def create_model(conf): """ """ if conf["model"] == 'EfficientNetB0': from efficientnet.tfkeras import EfficientNetB0 as Network # 4.7M params elif conf["model"] == 'EfficientNetB1': from efficientnet.tfkeras import EfficientNetB1 as Network # 7.2M params elif conf["model"] == 'EfficientNetB2': from efficientnet.tfkeras import EfficientNetB2 as Network # 8.5M params elif conf["model"] == 'EfficientNetB3': from efficientnet.tfkeras import EfficientNetB3 as Network # 11.5M params elif conf["model"] == 'EfficientNetB4': from efficientnet.tfkeras import EfficientNetB4 as Network # 18.6M params elif conf["model"] == 'EfficientNetB5': from efficientnet.tfkeras import EfficientNetB5 as Network # 29.5M params elif conf["model"] == 'EfficientNetB6': from efficientnet.tfkeras import EfficientNetB6 as Network # 42.2M params elif conf["model"] == 'EfficientNetB7': from efficientnet.tfkeras import EfficientNetB7 as Network # 65.4M params elif conf["model"] == 'ResNet50': from tensorflow.keras.applications import ResNet50 as Network # 23,6M params base_model = Network( weights=conf["weights"], # "imagenet", None or "noisy-student" include_top=False, input_shape=conf["img_shape"]) # Unfreeze the layers. I.E we're just using the pre-trained # weights as initial weigths and biases and train over them base_model.trainable = True # Define model model = Sequential() model.add(base_model) model.add(layers.GlobalAveragePooling2D()) model.add(layers.Dropout(conf["dropout"])) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dropout(conf["dropout"])) model.add( layers.Dense(conf["num_classes"], activation=conf["final_activation"])) if conf['optimizer'] == 'Adam': opt = tf.keras.optimizers.Adam(learning_rate=conf["learning_rate"]) elif conf['optimizer'] == 'SGD': opt = tf.keras.optimizers.SGD(learning_rate=conf["learning_rate"]) model.compile(optimizer=opt, loss='sparse_categorical_crossentropy', metrics=['sparse_categorical_accuracy']) if conf["verbosity"]: model.summary() return model
def build_efficientnet(self): """Builds efficient model with dense layers on top Returns: keras.models.Model :return: """ from efficientnet.tfkeras import EfficientNetB0 strategy = tf.distribute.MirroredStrategy() with strategy.scope(): conv_base = EfficientNetB0(weights='noisy-student', include_top=False, input_shape=(224, 224, 3)) outputconv_base = conv_base.output t_flat = Flatten()(outputconv_base) t_dense1 = Dense(1024, activation='relu')(t_flat) t_dense2 = Dense(256, activation='relu')(t_dense1) t_dense3 = Dense(128, activation='relu')(t_dense2) t_do = Dropout(0.5)(t_dense3) predictions = Dense(2, activation='softmax')(t_do) model = Model(inputs=conv_base.input, outputs=predictions, name='model') conv_base.trainable = False opt = tf.keras.optimizers.Adam(learning_rate=0.0002) model.compile( loss=tf.keras.losses.BinaryCrossentropy(label_smoothing=0.01), optimizer=opt, metrics=['accuracy']) return model
def SR_model(num_classes, dropout, mc_dropout, input_dim, training, pooling='avg'): inputs = Input(input_dim) base_model = EfficientNetB0(include_top=False, weights='imagenet', input_tensor=inputs) base_model.trainable = True x = base_model.output x = Dropout(dropout, name='top_dropout_1')(x, training=training) if pooling == 'avg': x = GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = GlobalMaxPooling2D(name='max_pool')(x) x = Dropout(dropout, name='top_dropout_2')(x, training=training) x = Dense(512, activation='relu', name='dense_512')(x) x = BatchNormalization()(x) x = Dropout(dropout, name='top_dropout_3')(x, training=training) x = Lambda(lambda x: K.dropout(x, level=mc_dropout))(x) #classification head (f) sr = Dense(num_classes, activation='softmax', name='dense_f')(x) return Model(inputs=inputs, outputs=sr)
def __init__(self, dropout=0.2, mc_dropout=0.2, num_classes=1, training=True, input_dim=(224, 224, 3), pooling="avg"): self.c = 0.75 self.lamda = 32 self.alpha = 0.5 self.dropout = dropout self.mc_dropout = mc_dropout self.pooling = pooling self.input_dim = input_dim self.training = training self.num_classes = num_classes #create model inputs = Input(shape=self.input_dim) base_model = EfficientNetB0(include_top=False, weights='imagenet', input_tensor=inputs) base_model.trainable = True x = base_model.output x = Dropout(self.dropout, name='top_dropout_1')(x, training=self.training) if pooling == 'avg': x = GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = GlobalMaxPooling2D(name='max_pool')(x) x = Dropout(self.dropout, name='top_dropout_2')(x, training=self.training) x = Dense(512, activation='relu', name='dense_512')(x) x = BatchNormalization()(x) x = Dropout(self.mc_dropout, name='top_dropout_3')(x, training=self.training) x = Lambda(lambda x: K.dropout(x, level=self.mc_dropout))(x) #classification head (f) f = Dense(self.num_classes, activation='softmax', name='f_head')(x) #selection head (g) g = Dense(512, activation='relu', name='dense_512_g')(x) g = BatchNormalization()(g) # this normalization is identical to initialization of batchnorm gamma to 1/10 g = Lambda(lambda a: a / 10)(g) g = Dense(1, activation='sigmoid', name='g_head')(g) # auxiliary head (h) selective_output = Concatenate(axis=1, name="selective_head")([f, g]) auxillary_output = Dense(self.num_classes, activation='softmax', name='auxilary_head')(x) self.model = Model(inputs=inputs, outputs=[selective_output, auxillary_output])
def efficientnet(b, weights='imagenet', include_top=False, input_shape=(None, None, 3)): """Loads the appropriate EfficientNet model with weights :param b: The size of the EfficientNet model. :type b: int :param weights: The pretrained weights to load. Defaults to iamgenet. :type weights: str :param include_top: Include the pretrained softmax layer. Defaults to False :type include_top: bool :param input_shape: Shape of input images. Defaults to no hight or width, 3 channels. :type input_shape: Tuple :return: EfficientNet Model. :rtype: tf.keras.models.Model """ if b == 0: return EfficientNetB0(weights=weights, include_top=include_top, input_shape=input_shape) elif b == 1: return EfficientNetB1(weights=weights, include_top=include_top, input_shape=input_shape) elif b == 2: return EfficientNetB2(weights=weights, include_top=include_top, input_shape=input_shape) elif b == 3: return EfficientNetB3(weights=weights, include_top=include_top, input_shape=input_shape) elif b == 4: return EfficientNetB4(weights=weights, include_top=include_top, input_shape=input_shape) elif b == 5: return EfficientNetB5(weights=weights, include_top=include_top, input_shape=input_shape) elif b == 6: return EfficientNetB6(weights=weights, include_top=include_top, input_shape=input_shape) elif b == 7: return EfficientNetB7(weights=weights, include_top=include_top, input_shape=input_shape) else: raise Exception("Invalid size for EfficientNet")
def load_effnet(shape, efftype = 'B0', weights = 'imagenet', trainable = False): if efftype == 'B0': backbone = EfficientNetB0(weights = weights, include_top = False, input_shape = shape) if efftype == 'B3': backbone = EfficientNetB3(weights = weights, include_top = False, input_shape = shape) if efftype == 'B5': backbone = EfficientNetB5(weights = weights, include_top = False, input_shape = shape) for layer in backbone.layers: layer.trainable = trainable return backbone
def __init__(self): num_cls = 5 imag_size = 224 #------------------------------------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) self.model_f = Model(inputs = model.input, outputs = 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]) self.model_f.load_weights("efficientnetB0_weights.h5")
def build_model(self): self.base_model = EfficientNetB0(weights='noisy-student', include_top=False) self.base_model.trainable = True self.x = self.base_model.output self.x = GlobalAveragePooling2D()(self.x) self.x = Dense(512, activation='relu')(self.x) self.x = Dropout(rate=0.2)(self.x) self.x = Dense(128, activation='relu')(self.x) self.x = Dropout(rate=0.2)(self.x) self.preds = Dense(1, activation='sigmoid')(self.x) self.model = Model(inputs=self.base_model.input, outputs=self.preds) self.model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
def get_base_model(modelname): if modelname == 'vgg16': print('MODELO CARGADO: VGG16') return tf.keras.applications.VGG16(input_shape=(img_size(), img_size(), 3), include_top=False, weights='imagenet') elif modelname == 'mobilenet': print('MODELO CARGADO: MOBILENET') return tf.keras.applications.MobileNetV2(input_shape=(img_size(), img_size(), 3), include_top=False, weights='imagenet') elif modelname == 'efficientnet': print('MODELO CARGADO: EFFICIENTNET') return EfficientNetB0(input_shape=(img_size(), img_size(), 3), include_top=False, weights='imagenet')
def Eff_net(): # loading pretrained conv base model conv_base = EfficientNetB0(weights="imagenet", include_top=true, input_shape=(200, 200, 3)) dropout_rate = 0.05 model = models.Sequential() model.add(conv_base) model.add(layers.Flatten(name="flatten")) # model.add(layers.Dense(32, activation="relu")) # model.add(layers.Dropout(dropout_rate)) # model.add(layers.Dense(16, activation="relu")) # model.add(layers.Dropout(dropout_rate)) # model.add(layers.Dense(256, activation='relu', name="fc1")) model.add(layers.Dense(1, activation="sigmoid", name="fc_out")) conv_base.trainable = False return model
def __init__(self, arch, pretrained=None): super(EfficientNet, self).__init__() self.net = EfficientNetB0(include_top=False, weights=pretrained, input_shape=(224, 224, 3), classes=10) # elif arch == 'efficientnet-b2': # self.net = EfficientNetB2(include_top=False, # weights=pretrained, # input_shape=(260, 260, 3), # classes=10) self.feature_3 = self.net.get_layer('block4a_expand_activation').output self.feature_2 = self.net.get_layer('block6a_expand_activation').output self.feature_1 = self.net.get_layer('top_activation').output self.feature_extractor = tf.keras.Model( inputs=self.net.input, outputs=[self.feature_3, self.feature_2, self.feature_1])
def create_efficientNet(): if image_model == 4: baseModel = EfficientNetB4(weights='imagenet', include_top=False, input_shape=input_size) elif image_model == 2: baseModel = EfficientNetB2(weights='imagenet', include_top=False, input_shape=input_size) elif image_model == 0: baseModel = EfficientNetB0(weights='imagenet', include_top=False, input_shape=input_size) probs = baseModel.layers.pop() top_conv = probs.input headModel = layers.Activation(swish, name='top_activation')(top_conv) headModel = layers.GlobalAveragePooling2D(name='avg_pool')(headModel) headModel = layers.Dropout(0.2, name='top_dropout')(headModel) headModel = layers.Dense(num_classes, activation='softmax')(headModel) model = Model(inputs=baseModel.input, outputs=headModel) return model
def __init__(self): self.num_cls = 5 self.imag_size = 224 model = EfficientNetB0(weights='imagenet', input_shape=(self.imag_size, self.imag_size, 3), include_top=False) outputs = model.output outputs = Flatten()(outputs) Hidden1_inputs = Dense(1024, activation="relu")(outputs) Hidden1_inputs = Dropout(0.5)(Hidden1_inputs) predictions = Dense(units=self.num_cls, activation="softmax")(Hidden1_inputs) self.model_f = Model(inputs=model.input, outputs=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])
def Eff_net_B0_simplest(Net_file_path, Trainable='All', load=True): # loading pretrained conv base model conv_base = EfficientNetB0(weights="imagenet", include_top=False, input_shape=(200, 200, 3)) dropout_rate = 0.2 model = models.Sequential() model.add(conv_base) model.add(layers.Flatten(name="flatten")) model.add(tf.keras.layers.BatchNormalization()) model.add(layers.Dense(32, activation="relu", name="Dense1_add")) # model.add(tf.keras.layers.BatchNormalization()) model.add(layers.Dropout(dropout_rate)) model.add(layers.Dense(16, activation="relu", name="Dense2_add")) # model.add(tf.keras.layers.BatchNormalization()) model.add(layers.Dropout(dropout_rate)) model.add(layers.Dense(1, activation="sigmoid", name="fc_out")) if load: model.load_weights(Net_file_path) if Trainable == 'Classifier': conv_base.trainable = False elif Trainable == 'Class_FirstConv': conv_base.trainable = True set_trainable = False for layer in conv_base.layers: if layer.name == 'multiply_16': set_trainable = True if set_trainable: layer.trainable = True else: layer.trainable = False elif Trainable == 'Class_SecondConv': conv_base.trainable = True set_trainable = False for layer in conv_base.layers: if layer.name == 'multiply_14': set_trainable = True if set_trainable: layer.trainable = True else: layer.trainable = False elif Trainable == 'Class_ThirdConv': conv_base.trainable = True set_trainable = False for layer in conv_base.layers: if layer.name == 'multiply_12': set_trainable = True if set_trainable: layer.trainable = True else: layer.trainable = False return model
print(f'Train of Label : {x_test.shape}') print(f'Test of Label : {y_test.shape}') x_test = x_test[:5138] y_test = y_test[:5138] print(x_train.shape) print(y_train.shape) print(x_test.shape) print(y_test.shape) # model BATCH_SIZE = 64 EPOCHS = 10 model = tf.compat.v1.keras.models.Sequential([ EfficientNetB0(include_top=False, input_shape=(224, 224, 3), pooling='avg'), tf.compat.v1.keras.layers.Dense(20), tf.compat.v1.keras.layers.BatchNormalization(), tf.compat.v1.keras.layers.Activation('softmax') ]) # fitting model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(lr=0.01), metrics=['accuracy']) hist = model.fit(x_train, y_train, epochs=EPOCHS, batch_size=BATCH_SIZE, validation_split=0.2)
def run_inference(tfrecords_folder, output_folder, batch_size=1000): Path(output_folder).mkdir(parents=True, exist_ok=True) model = EfficientNetB0(weights="imagenet", include_top=False, pooling="avg") tfrecords_to_write_embeddings(tfrecords_folder, output_folder, model, batch_size)
def run_inference_from_files(image_folder, output_folder, num_shards=10, batch_size=1000): model = EfficientNetB0(weights="imagenet", include_top=False, pooling="avg") list_ds = list_files(image_folder) compute_save_embeddings(list_ds, output_folder, num_shards, model, batch_size)
#from efficientnet.tfkeras import center_crop_and_resize, preprocess_input from tensorflow.keras import models from tensorflow.keras import layers from keras.datasets import cifar100 from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras import optimizers from tensorflow.keras.utils import plot_model from IPython.display import Image from keras.utils import to_categorical import matplotlib.pyplot as plt from skimage.transform import resize import numpy as np import cv2 from keras import backend as K baseModel = EfficientNetB0(weights="imagenet") #print(baseModel.summary()) dropout_rate = 0.2 batch_size = 64 epochs = 25 baseModel = EfficientNetB0(weights="imagenet", include_top=False) #print(baseModel.summary()) model = models.Sequential() model.add(baseModel) model.add(layers.GlobalMaxPooling2D(name="gmp")) if dropout_rate > 0: model.add(layers.Dropout(dropout_rate, name="dropout_out"))
f.write("Model : " + model_name) f.close() else: pass train_ds = make_tf_dataset(train_images, train_labels) valid_ds = make_tf_dataset(valid_images, valid_labels) train_ds = train_ds.repeat().batch(BATCH_SIZE) train_ds = train_ds.prefetch(AUTOTUNE) valid_ds = valid_ds.repeat().batch(BATCH_SIZE) valid_ds = valid_ds.prefetch(AUTOTUNE) base_model = EfficientNetB0(input_shape=(IMG_SIZE, IMG_SIZE, 3), weights="imagenet", include_top=False) avg = tf.keras.layers.GlobalAveragePooling2D()(base_model.output) output = tf.keras.layers.Dense(train_labels_len, activation="sigmoid")(avg) model = tf.keras.Model(inputs=base_model.input, outputs=output) for layer in base_model.layers: layer.trainable = True # optimizer = tf.keras.optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # model.compile(loss="categorical_crossentropy", optimizer=optimizer, metrics=["accuracy"]) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model.summary()
# train_generator = CutMixImageDataGenerator( # generator1=train_generator1, # generator2=train_generator2, # img_size=(224,224), # batch_size=64 # ) test_generator = test_datagen.flow_from_directory( '/home/john/Study/pytorch_retinaface/facedetect/data/test', target_size=(224, 224), batch_size=64, class_mode='binary') # '/home/john/Study/mask/mask_model_0925.h5' # 2. 모델 model = Sequential() model.add(EfficientNetB0(include_top=False, pooling='avg')) model.add(Dropout(0.1, name='hidden1')) #model.add(GlobalAveragePooling2D(name='hidden2')) model.add(Dense(1, activation='sigmoid', name='s1')) model.summary() # 3. 훈련 # tb_hist = TensorBoard(log_dir='./graph', histogram_freq=0, write_graph=True, write_images=True, update_freq='batch') # parallel_model = multi_gpu_model(model, gpus=['/xla_gpu:1', '/xla_gpu:2']) model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(label_smoothing=0.9), metrics=['acc']) hist = model.fit_generator(train_generator, steps_per_epoch=100, epochs=100, validation_data=test_generator,
import os import sys import numpy as np from skimage.io import imread import matplotlib.pyplot as plt sys.path.append('..') # if you use tensorflow.keras: from efficientnet.tfkeras import EfficientNetB0 from efficientnet.tfkeras import center_crop_and_resize, preprocess_input from tensorflow.keras.applications.imagenet_utils import decode_predictions # test image test_b_2 = "../predict/pics/ROI.png" image = imread(test_b_2) plt.figure(figsize=(10, 10)) plt.imshow(image) plt.show() # loading pretrained model model = EfficientNetB0(weights='imagenet') # preprocess input image_size = model.input_shape[1] x = center_crop_and_resize(image, image_size=image_size) x = preprocess_input(x) print(x.shape) x = np.expand_dims(x, 0) # make prediction and decode y = model.predict(x) print(decode_predictions(y))
rotation_range=45, width_shift_range=0.2, height_shift_range=0.2) # Validation data generator datagen_val = ImageDataGenerator(rescale=1. / 255) ################################## ## MODEL ######################### ################################## input_shape = (IMG_ROWS, IMG_COLS, 3) #### Efficient #### effnet = EfficientNetB0(weights='imagenet', include_top=False, input_shape=input_shape) effnet.trainable = True x = effnet.output x = Flatten()(x) x = Dense(2048, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(1024, activation='relu')(x) x = Dropout(0.5)(x) predictions = Dense(NUM_CLASSES, activation='sigmoid')(x) model = Model(inputs=effnet.input, outputs=predictions) ###################
def build_model(base_model, input_shape, metrics, loss, loss_weights, **kwargs): if base_model == 'resnet50': from tensorflow.keras.applications import ResNet50 base_model = ResNet50(include_top=False, weights='imagenet', input_shape=input_shape) if base_model == 'densenet121': from tensorflow.keras.applications import DenseNet121 base_model = DenseNet121(include_top=False, weights='imagenet', input_shape=input_shape) if base_model == 'efficientnetb0': from efficientnet.tfkeras import EfficientNetB0 base_model = EfficientNetB0(include_top=False, weights='imagenet', input_shape=input_shape) if base_model == 'efficientnetb1': from efficientnet.tfkeras import EfficientNetB1 base_model = EfficientNetB1(include_top=False, weights='imagenet', input_shape=input_shape) if base_model == 'efficientnetb2': from efficientnet.tfkeras import EfficientNetB2 base_model = EfficientNetB2(include_top=False, weights='imagenet', input_shape=input_shape) if base_model == 'efficientnetb3': from efficientnet.tfkeras import EfficientNetB3 base_model = EfficientNetB3(include_top=False, weights='imagenet', input_shape=input_shape) if base_model == 'efficientnetb4': from efficientnet.tfkeras import EfficientNetB4 base_model = EfficientNetB4(include_top=False, weights='imagenet', input_shape=input_shape) if base_model == 'efficientnetb5': from efficientnet.tfkeras import EfficientNetB5 base_model = EfficientNetB5(include_top=False, weights='imagenet', input_shape=input_shape) x_in = Input(shape=input_shape) x = Conv2D(3, (3, 3), padding='same')(x_in) x = base_model(x) x = GlobalAvgPool2D()(x) x = BatchNormalization()(x) x = Dropout(0.5)(x) out_grapheme = Dense(168, activation='softmax', name='root')(x) out_vowel = Dense(11, activation='softmax', name='vowel')(x) out_consonant = Dense(7, activation='softmax', name='consonant')(x) model = Model(inputs=x_in, outputs=[out_grapheme, out_vowel, out_consonant]) model.compile(Adam(lr=0.0001), metrics=metrics, loss=loss, loss_weights=loss_weights) return model
from efficientnet.tfkeras import EfficientNetB0 import numpy as np image = np.random.randint(0, 255, (1, 224, 224, 3)) / 255. label = np.array([1]) model = EfficientNetB0() model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['acc']) model.fit(image, label, epochs=1) pred = model.predict(image) print(pred)
"dogs.csv") dogs_photos_path = os.path.join(embedding_utils.DATASET_PATH, "dog_data_small", "dogs_photos.csv") dog_images_path = os.path.join(embedding_utils.DATASET_PATH, "resized_dogs_small") embeddings_path = os.path.join(embedding_utils.DATASET_PATH, "embeddings_small") # Variable to hold the dogs embeddings embeddings = None stacked_embeddings = None embeddings_id_to_name = None faiss_index = None dogs = None efficientnet_model = EfficientNetB0(weights='imagenet', include_top=False, pooling="avg") def create_faiss_index(stacked_embeddings): d = 1280 index = faiss.IndexFlatIP(d) index.add(stacked_embeddings) return index def faiss_search(index, id_to_name, emb, k=5): # Peform actual search D, I = index.search(np.expand_dims(emb, 0), k) return list(zip(D[0], [id_to_name[x] for x in I[0]]))
headModel = baseModel.output headModel = Dense(51, activation='softmax')(headModel) elif network == "NASNetMobile": print(network) train, test, lb2, labelsTest = preprocessing(network) baseModel = NASNetMobile(weights=pretraining, include_top=False, input_tensor=Input(shape=(224, 224, 3)), pooling="avg") headModel = baseModel.output headModel = Dense(51, activation='softmax')(headModel) elif network == "EfficientNetB0": print(network) train, test, lb2, labelsTest = preprocessing_EfficcientNet() baseModel = EfficientNetB0(weights=pretraining, include_top=False, input_tensor=Input(shape=(224, 224, 3)), pooling="avg") headModel = baseModel.output headModel = Dropout(0.2)(headModel) headModel = Dense(51, activation='softmax')(headModel) else: print(network) train, test, lb2, labelsTest = preprocessing_EfficcientNet() baseModel = EfficientNetB3(weights=pretraining, include_top=False, input_tensor=Input(shape=(224, 224, 3)), pooling="avg") headModel = baseModel.output headModel = Dropout(0.2)(headModel) headModel = Dense(51, activation='softmax')(headModel)
test_datagen = ImageDataGenerator(rescale=1 / 255 #rescale the tensor values to [0,1] ) test_generator = test_datagen.flow_from_directory(directory=test_path, classes=['real', 'fake'], target_size=(input_size, input_size), color_mode="rgb", class_mode=None, batch_size=1, shuffle=False) # Train a CNN classifier efficient_net = EfficientNetB0(weights='imagenet', input_shape=(input_size, input_size, 3), include_top=False, pooling='max') model = Sequential() model.add(efficient_net) model.add(Dense(units=512, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(units=128, activation='relu')) model.add(Dense(units=1, activation='sigmoid')) model.summary() # Compile model model.compile(optimizer=Adam(lr=0.0001), loss='binary_crossentropy', metrics=['accuracy'])
def train_model(CONFIG): checkpoint_path = CONFIG['checkpoint_path'].format( experiment_i=CONFIG['experiment_i']) checkpoint_dir = os.path.dirname(checkpoint_path) # Create a callback that saves the model's weights every 1 epoch cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path, verbose=1, save_weights_only=True, save_best_only=True) #early_stopping_callback = tf.keras.callbacks.EarlyStopping( # monitor='val_loss', min_delta=0, patience=5, verbose=0, mode='min', # baseline=None, restore_best_weights=True #) tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir=CONFIG['log_dir'].format(experiment_i=CONFIG['experiment_i']), update_freq='epoch') callbacks = [tensorboard_callback, cp_callback] image_dir = CONFIG['image_dir'] base_model = EfficientNetB0(weights='noisy-student', include_top=False) base_model.trainable = True x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1000, activation='relu')(x) x = Dropout(rate=0.2)(x) preds = Dense(200, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=preds) train_datagen = ImageDataGenerator(rotation_range=20, zoom_range=0.15, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15, horizontal_flip=True, fill_mode="nearest") val_datagen = ImageDataGenerator() train_generator = train_datagen.flow_from_directory( directory=os.path.join(image_dir, 'train'), batch_size=32, target_size=(224, 224), seed=3, shuffle=True, class_mode="categorical") val_generator = val_datagen.flow_from_directory(directory=os.path.join( image_dir, 'val'), batch_size=32, target_size=(224, 224), seed=3, shuffle=False, class_mode="categorical") model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy']) step_size_train = train_generator.n // train_generator.batch_size step_size_val = val_generator.n // val_generator.batch_size model.fit(train_generator, validation_data=val_generator, validation_steps=step_size_val, steps_per_epoch=step_size_train, epochs=CONFIG['epochs'], callbacks=callbacks) path_to_save = CONFIG['saved_model'].format( experiment_i=CONFIG['experiment_i']) print(f"Saving model to {path_to_save}...") model.save(path_to_save) print("Done") return model