def efficient_model(input_shape=(224, 224, 3)): model = EfficientNetB0(input_shape=input_shape, weights=None) #can do B7 if want larger input_layer = model.input last_layer = model.layers[-2].output x = Dense(1, activation='sigmoid')(last_layer) return Model(inputs=input_layer, outputs=x)
def _build(self): # inputs = keras.layers.Input((*self.input_dims, 1)) # x = keras.layers.Conv2D(filters=3, kernel_size=(1, 1), strides=(1, 1), name="initial_conv2d")(inputs) # x = keras.layers.BatchNormalization(axis=3, epsilon=1.001e-5, name='initial_bn')(x) # x = keras.layers.Activation('relu', name='initial_relu')(x) # engine = EfficientNetB0(include_top=False, input_shape=(*self.input_dims[:2], 3), classes=6) x = keras.layers.GlobalAveragePooling2D(name='avg_pool')(engine.output) x = keras.layers.Dropout(0.2)(x) x = keras.layers.Dense(keras.backend.int_shape(x)[1], activation="relu", name="dense_hidden_1")(x) x = keras.layers.Dropout(0.1)(x) out = keras.layers.Dense(6, activation="sigmoid", name='dense_output')(x) self.model = keras.models.Model(inputs=engine.input, outputs=out) self.model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['acc', 'mse'])
def _build(self): self, model = EfficientNetB0(include_top=False, input_shape=(*self.input_dims, 1), classes=6) self.model.compile(loss=weighted_log_loss, optimizer=keras.optimizers.Adam(0.0), metrics=[weighted_loss])
def build_efficient_net(n_classes, img_size, model_name): input_layer = Input((img_size, img_size, 3)) eff_net = EfficientNetB0(weights=None, include_top=False, input_tensor=input_layer) eff_net.trainable = True head = vanilla_head(eff_net.output, n_classes) return Model(input_layer, head, name=model_name)
def __init__(self, model_type='vgg19', layer='fc1', weights='imagenet', img_dims=(320, 240), **kwargs): """Initializes the object feature detector module efficientnet/probs Args: vgg19:fc2 """ super().__init__(**kwargs) self.weights = weights self.layer = layer self.session = tf.Session(graph=tf.Graph()) self.pre_input = None self.img_dims = img_dims self.queue = deque(maxlen=1) with self.session.graph.as_default(): set_session(self.session) if model_type == 'efficientnet': from efficientnet.keras import EfficientNetB0 from efficientnet.keras import preprocess_input self.pre_input = preprocess_input base_model = EfficientNetB0(weights=self.weights) self.xs, self.ys = 224, 224 if model_type == 'inveptionv3': from keras.applications.inception_v3 import InceptionV3 from keras.applications.inception_v3 import preprocess_input base_model = InceptionV3(weights=self.weights, include_top=True) self.pre_input = preprocess_input self.xs, self.ys = 299, 299 if model_type == 'vgg19': from keras.applications.vgg19 import VGG19 from keras.applications.vgg19 import preprocess_input base_model = VGG19(weights=self.weights, include_top=True) self.pre_input = preprocess_input self.xs, self.ys = 224, 224 # allow for other output layers print(base_model.summary()) self.model = Model(inputs=base_model.input, outputs=base_model.get_layer(self.layer).output) print('Feature extractor module setup complete.')
def _get_backbone_model(self): backbone_model = None if self.backbone_name == 'resnet18': backbone_model = ResNet18(input_shape=self.input_shape, include_top=False, weights='imagenet') if self.backbone_name == 'resnet34': backbone_model = ResNet34(input_shape=self.input_shape, include_top=False, weights='imagenet') elif self.backbone_name == 'mobilenetv2': backbone_model = MobileNetV2(input_shape=self.input_shape, include_top=False, weights='imagenet') elif self.backbone_name == 'efficientnetb0': backbone_model = EfficientNetB0(input_shape=self.input_shape, include_top=False, weights='imagenet') elif self.backbone_name == 'efficientnetb1': backbone_model = EfficientNetB1(input_shape=self.input_shape, include_top=False, weights='imagenet') elif self.backbone_name == 'efficientnetb3': backbone_model = EfficientNetB3(input_shape=self.input_shape, include_top=False, weights='imagenet') elif self.backbone_name == 'efficientnetb5': backbone_model = EfficientNetB5(input_shape=self.input_shape, include_top=False, weights='imagenet') elif self.backbone_name == 'densenet': backbone_model = DenseNet121(input_shape=self.input_shape, include_top=False, weights='imagenet') return backbone_model
def __init__(self, model_size , imag_size, num_cls): try: if model_size == "B0": model = EfficientNetB0(weights = 'imagenet', input_shape = (imag_size,imag_size,3), include_top = False) elif model_size == "B3": model = EfficientNetB3(weights = 'imagenet', input_shape = (imag_size,imag_size,3), include_top = False) elif model_size == "B5": model = EfficientNetB5(weights = 'imagenet', input_shape = (imag_size,imag_size,3), include_top = False) elif model_size == "B7": model = EfficientNetB7(weights = 'imagenet', input_shape = (imag_size,imag_size,3), include_top = False) ENet_out = model.output ENet_out = Flatten()(ENet_out) Hidden1_in = Dense(1024, activation="relu")(ENet_out) Hidden1_in = Dropout(0.5)(Hidden1_in) predictions = Dense(units = num_cls, activation="softmax")(Hidden1_in) self.model_f = Model(input = model.input, output = predictions) self.model_f.compile(optimizers.Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08), loss='categorical_crossentropy', metrics=[metrics.mae, metrics.categorical_accuracy]) except: print("only B0/B3/B5/B7 allowed")
if not os.path.isdir(result_path): os.mkdir(DEFAULT_IMAGE_DIR + '/result') os.mkdir(DEFAULT_IMAGE_DIR + '/cropped') ################# LOAD MODELS ####################### #### MASK-R-CNN mrcnn_model = modellib.MaskRCNN(mode="inference", config=config, model_dir=DEFAULT_LOGS_DIR) weights_path = DEFAULT_MRCNN_MODEL_DIR mrcnn_model.load_weights(weights_path, by_name=True) ##### EFFICIENTNET efficient_net = EfficientNetB0(weights='imagenet', input_shape=(32, 32, 3), include_top=False, pooling='max') eff_model = Sequential() eff_model.add(efficient_net) eff_model.add(Dense(units=120, activation='relu')) eff_model.add(Dense(units=120, activation='relu')) eff_model.add(Dense(units=1, activation='sigmoid')) eff_model.summary() eff_model.compile(optimizer=Adam(lr=0.0001), loss='binary_crossentropy', metrics=['accuracy']) eff_model.load_weights(DEFAULT_EFF_MODEL_DIR) #############################################################################3
#name: Image Classification #description: Image classification based of Efficientnet model #language: python #input: file file #output: map classes [Detected classes with probabilities] #tags: demo, panel, files, efficientnet #condition: file.isFile && file.size < 1e6 && (file.name.endsWith("jpg") || file.name.endsWith("jpeg") || file.name.endsWith("png")) #help-url: https://github.com/qubvel/efficientnet import numpy as np from skimage.io import imread from efficientnet.keras import EfficientNetB0 from keras.applications.imagenet_utils import decode_predictions from efficientnet.keras import center_crop_and_resize, preprocess_input image = imread(file) model = EfficientNetB0(weights='imagenet') image_size = model.input_shape[1] _image = center_crop_and_resize(image, image_size=image_size) _image = preprocess_input(_image) _image = np.expand_dims(_image, 0) predicted = model.predict(_image) predicted = decode_predictions(predicted)[0] classes = {} for p in predicted: classes[p[1]] = float(p[2])
verbose=1, save_best_only=True, mode="max", ) lr_reduce = ReduceLROnPlateau( monitor="val_loss", factor=np.sqrt(0.1), patience=5, verbose=1, cooldown=0, min_lr=0.5e-6, ) callbacks = [checkpoint, lr_reduce] conv_m = EfficientNetB0(weights="imagenet", include_top=False, input_shape=(size, size, 3)) conv_m.trainable = False model = Sequential() model.add(conv_m) model.add(AveragePooling2D(pool_size=(7, 7))) model.add(Flatten()) model.add(Dense(32, activation="relu")) model.add(BatchNormalization()) model.add(Dropout(0.5)) model.add(Dense(5, activation="softmax")) model.compile( loss="categorical_crossentropy", optimizer=SGD(lr=0.1, momentum=0.9), metrics=["accuracy"],
target_size=(img_rows, img_cols), batch_size=batch_size, class_mode='categorical')#多分类; 'binary') print("train_generator.filenames",train_generator.filenames)# 按顺序输出文件的名字 print("train_generator.class_indices", train_generator.class_indices) #输出对应的标签文件夹 validation_generator = test_datagen.flow_from_directory( test_data_dir, target_size=(img_rows, img_cols), batch_size=batch_size, class_mode='categorical')#多分类; 'binary') print("validation_generator.filenames",validation_generator.filenames)# 按顺序输出文件的名字 print("validation_generator.class_indices", validation_generator.class_indices) #输出对应的标签文件夹 ##################训练网络模型########################### # build model base_model = EfficientNetB0(input_shape=(img_rows, img_cols, 3), weights='imagenet', include_top=False) x = keras.layers.GlobalAveragePooling2D()(base_model.output) output = keras.layers.Dense(num_classes, activation='softmax')(x) model = keras.models.Model(inputs=[base_model.input], outputs=[output]) # initiate optimizer opt = keras.optimizers.SGD(lr=0.001) # keras.optimizers.Adam(lr=0.001) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) # optimizer='SGD' # train history = model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, # typically steps_per_epoch= dataset samples 3120 / batch_size 4 epochs=epochs, # finacal epoches validation_data=validation_generator, validation_steps=nb_validation_samples// batch_size, # typically validation_steps = validation dataset samples 780 / batch_size 4 verbose = 2, )
json_file.close() model = model_from_json(model_json) model.load_weights(args["weights"]) model.compile( optimizer=Adam(lr=0.0001), loss="binary_crossentropy", metrics=["accuracy"], ) break elif choice in ("n", "N"): sys.exit(0) else: # initializeaza si compileaza modelul EfficientNet (foloseste transfer learning) efficient_net = EfficientNetB0(weights="imagenet", input_shape=(256, 128, 3), include_top=False, pooling="max") model = Sequential() model.add(efficient_net) model.add(Dense(units=120, activation="relu")) model.add(Dense(units=120, activation="relu")) model.add(Dense(units=2, activation="softmax")) model.compile(optimizer=Adam(lr=0.0001), loss="binary_crossentropy", metrics=["accuracy"]) if not os.path.isfile(args["model"]): model_json = model.to_json() with open(args["model"], "w") as json_file: json_file.write(model_json) model.summary()
x_test, y_test = load_data(dataset_test_dst) print("x_train.shape = {}".format(x_train.shape)) print("x_test.shape = {}".format(x_test.shape)) x_train = x_train.astype('float32') / 255 x_test = x_test.astype('float32') / 255 # one-hot encoding num_cls = 5 Y_train = np_utils.to_categorical(y_train, num_cls) Y_test = np_utils.to_categorical(y_test, num_cls) #------------------------------------end of importing data-----------------------------# #------------------------------------start building model-----------------------------# model = EfficientNetB0(weights='imagenet', input_shape=(imag_size, imag_size, 3), include_top=False) ENet_out = model.output ENet_out = Flatten()(ENet_out) Hidden1_in = Dense(1024, activation="relu")(ENet_out) Hidden1_in = Dropout(0.5)(Hidden1_in) predictions = Dense(units=num_cls, activation="softmax")(Hidden1_in) model_f = Model(input=model.input, output=predictions) model_f.compile(optimizers.Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08), loss='categorical_crossentropy',
def setup(): return EfficientNetB0(weights='imagenet')
model_split = 'block2a_expand_conv' layer_idx = [ i for i in range(len(model.layers)) if model.layers[i].name == model_split ][0] for i, layer in enumerate(model.layers): if i < layer_idx or isinstance(layer, layers.BatchNormalization): layer.trainable = False else: layer.trainable = True else: base_model = EfficientNetB0(include_top=False, weights='imagenet', input_shape=(None, None, 3), pooling='avg') x = base_model.output predictions = layers.Dense(1, activation='sigmoid')(x) model = Model(inputs=base_model.input, outputs=predictions) if freeze: for layer in base_model.layers: layer.trainable = False else: model_split = 'block2a_expand_conv' layer_idx = [ i for i in range(len(model.layers))
opt = Adam(lr=INIT_LR) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, min_lr=1e-10, verbose=1, cooldown=2) model_checkpoint = ModelCheckpoint('EFNB3Weight.h5', monitor='val_loss', save_best_only=True, period=3) input_tensor = Input(shape=(28, 28, 3)) model = EfficientNetB0(weights=None, include_top=False, input_tensor=input_tensor) x = model.output x = Flatten()(x) x = Dense(1024, activation="relu")(x) x = Dropout(0.5)(x) predictions = Dense(units=10, activation="softmax")(x) model_f = Model(input=model.input, output=predictions) model_f.compile(Adam(lr=INIT_LR), loss='categorical_crossentropy', metrics=['accuracy']) print(model.summary()) # train the network