def get_model(use_model) -> Model: if use_model == 'MobileNetV2': conv_model: Model = MobileNetV2(weights='imagenet', include_top=False, input_shape=IMG_SHAPE) else: conv_model: Model = ResNet50(weights='imagenet', include_top=False, input_shape=IMG_SHAPE) layer: Layer for layer in conv_model.layers: layer.trainable = False image_a = Input(IMG_SHAPE) image_b = Input(IMG_SHAPE) branch_a = conv_model(image_a) branch_b = conv_model(image_b) merged_layers = concatenate([branch_a, branch_b]) merged_layers = GlobalAveragePooling2D()(merged_layers) merged_layers = Dense(256, activation='relu')(merged_layers) merged_layers = Dropout(0.1)(merged_layers) merged_layers = Dense(256, activation='relu')(merged_layers) merged_layers = Dropout(0.0)(merged_layers) output = Dense(1, kernel_initializer='normal', activation='linear')(merged_layers) model = Model(inputs=[image_a, image_b], outputs=output) model.compile(optimizer=tf.keras.optimizers.Adam(0.00100), loss='mse', metrics=[loss_in_fact]) return model
def mobilenetv2_yolo_body(inputs, num_anchors, num_classes, alpha=1.0): # input: 416 x 416 x 3 # conv_pw_13_relu :13 x 13 x 1024 # conv_pw_11_relu :26 x 26 x 512 # conv_pw_5_relu : 52 x 52 x 256 mobilenetv2 = MobileNetV2(input_tensor=inputs, include_top=False, weights='imagenet') x, y1 = make_last_layers_mobilenet(mobilenetv2.output, 17, 512, num_anchors * (num_classes + 5)) x = Conv2D(256, kernel_size=1, padding='same', use_bias=False, name='block_20_conv')(x) x = BatchNormalization(momentum=0.9, name='block_20_BN')(x) x = ReLU(6., name='block_20_relu6')(x) x = UpSampling2D(2)(x) x = Concatenate()([x, MobilenetConv2D(mobilenetv2.get_layer('block_12_project_BN').output, (1, 1), alpha, 384)]) x, y2 = make_last_layers_mobilenet(x, 21, 256, num_anchors * (num_classes + 5)) x = Conv2D(128, kernel_size=1, padding='same', use_bias=False, name='block_24_conv')(x) x = BatchNormalization(momentum=0.9, name='block_24_BN')(x) x = ReLU(6., name='block_24_relu6')(x) x = UpSampling2D(2)(x) x = Concatenate()([x, MobilenetConv2D(mobilenetv2.get_layer('block_5_project_BN').output, (1, 1), alpha, 128)]) x, y3 = make_last_layers_mobilenet(x, 25, 128, num_anchors * (num_classes + 5)) # y1 = Lambda(lambda y: tf.reshape(y, [-1, tf.shape(y)[1],tf.shape(y)[2], num_anchors, num_classes + 5]),name='y1')(y1) # y2 = Lambda(lambda y: tf.reshape(y, [-1, tf.shape(y)[1],tf.shape(y)[2], num_anchors, num_classes + 5]),name='y2')(y2) # y3 = Lambda(lambda y: tf.reshape(y, [-1, tf.shape(y)[1],tf.shape(y)[2], num_anchors, num_classes + 5]),name='y3')(y3) return Model(inputs, [y1, y2, y3])
def GetModel(): base_model = MobileNetV2(input_shape=(224, 224, 3), weights='imagenet', include_top=False, pooling='max') for layer in base_model.layers: layer.trainable = False x = base_model.output x = Dropout(0.6)(x) x = Dense(embedding_dim)(x) x = Lambda(lambda x: K.l2_normalize(x, axis=1))(x) embedding_model = Model(base_model.input, x, name='embedding') input_shape = (image_size, image_size, 3) anchor_input = Input(input_shape, name='anchor_input') positive_input = Input(input_shape, name='positive_input') negative_input = Input(input_shape, name='negative_input') anchor_embedding = embedding_model(anchor_input) positive_embedding = embedding_model(positive_input) negative_embedding = embedding_model(negative_input) inputs = [anchor_input, positive_input, negative_input] outputs = [anchor_embedding, positive_embedding, negative_embedding] triplet_model = Model(inputs, outputs) triplet_model.add_loss(K.mean(triplet_loss(outputs))) return embedding_model, triplet_model
def siamese_encoder(input_shape): """Creates and returns model of encoder part of Siamese network.""" model = MobileNetV2(include_top=False, pooling="max", weights="imagenet", input_shape=input_shape) return model
def create_model(self, num_outputs): print('[Dronet] Starting dronet with MobileNetV2') self.mobile = MobileNetV2(include_top=self.include_top, weights=None, classes=num_outputs) print("self.mobile.summary()======", self.mobile.summary()) print('[Dronet] Done with dronet with MobileNetV2')
def get_mobilev2_model(classes=2): def preprocess_input(img): img = img / 128. img = img - 1. return img.astype(np.float32) def decode_img(img): img = img + 1. img = img * 128. return img.astype(np.uint8) base_model = MobileNetV2(include_top=False, input_shape=(224, 224, 3)) x = base_model.output x = GlobalAveragePooling2D()(x) pre = Dense(classes, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=pre) model.summary() # 冻结这些层就无法训练 # 迁移学习,用训练好的权重,重写全连接层再进行训练 for layer in base_model.layers: layer.trainable = False ckpt = './ckpt/mobilev2.h5' checkpoint = ModelCheckpoint(filepath=ckpt) tensorboard = './log/mobilev2' tensorboard = TensorBoard(log_dir=tensorboard) if os.path.exists(ckpt): model.load_weights(ckpt) print('load done') else: plot_model(model, to_file='mobilev2.png') sgd = SGD(lr=1e-2, decay=1e-6, momentum=0.9, nesterov=True) model.compile(optimizer=sgd, loss='binary_crossentropy', metrics=['accuracy']) return model, checkpoint, tensorboard, preprocess_input, decode_img
def siamese_network(input_shape): """Creates and returns model of encoder part of Siamese network.""" left_input = Input(input_shape) right_input = Input(input_shape) model = MobileNetV2(include_top=False, pooling="max", weights="imagenet", input_shape=input_shape) model.trainable = False x = Dense(1280)(model.output) x = Activation('relu')(x) x = Dropout(0.2)(x) x = Dense(1280)(x) x = Activation('relu')(x) x = Dropout(0.2)(x) model = Model(model.input, x) encoded_l = model(left_input) encoded_r = model(right_input) distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)( [encoded_l, encoded_r]) siamese_net = Model(inputs=[left_input, right_input], outputs=distance) siamese_net.compile(loss=contrastive_loss, optimizer='rmsprop', metrics=[accuracy]) siamese_net.summary() return siamese_net
def construct_model(): conv_base = MobileNetV2(input_shape=None, include_top=False, weights='imagenet', pooling='max') conv_features = conv_base.output finger_status = layers.Dense(3, activation='softmax', name="finger_status")( conv_features) # none, closed, open finger_positions = layers.Dense(4, activation='relu', name="finger_pos")( conv_features) # y1, x1, y2, x2 face_status = layers.Dense(1, activation='sigmoid', name="face_status")( conv_features) # none, present face_position = layers.Dense(4, activation='relu', name="face_pos")( conv_features) # y1, x1, y2, x2 final_outputs = [ finger_status, finger_positions, face_status, face_position ] model = models.Model(inputs=conv_base.input, outputs=final_outputs) return model
def DeepLabV3(config: ModelConfig): """ Build DeepLabv3+ model :param config: ModelConfiguration Class, Reference - `models.config` module :return: Keras Model """ # 전처리 부분 구성하기 inputs = Input(shape=config.INPUT_SHAPE) # BackBone Network 구성하기 if config.BACKBONE == 'MobileNetV2': from tensorflow.python.keras.applications import MobileNetV2 preprocess = MeanShift()(inputs) # (0,255) -> (-1, 1) base = MobileNetV2(input_tensor=preprocess, alpha=config.BACKBONE_ALPHA, include_top=False) skip_input = (base.get_layer( config.BACKBONE_LOW_FEATURE_MAP_NAME).output) aspp_input = (base.get_layer( config.BACKBONE_HIGH_FEATURE_MAP_NAME).output) else: raise ValueError(f"{config.BACKBONE} is not implemented") # ASPP Module Network 구성하기 encoded_fmap = aspp_module(aspp_input, num_features=config.ASPP_NUM_FEATURES, atrous_rate=config.ASPP_ATROUS_RATE, USE_GROUPNORM=config.USE_GROUPNORM, GROUPS=config.GROUPS) # Decoder Network 구성하기 logits = deeplab_decoder( encoded_fmap, skip_input, num_depth=config.DECODER_NUM_DEPTH, num_features=config.DECODER_NUM_FEATURES, num_skip_features=config.DECODER_NUM_SKIP_FEATURES, use_separable_conv=config.DECODER_USE_SEPARABLE_CONV, USE_GROUPNORM=config.USE_GROUPNORM, GROUPS=config.GROUPS) outputs = [] if config.SEPARATE_BG_CLASSIFIER: # BackGround Classifier 분리 bg_pred = Conv2D(1, (1, 1), activation='sigmoid')(logits) bg_pred = ResizeLike(name='bg_prediction')([bg_pred, base.input]) outputs.append(bg_pred) if config.SEPARATE_CRACK_CLASSIFIER: # Label Classifier와 Crack Classifier를 분리 label_pred = Conv2D(config.NUM_CLASSES, (1, 1), activation='softmax')(logits) label_pred = ResizeLike(name='label_prediction')( [label_pred, base.input]) abnormal_pred = Conv2D(1, (1, 1), activation='sigmoid')(logits) abnormal_pred = ResizeLike(name='crack_prediction')( [abnormal_pred, base.input]) outputs.extend([label_pred, abnormal_pred]) else: # Label Classifier만을 둚 prediction = Conv2D(config.NUM_CLASSES, (1, 1), name='logits')(logits) prediction = ResizeLike(name='label_prediction')( [prediction, base.input]) outputs.append(prediction) # Model 선언 model = Model(inputs, outputs, name='deeplabv3') # Freeze the BackBone Network if config.BACKBONE_FREEZE: freeze_flag = True for layer in model.layers: if freeze_flag: layer.trainable = False else: layer.trainable = True if layer.name == config.BACKBONE_HIGH_FEATURE_MAP_NAME: # model train the weights After BACKBONE Network freeze_flag = False return model
stratify=labels, random_state=42) # construct the training image generator for data augmentation aug = 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") # load the MobileNetV2 network, ensuring the head FC layer sets are # left off baseModel = MobileNetV2(weights="imagenet", include_top=False, input_tensor=Input(shape=(224, 224, 3))) # construct the head of the model that will be placed on top of the # the base model headModel = baseModel.output headModel = AveragePooling2D(pool_size=(7, 7))(headModel) headModel = Flatten(name="flatten")(headModel) headModel = Dense(128, activation="relu")(headModel) headModel = Dropout(0.5)(headModel) headModel = Dense(2, activation="softmax")(headModel) # place the head FC model on top of the base model (this will become # the actual model we will train) model = Model(inputs=baseModel.input, outputs=headModel)
""" we set up a sequential model that we can add layers to """ my_new_model = Sequential() """ first we add all of pre-trained model we've written include_top=False, this is how specify that we want to exlude the layer that makes prediction into the thousands of categories used in the ImageNet competition we set the weights to be 'ImageNet' to specify that we use the pre-traind model on ImageNet pooling equals average says that if we had extra channels in our tensor at the end of this step we want to collapse them to 1d tensor by taking an average across channels now we have a pre-trained model that creates the layer before the last layer that we saw in the slides """ my_new_model.add( MobileNetV2(weights='imagenet', include_top=False, pooling='avg')) """ we add a dense layer to make predictions, we specify the number of nodes in this layer which in this case is the number of classes, then we want to apply the softmax function to turn it into probabilities """ my_new_model.add(Dense( num_classes, activation='softmax', )) """ we tell tensor flow not to train the first layer which is the pre-trained model because that's the model that was already pre-trained with the ImageNet data """ my_new_model.layers[0].trainable = False