def tiny_yolo4lite_resnet50v2_body(inputs, num_anchors, num_classes, use_spp=True): '''Create Tiny YOLO_v4 Lite ResNet50V2 model CNN body in keras.''' resnet50v2 = ResNet50V2(input_tensor=inputs, weights='imagenet', include_top=False) print('backbone layers number: {}'.format(len(resnet50v2.layers))) # input: 416 x 416 x 3 # post_relu: 13 x 13 x 2048 # conv4_block5_out: 26 x 26 x 1024 # conv3_block3_out: 52 x 52 x 512 # f1 :13 x 13 x 2048 f1 = resnet50v2.get_layer('post_relu').output # f2: 26 x 26 x 1024 f2 = resnet50v2.get_layer('conv4_block5_out').output f1_channel_num = 1024 f2_channel_num = 512 y1, y2 = tiny_yolo4lite_predictions( (f1, f2), (f1_channel_num, f2_channel_num), num_anchors, num_classes, use_spp) return Model(inputs, [y1, y2])
def __init__(self, img_w: int, img_h: int, channels: int): ''' Args: img_w: Pixel width for input images img_h: Pixel height for input images channels: number of channels for input images ''' self.img_w = img_w self.img_h = img_h self.channels = channels self.resnet50v2 = ResNet50V2(weights='imagenet', include_top=False, input_tensor=layers.Input( shape=(self.img_h, self.img_w, 3), name='input_sentinel')) # Load part of the VGG without the top layers into 'pretrained' model self.pretrained_model = models.Model( inputs=self.resnet50v2.input, outputs=self.resnet50v2.get_layer('conv5_block3_out').output) self.config = self.pretrained_model.get_config() self.hs_inputs = Input(shape=(self.img_h, self.img_w, self.channels), name='input')
def model_builder(hp): model_type = hp.Choice('model_type', ['ResNet50V2']) if model_type == 'ResNet50V2': base_model = ResNet50V2(input_shape=( IMG_WIDTH, IMG_HEIGHT, 3), include_top=False, weights='imagenet') head_model = base_model for layers in base_model.layers[:45]: layers.trainable = True head_model = head_model.output head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model) head_model = tf.keras.layers.Flatten(name="Flatten")(head_model) hp_units = hp.Int('units', min_value=1300, max_value=1750, step=150) head_model = tf.keras.layers.Dense( hp_units, activation='relu')(head_model) head_model = tf.keras.layers.Dropout(0.3)(head_model) prediction_layer = tf.keras.layers.Dense( len(classes), activation='relu')(head_model) model = tf.keras.Model(inputs=base_model.input, outputs=prediction_layer) hp_learning_rate = hp.Choice( 'learning_rate', values=[1e-2, 1e-3, 1e-4]) model.compile(optimizer=keras.optimizers.Adam(learning_rate=hp_learning_rate), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy']) return model
def define_model(n_layers=45, BASE_MODEL='ResNet50V2'): if BASE_MODEL == 'ResNet50V2': # Pre-trained model with MobileNetV2 base_model = ResNet50V2(input_shape=( IMG_WIDTH, IMG_HEIGHT, 3), include_top=False, weights='imagenet') head_model = base_model for layers in base_model.layers[:n_layers]: layers.trainable = True head_model = head_model.output head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model) head_model = tf.keras.layers.Flatten(name="Flatten")(head_model) head_model = tf.keras.layers.Dense(1600, activation='relu')(head_model) head_model = tf.keras.layers.Dropout(0.2)(head_model) prediction_layer = tf.keras.layers.Dense( len(classes), activation='softmax')(head_model) model = tf.keras.Model(inputs=base_model.input, outputs=prediction_layer) if BASE_MODEL == 'InceptionV3': base_model = InceptionV3(input_shape=( IMG_WIDTH, IMG_HEIGHT, 3), include_top=False, weights='imagenet') head_model = base_model for layers in base_model.layers[:n_layers]: layers.trainable = False head_model = head_model.output head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model) head_model = tf.keras.layers.Flatten(name="Flatten")(head_model) head_model = tf.keras.layers.Dense(1024, activation='relu')(head_model) head_model = tf.keras.layers.Dropout(0.5)(head_model) prediction_layer = tf.keras.layers.Dense( len(classes), activation='softmax')(head_model) model = tf.keras.Model(inputs=base_model.input, outputs=prediction_layer) return model
def __init__(self, args, encoder_shape=(224, 224, 3)): super().__init__(name="Generator") self._args = args # Create the ResNet50V2 Encoder self._encoder = ResNet50V2(include_top=False, weights="imagenet", input_shape=encoder_shape, pooling="avg") # Build the Regressor that will perform IEF self._dense_1 = layers.Dense(1024, activation="relu") self._dense_2 = layers.Dense(1024, activation="relu") self._dropout_1 = layers.Dropout(0.5) self._dropout_2 = layers.Dropout(0.5) small_xavier = tf.initializers.VarianceScaling(.01, mode='fan_avg', distribution='uniform') self._reg_out = layers.Dense(85, kernel_initializer=small_xavier) # Load the initial mean theta params and create # a trainable variable for it self._mean_theta = tf.Variable(load_mean_theta(self._args), name='mean_theta', trainable=True)
def yolo4_resnet50v2_body(inputs, num_anchors, num_classes): """Create YOLO_V4 ResNet50V2 model CNN body in Keras.""" resnet50v2 = ResNet50V2(input_tensor=inputs, weights='imagenet', include_top=False) print('backbone layers number: {}'.format(len(resnet50v2.layers))) # input: 416 x 416 x 3 # post_relu: 13 x 13 x 2048 # conv4_block5_out: 26 x 26 x 1024 # conv3_block3_out: 52 x 52 x 512 # f1 :13 x 13 x 2048 f1 = resnet50v2.get_layer('post_relu').output # f2: 26 x 26 x 1024 f2 = resnet50v2.get_layer('conv4_block5_out').output # f3 : 52 x 52 x 512 f3 = resnet50v2.get_layer('conv3_block3_out').output f1_channel_num = 1024 f2_channel_num = 512 f3_channel_num = 256 y1, y2, y3 = yolo4_predictions( (f1, f2, f3), (f1_channel_num, f2_channel_num, f3_channel_num), num_anchors, num_classes) return Model(inputs=inputs, outputs=[y1, y2, y3])
def build_COVIDNet(num_classes=3, flatten=True, checkpoint='',args=None): if args.model == 'resnet50v2': base_model = ResNet50V2(include_top=False, weights='imagenet', input_shape=(args.img_size, args.img_size, 3)) x = base_model.output if args.model =='mobilenetv2': base_model = MobileNetV2(include_top=False, weights='imagenet', input_shape=(args.img_size, args.img_size, 3)) x = base_model.output if args.model == 'custom': base_model = covidnet(input_tensor=None, input_shape=(args.img_size, args.img_size, 3), classes=3) x = base_model.output if args.model == 'EfficientNet': import efficientnet.tfkeras as efn base_model = efn.EfficientNetB4(weights=None, include_top=True, input_shape=(args.img_size, args.img_size, 3), classes=3) x = base_model.output if flatten: x = Flatten()(x) else: # x = GlobalAveragePooling2D()(x) x = GlobalMaxPool2D()(x) if args.datapipeline == 'covidx': x = Dense(1024, activation='relu',kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x) x = Dense(256, activation='relu',kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x) # x = Dropout(0.2)(x) predictions = Dense(num_classes, activation='softmax',name=f'FC_{num_classes}')(x) model = Model(inputs=base_model.input, outputs=predictions) if len(checkpoint): model.load_weights(checkpoint) return model
def define_model(num): if num == 0: convbase = MobileNetV2( weights='imagenet', include_top=False, input_shape=(150, 150, 3)) print("Creating MobileNet layer!") elif num == 1: convbase = ResNet50V2(weights='imagenet', include_top=False, input_shape=(150, 150, 3)) print("Creating ResNet layer!") elif num == 2: convbase = VGG16( weights='imagenet', include_top=False, input_shape=(150, 150, 3)) print("Creating VGG16 layer!") else: print("Out of range! Something's wrong") convbase.trainable = False # Preserve weights of pre-trained conv layers model = tf.keras.Sequential() model.add(convbase) model.add(layers.Flatten()) model.add(layers.Dense(256, activation='relu')) model.add(layers.Dense(10, activation='softmax')) # compile model model.compile(loss='categorical_crossentropy', optimizer=RMSprop(lr=2e-5), metrics=['accuracy']) return model
def prepare_model(labels): base_model = ResNet50V2(include_top=False, weights='imagenet', input_shape=(200, 200, 3), pooling='avg') x = base_model.output x = Dense(1024, activation='relu')(x) x = Dense(256, activation='relu')(x) x = Dense(64, activation='relu')(x) x = Dropout(0.2)(x) predictions = Dense(len(labels), activation='sigmoid')(x) model = Model(inputs=base_model.input, outputs=predictions) # first: train only the top layers (which were randomly initialized) for layer in base_model.layers: layer.trainable = False # compile the model (should be done *after* setting layers to non-trainable) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model
def cp_net(input): resnet = ResNet50V2(False, None, input_tensor=input, input_shape=input_shape, pooling="avg") out = Dense(n_features)(resnet.output) return out
def resnet50v2(model_config, input_shape, metrics, n_classes=2, output_bias=None, gpus=1): ''' Defines a model based on a pretrained ResNet50V2 for multiclass X-ray classification. :param model_config: A dictionary of parameters associated with the model architecture :param input_shape: The shape of the model input :param metrics: Metrics to track model's performance :return: a Keras Model object with the architecture defined in this method ''' # Set hyperparameters nodes_dense0 = model_config['NODES_DENSE0'] lr = model_config['LR'] dropout = model_config['DROPOUT'] l2_lambda = model_config['L2_LAMBDA'] if model_config['OPTIMIZER'] == 'adam': optimizer = Adam(learning_rate=lr) elif model_config['OPTIMIZER'] == 'sgd': optimizer = SGD(learning_rate=lr) else: optimizer = Adam(learning_rate=lr) # For now, Adam is default option # Set output bias if output_bias is not None: output_bias = Constant(output_bias) print("MODEL CONFIG: ", model_config) # Start with pretrained ResNet50V2 X_input = Input(input_shape, name='input_img') base_model = ResNet50V2(include_top=False, weights='imagenet', input_shape=input_shape, input_tensor=X_input) X = base_model.output # Add custom top X = GlobalAveragePooling2D()(X) X = Dropout(dropout)(X) X = Dense(nodes_dense0, kernel_initializer='he_uniform', activity_regularizer=l2(l2_lambda))(X) X = LeakyReLU()(X) X = Dense(n_classes, bias_initializer=output_bias)(X) Y = Activation('softmax', dtype='float32', name='output')(X) # Set model loss function, optimizer, metrics. model = Model(inputs=X_input, outputs=Y) model.summary() if gpus >= 2: model = multi_gpu_model(model, gpus=gpus) model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=metrics) return model
def frozen_resnet(input_size, n_classes, local_weights="/resnets/resnet50v2_notop.h5"): if local_weights and path.exists(local_weights): print(f'Using {local_weights} as local weights.') model_ = ResNet50V2( include_top=False, input_tensor=Input(shape=input_size), weights=local_weights) else: print( f'Could not find local weights {local_weights} for ResNet. Using remote weights.') model_ = ResNet50V2( include_top=False, input_tensor=Input(shape=input_size)) for layer in model_.layers: layer.trainable = False x = Flatten(input_shape=model_.output_shape[1:])(model_.layers[-1].output) x = Dense(n_classes, activation='softmax')(x) frozen_model = Model(model_.input, x) return frozen_model
def resNet(self, nclasses=3, summary=True): res = ResNet50V2(weights='imagenet', include_top=False, input_shape=(self.__xSize, self.__ySize, 3)) res.trainable = False input_l = layers.Input(shape=(self.__xSize, self.__ySize, 3)) x = res(input_l, training=False) predict = self.__addTop(x, nclasses) self.__model = tf.keras.Model(input_l, predict) if summary: self.__model.summary() self.__compileModel()
def define_model(): model = ResNet50V2(include_top=False, input_shape=(240, 320, 3)) x = model.output avgpool = GlobalAveragePooling2D()(x) output = Dense(1, activation='sigmoid')(avgpool) model = Model(inputs=model.inputs, outputs=output) opt = SGD(lr=0.001, momentum=0.9) model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy']) return model
def __init__(self): super(Generator, self).__init__(name='generator') self.config = Config() self.enc_shape = self.config.ENCODER_INPUT_SHAPE self.resnet50V2 = ResNet50V2(include_top=False, weights='imagenet', input_shape=self.enc_shape, pooling='avg') self._set_resnet_arg_scope() self.regressor = Regressor() self.smpl = Smpl()
def model(img_width=224, img_height=224): model_resnet50_conv = ResNet50V2(include_top=False, input_shape=(img_width, img_height, 3)) for layer in model_resnet50_conv.layers[:154]: layer.trainable = False model_resnet50_conv.trainable = False x = GlobalAveragePooling2D(name="GAP")(model_resnet50_conv.output) x = Dense(2, activation="sigmoid", name="predictions")(x) model = Model(inputs=model_resnet50_conv.inputs, outputs=x) return model
def __init__(self, data_shape=(224, 224, 3), resnet_version=1, resnet_layer_number=50, num_classes=1000): super(ResNet, self).__init__() weights = None if num_classes == 1000 and data_shape == (224, 224, 3): weights = 'imagenet' self.resnet_version = resnet_version self.data_augmentation = keras.Sequential( [ layers.experimental.preprocessing.RandomFlip( "horizontal", input_shape=data_shape), layers.experimental.preprocessing.RandomRotation(0.1), layers.experimental.preprocessing.RandomZoom(0.1), ] ) self.rescaling = layers.experimental.preprocessing.Rescaling(1./255) def preprocess_input(x, data_format=None): from tensorflow.keras.applications import imagenet_utils return imagenet_utils.preprocess_input( x, data_format=data_format, mode='tf') #return x self.preprocess_input = preprocess_input if resnet_layer_number == 18: if resnet_version == 1: self.resnet = ResNet18(category_num=num_classes) else: self.resnet = ResNet18V2(category_num=num_classes) elif resnet_layer_number == 50: if resnet_version == 1: self.resnet = ResNet50(weights=weights, input_shape=data_shape, classes=num_classes) else: self.resnet = ResNet50V2(weights=weights, input_shape=data_shape, classes=num_classes) elif resnet_layer_number == 101: if resnet_version == 1: self.resnet = ResNet101(weights=weights, input_shape=data_shape, classes=num_classes) else: self.resnet = ResNet101V2(weights=weights, input_shape=data_shape, classes=num_classes) elif resnet_layer_number == 152: if resnet_version == 1: self.resnet = ResNet152(weights=weights, input_shape=data_shape, classes=num_classes) else: self.resnet = ResNet152V2(weights=weights, input_shape=data_shape, classes=num_classes) self.build((None,) + data_shape)
def create_image_resnet50v2_model(NUM_CLASS, isPreTrained=False, pathToResNet50V2ModelWeights=None): resnet50v2 = ResNet50V2(weights='imagenet', include_top=False) last_layer = resnet50v2.output x = GlobalAveragePooling2D()(last_layer) x = Dense(768, activation='relu', name='img_dense_768')(x) out = Dense(NUM_CLASS, activation='softmax', name='img_output_layer')(x) resnet50v2 = Model(inputs=resnet50v2.input, outputs=out, name="ResNet50V2") if not isPreTrained: return resnet50v2 else: resnet50v2.load_weights(pathToResNet50V2ModelWeights) return resnet50v2, 2
def load_network(model_path): if '.h5' in model_path: model = tf.keras.models.load_model(model_path) else: if 'resnet50v2' in model_path: model = ResNet50V2(weights='imagenet') elif 'mobilenet' in model_path: model = MobileNet(weights='imagenet') elif 'mobilenetv2' in model_path: model = MobileNetV2(weights='imagenet') elif 'vgg19' in model_path: model = VGG19(weights='imagenet') else: raise ValueError('Invalid model name : {}'.format(model_path)) return model
def ResNet50V2_pretrain_model(): modelPre = ResNet50V2(weights='imagenet', include_top=False, input_shape=config.input_shape, classes=config.category_num) model = tf.keras.Sequential() model.add(modelPre) model.add(tf.keras.layers.GlobalAveragePooling2D()) model.add( tf.keras.layers.Dense(config.category_num, name='fully_connected', activation='softmax', use_bias=False)) return model
def build_resnet50V2(NUM_CLASS): resnet50v2 = ResNet50V2(weights='imagenet', include_top=False) #model.summary() last_layer = resnet50v2.output x = GlobalAveragePooling2D()(last_layer) # a softmax layer for 2 classes x = Dense(768, activation='relu', name='img_dense_768')(x) out = Dense(NUM_CLASS, activation='softmax', name='output_layer')(x) resnet50v2 = Model(inputs=resnet50v2.input, outputs=out) plot_model(resnet50v2, to_file='resnet50v2_inputs.png', show_shapes=True, dpi=600, expand_nested=False) return resnet50v2, 7
def load_model(self): FACTOR = 0.70 HEIGHT = 137 WIDTH = 236 HEIGHT_NEW = int(HEIGHT * FACTOR) WIDTH_NEW = int(WIDTH * FACTOR) base_model = ResNet50V2(include_top=False, weights='imagenet', input_tensor=None, input_shape=(HEIGHT_NEW, WIDTH_NEW, 3), pooling=None, classes=1000) # base_model.trainable=False x = base_model.output x = layers.GlobalAveragePooling2D()(x) grapheme_root = layers.Dense(168, activation='softmax', name='root')(x) vowel_diacritic = layers.Dense(11, activation='softmax', name='vowel')(x) consonant_diacritic = layers.Dense(7, activation='softmax', name='consonant')(x) model = Model( inputs=base_model.input, outputs=[grapheme_root, vowel_diacritic, consonant_diacritic]) for layer in base_model.layers: layer.trainable = True model.compile(optimizer='adam', loss={ 'root': 'categorical_crossentropy', 'vowel': 'categorical_crossentropy', 'consonant': 'categorical_crossentropy' }, loss_weights={ 'root': 0.5, 'vowel': 0.25, 'consonant': 0.25 }, metrics={ 'root': 'accuracy', 'vowel': 'accuracy', 'consonant': 'accuracy' }) # print(model.summary()) return model
def build_COVIDNet(num_classes=3, flatten=True, checkpoint=''): base_model = ResNet50V2(include_top=False, weights='imagenet', input_shape=(224, 224, 3)) x = base_model.output if flatten: x = Flatten()(x) else: x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) x = Dense(256, activation='relu')(x) predictions = Dense(num_classes, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) if len(checkpoint): model.load_weights(checkpoint) return model
def get_resnet_model(): model = ResNet50V2(weights='imagenet', include_top=False) # for i, layer in enumerate(model.layers): # print(i, layer.name) layer_indices = [9, 36, 82, 150, 185] # activation indices ~ scale 0.015 layer_indices = [37, 83, 151] # max_pool indices ~ scale 0.018 outputs = None for idx in layer_indices: features = model.layers[idx].output features = Flatten()(features) if (idx == layer_indices[0]): outputs = features else: outputs = concatenate([outputs, features]) resnet_model = Model(model.inputs, outputs) return resnet_model
def inject_net(name="resnet", input_tensor=None): ''' Picks One of the Pretrained Models (or untrained Mods on it) and returns the respective mergeable Endpoints ''' if name == "resnet": resnet = ResNet50V2(include_top=False, weights=None, pooling=None, input_tensor=input_tensor) ep_layers = [] for layer in resnet.layers: if '_pool' in layer.name: ep_layers.append(layer.output) ep1, ep2, ep3, ep4 = ep_layers return ep1, ep2, ep3, ep4 elif name == "vgg16": vgg = tf.keras.applications.VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor, pooling=None) ep1 = vgg.get_layer('block2_pool').output ep2 = vgg.get_layer('block3_pool').output ep3 = vgg.get_layer('block4_pool').output ep4 = vgg.get_layer('block5_pool').output return ep1, ep2, ep3, ep4 elif name == 'resnet_mod': resnet_mod = get_resnet_mod(input_tensor=input_tensor) ep1 = resnet_mod.get_layer('ep1').output ep2 = resnet_mod.get_layer('ep2').output ep3 = resnet_mod.get_layer('ep3').output ep4 = resnet_mod.get_layer('ep4').output print(ep1.shape, ep2.shape, ep3.shape, ep4.shape) return ep1, ep2, ep3, ep4
def buildKerasAppModel(img_height, img_width, img_channel, num_classes): AppModel = ResNet50V2(include_top=False, pooling='avg', weights='imagenet') x = AppModel.layers[-1].output x = Flatten()(x) x = BatchNormalization()(x) x = Dropout(0.5)(x) output_layer = Dense(num_classes, activation='softmax', name='softmax')(x) model = Model(inputs=AppModel.input, outputs=output_layer) model.compile( loss= 'sparse_categorical_crossentropy', #categorical_crossentropy / sparse_categorical_crossentropy optimizer=Adam(lr=1e-5), metrics=['accuracy']) model.summary() return model
def build_network(cls): import ssl ssl._create_default_https_context = ssl._create_unverified_context base_model = ResNet50V2(include_top=False, weights='imagenet', input_shape=(224, 224, 3)) x = base_model.output if cls.flatten: x = Flatten()(x) else: x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) x = Dense(256, activation='relu')(x) predictions = Dense(cls.num_classes, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) if len(cls.checkpoint): model.load_weights(checkpoint) return model
def createTextResNet50v2Maximum(max_seq_len, bert_ckpt_file, bert_config_file, NUM_CLASS): with GFile(bert_config_file, "r") as reader: bc = StockBertConfig.from_json_string(reader.read()) bert_params = map_stock_config_to_params(bc) bert_params.adapter_size = None bert_layer = BertModelLayer.from_params(bert_params, name="bert") bert_in = Input(shape=(max_seq_len, ), dtype='int32', name="input_ids_bert") bert_inter = bert_layer(bert_in) cls_out = Lambda(lambda seq: seq[:, 0, :])(bert_inter) cls_out = Dropout(0.5)(cls_out) bert_out = Dense(units=768, activation="tanh")(cls_out) # 768 before load_stock_weights(bert_layer, bert_ckpt_file) # image models: resNet50v2 = ResNet50V2(weights='imagenet', include_top=False) res_out = resNet50v2.output res_out = GlobalAveragePooling2D()(res_out) res_out = Dropout(0.5)(res_out) res_out = Dense(2048)(res_out) res_out = Dropout(0.5)(res_out) res_out = Dense(768)(res_out) merge = Maximum()([res_out, bert_out]) # restliche Layer x = Dense(2048)(merge) x = Dropout(0.5)(x) x = Dense(1024)(x) x = Dropout(0.5)(x) x = Dense(512)(x) x = Dropout(0.5)(x) output = Dense(NUM_CLASS, activation='softmax', name='output_layer')(x) model = Model(inputs=[resNet50v2.input, bert_in], outputs=output) plot_model(model, to_file='multiple_inputs_text.png', show_shapes=True, dpi=600, expand_nested=False) return model, 14
def _resnet50_attention_cnn_backbone(input_layer): """ResNet50V2 convolution part of CRNN model(Only Attention use). Parameters: input_layer: Keras Layer, model input. Returns: Keras Layer. """ layer = ResNet50V2(include_top=False, weights='imagenet')(input_layer) # The down sampling factor of ResNet50 is 28. # The shape of the ResNet50 output layer is (None, img_width / 28, img_height / 28, 2048). layer = Reshape(target_shape=(-1, 512), name='Reshape')(layer) layer = Dense(units=256, activation='relu', name='Dense1')(layer) layer = Dropout(rate=0.25, name='Dropout')(layer) return layer
def ResNet50_model(input_shape=(128, 128, 3)): optimizer = SGD(lr=0.01) X_input = Input(input_shape, name='input_img') base_model = ResNet50V2(include_top=False, weights='imagenet', input_shape=input_shape, input_tensor=X_input) X = base_model.output X = GlobalAveragePooling2D()(X) X = BatchNormalization()(X) X = Dropout(0.2)(X) X = Dense(512, kernel_initializer='he_uniform')(X) X = LeakyReLU()(X) X = Dense(4)(X) Y = Activation('softmax', dtype='float32', name='output')(X) model = Model(inputs=X_input, outputs=Y) model.summary() model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy']) return model