def get_model_resnext50(img_size, batch_size): inputs = Input(shape=(img_size, img_size, 3), batch_size=batch_size) base_model = ResNeXt50(input_tensor=inputs) x = base_model.outputs out1 = GlobalMaxPooling2D()(x) out2 = GlobalAveragePooling2D()(x) out3 = Flatten()(x) out = Concatenate(axis=-1)([out1, out2, out3]) out = Dropout(0.5)(out) # and a logistic layer out = Dense(1, activation="sigmoid", name="3_")(out) # Create model. model = tf.keras.Model(inputs, out) model.compile(optimizer=Adam(learning_rate=0.00007, beta_1=0.9, beta_2=0.999, epsilon=1e-08, use_locking=False, name='Adam'), loss='binary_crossentropy', metrics=['acc']) return model
def __init__(self, block_list, initial_filters=64): #默認輸出深度是64 super(ResNet18, self).__init__() self.num_blocks = len(block_list) #共有幾個block self.block_list = block_list self.out_filters = initial_filters # 第一層卷積 self.c1 = Conv2D(self.out_filters, (3, 3), strides=1, padding="same", use_bias=False) #採用64個3*3的卷積核,步長為1,全零填充 self.b1 = BatchNormalization() #批標準化BN self.a1 = Activation("relu") #relu激活函數 self.blocks = tf.keras.models.Sequential() # 構建8個ResNet網絡結構,有8個ResNet塊,每一個ResNet塊有2層卷積,一共是18層網絡 # 第一個ResNet塊是2個實線跳連的ResNet塊,實線計算公式為: H(x) = F(x) + x # 第二,三,四ResNet塊是先虛線再實線的ResNet塊,虛線計算公式為:H(x) = F(x) + W(x) for block_id in range( len(block_list)): #第幾個resnet block #循環次數由參數列表元素個數決定 for layer_id in range(block_list[block_id]): #第幾個卷積層 if block_id != 0 and layer_id == 0: #對 除了第一個blokc以外的每個block的輸入進行下採樣 block = ResnetBlock( self.out_filters, strides=2, residual_path=True) #residual_path=True用虛線連接 else: block = ResnetBlock( self.out_filters, residual_path=False) #residual_path=False用實線連接 self.blocks.add(block) #將構建好的block加入resnet self.out_filters *= 2 #下一個block的卷積核數是上一個block的2倍 self.p1 = GlobalMaxPooling2D() #平均全局池化 self.f1 = Dense(10, activation="softmax", kernel_regularizer=tf.keras.regularizers.l2()) #全連接
def __init__(self, num_blocks, num_classes, init_ch=16, **kwargs): #默認輸出深度是16(init_ch=16) super(Inception10, self).__init__(**kwargs) self.in_channels = init_ch self.out_channels = init_ch self.num_blocks = num_blocks self.init_ch = init_ch self.c1 = ConvBNRelu(init_ch) self.blocks = tf.keras.models.Sequential() for block_id in range(num_blocks): for layer_id in range(2): #每2個Inception結構塊組成一個block if layer_id == 0: block = InceptionBlk( self.out_channels, strides=2 ) #每個block中的第一個Inception結構塊,卷積步長是2,令第一個Inception結構塊輸出特征圖尺寸減半 else: block = InceptionBlk(self.out_channels, strides=1) #第二個Inception結構塊卷積步長是1 self.blocks.add(block) #enlarger out_channels per block #block_0設置的通道數是16,經過個四個分支,輸出的深度為 4*16=64 #在這裡給通道數加倍了,所有block_1通道數是block_0通道數的兩倍是32,同樣經過四個分支輸出的深度是 4*32=128,這128個通道的數據會被送入平均池化,送入10個分類的全連接 self.out_channels *= 2 #第一個Inception結構塊,卷積步長是2,令第一個Inception結構塊輸出特征圖尺寸減半,因此我們把輸出特征圖深度加深,盡可能保證特征提取中信息的承載量一致 self.p1 = GlobalMaxPooling2D() #全局池化 self.f1 = Dense(num_classes, activation="softmax") #全連接
def __init__(self, n_hidden=128, num_classes=10, last_linear='cosine'): super(ConvNet, self).__init__() self.features = tf.keras.Sequential([ ConvBlock(in_channels=1, out_channels=32, kernel_size=3, strides=1, padding=0, data_format='channels_last', name='features/conv1'), ConvBlock(in_channels=32, out_channels=64, kernel_size=3, strides=1, padding=0, data_format='channels_last', name='features/conv2'), ConvBlock(in_channels=64, out_channels=64, kernel_size=3, strides=1, padding=0, data_format='channels_last', name='features/conv2'), GlobalMaxPooling2D(data_format='channels_last', name='pool'), Dense(units=n_hidden, name='features/fc1'), ReLU(name='features/relu') ]) if last_linear == 'cosine': self.last_linear = CosineLinear(num_features=n_hidden, num_classes=num_classes) else: self.last_linear = Dense(num_classes, use_bias=False)
def convert_to_fcn(model, classes=2, activation='softmax', pooling='avg', features=False, model_type='alexnet'): """ Converts a given CNN model to a FCN model Args: model: The model object classes: Number of classes activation: Type of activation for the last layer pooling: Pooling type for generating features features: Whether to return convolutional features or apply global pooling and activation model_type: The type of CNN. Support alexnet, vgg16, and resnet50 Returns: Model object """ num_filters = 4096 if 'resnet' in model_type: num_filters = 2048 x = Conv2D(filters=num_filters, kernel_size=(6, 6), strides=(1, 1), padding='valid')(model.output) x = Conv2D(filters=num_filters, kernel_size=(1, 1), strides=(1, 1), padding='valid')(x) x = Conv2D(filters=classes, kernel_size=(1, 1), strides=(1, 1), padding='valid')(x) if features: if pooling == 'avg': x = Lambda(lambda x: K.mean(x, axis=-1))(x) else: x = Lambda(lambda x: K.max(x, axis=-1))(x) x = Flatten(name='fcn_features')(x) else: x = GlobalMaxPooling2D()(x) x = Activation(activation)(x) return Model(model.input, x)
def resnet_infogan_discriminator(latent_vars=8, size=128): img_in = Input(shape=(size, size, 1), name="disc_img_in") x = res_block(64, norm="spectral")(img_in) x = res_block(64, stride=2, norm="spectral")(x) x = res_block(64, stride=2, norm="spectral")(x) x = res_block(128, stride=2, norm="spectral")(x) x = res_block(256, stride=2, norm="spectral")(x) x = res_block(512, stride=2, norm="spectral")(x) x_avg = GlobalAveragePooling2D()(x) x_max = GlobalMaxPooling2D()(x) x = Concatenate()([x_avg, x_max]) l = dense_block(64, norm="spectral")(x) l = dense_block(64, norm="spectral")(l) latent_out = SNDense(latent_vars, activation="linear")(l) batch_std = BatchStd()(x) sx = Concatenate()([x, batch_std]) sx = dense_block(256, norm="spectral")(sx) sx = SNDense(1, activation='linear')(sx) inputs = [img_in] out = [sx, latent_out] model = Model(inputs=inputs, outputs=out, name="disc") return model
def _channel_attention(_inputs, cbam_ratio=8): channel = K.int_shape(_inputs)[-1] shared_layer_one = Dense(channel // cbam_ratio, activation='relu', kernel_initializer='he_normal', use_bias=True, bias_initializer='zeros', name=name + '_sl1') shared_layer_two = Dense(channel, kernel_initializer='he_normal', use_bias=True, bias_initializer='zeros', name=name + '_sl2') avg_pool = GlobalAveragePooling2D(name=name + '_gap')(_inputs) avg_pool = Reshape((1, 1, channel))(avg_pool) avg_pool = shared_layer_one(avg_pool) avg_pool = shared_layer_two(avg_pool) max_pool = GlobalMaxPooling2D(name=name + '_gmp')(_inputs) max_pool = Reshape((1, 1, channel))(max_pool) max_pool = shared_layer_one(max_pool) max_pool = shared_layer_two(max_pool) cbam_feature = Add()([avg_pool, max_pool]) cbam_feature = _activation(cbam_feature, activation='sigmoid', name=name + '_sigmoid') return Multiply()([_inputs, cbam_feature])
def __init__(self, include_top=True, input_tensor=None, input_shape=None, pooling=None, classes=8631): super(ResNet50Model, self).__init__() self.include_top = include_top input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=K.image_data_format(), require_flatten=include_top) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = ResNet50Component(include_top=include_top)(img_input) # x = AveragePooling2D((7, 7), name='avg_pool')(x) x = Flatten()(x) if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input super(ResNet50Model, self).__init__(inputs, x, name='vggface_resnet50')
def build_model(): """Build a simple CNN.""" input_layer = Input(shape=(None, None, 3)) x = Conv2D(32, (3, 3), activation='selu')(input_layer) # x = BatchNormalization()(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(32, (3, 3), activation='selu')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(64, (4, 4), activation='selu')(x) # x = BatchNormalization()(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Dropout(0.5)(x) x = Conv2D(128, (1, 1))(x) # this allows for pooling without losing image dimension flexibility x = GlobalMaxPooling2D()(x) # some fully connected on top x = Dense(64, activation='selu')(x) x = Dropout(0.5)(x) output_layer = Dense(6, activation='softmax')(x) model = Model(inputs=input_layer, outputs=output_layer) return model
def get_model(n_classes=1): base_model = ResNet50(weights='imagenet', include_top=False) #for layer in base_model.layers: # layer.trainable = False x = base_model.output x = GlobalMaxPooling2D()(x) x = Dropout(0.5)(x) x = Dense(100, activation="relu")(x) x = Dropout(0.5)(x) if n_classes == 1: x = Dense(n_classes, activation="sigmoid")(x) else: x = Dense(n_classes, activation="softmax")(x) base_model = Model(base_model.input, x, name="base_model") if n_classes == 1: base_model.compile(loss="binary_crossentropy", metrics=['acc'], optimizer="adam") else: base_model.compile(loss="sparse_categorical_crossentropy", metrics=['acc'], optimizer="adam") return base_model
def generate_model(hyper_space): model = VGG16(weights='imagenet', include_top=False) #print(model.summary()) x = model.get_layer(hyper_space['last_layer']).output #Congelando o treinamento model.trainable = False for i in range(0, hyper_space['qtd_conv']): x = Convolution2D(512, 3, 3, activation='relu')(x) if hyper_space['pooling'] == 'AVG': x = GlobalAveragePooling2D(name='avg_pool')(x) else: x = GlobalMaxPooling2D(name='max_pool')(x) for i in range(0, hyper_space['qtd_dense']): x = Dense(hyper_space['neurons'], activation='relu')(x) x = Dense(hyper_space['neurons'], activation='relu')(x) x = Dropout(hyper_space['dropout'])(x) x = Dense(5, activation='softmax')(x) for layer in model.layers: layer.trainable = False model_final = Model(inputs=model.inputs, outputs=x) model_final.compile(optimizer=hyper_space['optmizer'], loss="categorical_crossentropy", metrics=["accuracy"]) return model_final
def __init__(self, learning_rate, epsilon): """ inputs: -learning rate (float): learning rate of the Nadam optimizer -epsilon (float): amount of added noise in the adversarial objective function """ super().__init__() self.c_param = 0 self.learning_rate = learning_rate self.epsilon = epsilon self.effnet_base = EfficientNetB7(weights="imagenet", include_top=False, input_shape=(32, 32, 3)) self.effnet_base.trainable = True layer = self.effnet_base.layers[-2].output layer = GlobalMaxPooling2D()(layer) layer = Dropout(0.2)(layer) layer = Dense(32)(layer) layer = Dense(10)(layer) output = Activation("softmax")(layer) self.model = Model(inputs=self.effnet_base.inputs, outputs=[output]) self.loss = tf.keras.losses.CategoricalCrossentropy() self.optimizer = tf.keras.optimizers.Nadam(self.learning_rate)
def __init__(self): """Init method. We define here a simple (shallow) CNN. """ self.num_train_samples = 0 self.num_feat = 1 self.num_labels = 1 self.is_trained = False self.model = Sequential() self.model.add(Conv2D(8, (3, 3), input_shape=(40, 40, 3))) self.model.add(Activation('relu')) self.model.add(BatchNormalization(axis=-1, epsilon=2e-5,momentum=0.9))# self.model.add(Conv2D(16, (1, 1), strides=(2,2), kernel_regularizer=l2(0.0001))) # self.model.add(MaxPooling2D(pool_size=(2,2))) self.model.add(BatchNormalization(axis=-1, epsilon=2e-5,momentum=0.9)) self.model.add(Conv2D(32, (2,2),strides=(1,1), kernel_regularizer=l2(0.0001))) # self.model.add(MaxPooling2D(pool_size=(2,2))) self.model.add(Activation('relu')) self.model.add(BatchNormalization(axis=-1, epsilon=2e-5,momentum=0.9))# self.model.add(Conv2D(32, (1, 1),strides=(1,1), kernel_regularizer=l2(0.0001))) self.model.add(Activation('relu')) self.model.add(MaxPooling2D(pool_size=(2,2))) self.model.add(GlobalMaxPooling2D()) # self.model.add(Dense(16, activation='relu')) # self.model.add(Activation('relu')) self.model.add(Dense(1)) self.model.add(Activation('sigmoid')) self.model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
def cbam_block(x, ratio=8): # channel_attention filters = x.shape[-1] avg_pool_ch = GlobalAveragePooling2D()(x) avg_pool_ch = Reshape((1, 1, filters))(avg_pool_ch) avg_pool_ch = Dense(filters // ratio)(avg_pool_ch) avg_pool_ch = Activation('relu')(avg_pool_ch) avg_pool_ch = Dense(filters)(avg_pool_ch) max_pool_ch = GlobalMaxPooling2D()(x) max_pool_ch = Reshape((1, 1, filters))(max_pool_ch) max_pool_ch = Dense(filters // ratio)(max_pool_ch) max_pool_ch = Activation('relu')(max_pool_ch) max_pool_ch = Dense(filters)(max_pool_ch) cbam_ch = Add()([avg_pool_ch, max_pool_ch]) cbam_ch = Activation('sigmoid')(cbam_ch) cbam_ch = Multiply()([x, cbam_ch]) # spatial_attention kernel_size = 7 avg_pool_s = Lambda(lambda x: K.mean(x, axis=3, keepdims=True))(cbam_ch) max_pool_s = Lambda(lambda x: K.max(x, axis=3, keepdims=True))(cbam_ch) concat = Concatenate(axis=3)([avg_pool_s, max_pool_s]) cbam_s = Conv2D(filters=1, kernel_size=kernel_size, strides=1, padding='same')(concat) cbam_s = Activation('sigmoid')(cbam_s) cbam = Multiply()([cbam_ch, cbam_s]) return cbam
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 get_model(base_model, layer, input_shape, classes=6, activation="softmax", dropout=None, pooling="avg", weights=None, pretrained="imagenet"): base = base_model(input_shape=input_shape, include_top=False, weights=pretrained) if pooling == "avg": x = GlobalAveragePooling2D()(base.output) elif pooling == "max": x = GlobalMaxPooling2D()(base.output) elif pooling is None: x = Flatten()(base.output) if dropout is not None: x = Dropout(dropout)(x) x = Dense(classes, activation=activation)(x) model = Model(inputs=base.input, outputs=x) if weights is not None: model.load_weights(weights) for l in model.layers[:layer]: l.trainable = False return model
def __init__(self, lr, num_Classes, model_name): self.model_name = model_name self.model = Sequential() if model_name not in ['VGG', 'Inception', 'Resnet']: print("Pretrained Model is Not Available") if model_name == 'VGG': base_model = VGG16(include_top=False, weights='imagenet') elif model_name == 'Inception': base_model = InceptionV3(include_top=False, weights='imagenet') else: base_model = ResNet50(include_top=False, weights='imagenet') base_model.trainable = False self.model.add(base_model) self.model.add(GlobalMaxPooling2D()) self.model.add(Dropout(0.3)) self.model.add(Dense(512, activation='relu')) self.model.add(Dropout(0.2)) self.model.add(Dense(256, activation='relu')) self.model.add(Dropout(0.2)) self.model.add(Dense(128, activation='relu')) self.model.add(Dropout(0.2)) self.model.add(Dense(64, activation='relu')) self.model.add(Dense(num_Classes, activation='sigmoid')) print(self.model.summary()) self.model.compile(optimizer=Adam(lr), loss=binary_crossentropy, metrics=['accuracy'])
def getModel(): X_input = X = Input([32, 32, 3]) X = Conv2D(18, kernel_size=6, strides=1, activation='relu', padding='valid')(X) X = denseBlock(X, 6, 18, 1, 'same', 'selu') X = denseBlock(X, 6, 18, 1, 'same', 'selu') X = denseBlock(X, 6, 18, 1, 'same', 'selu') X = transition_block(X, 6, 18, 'same', 'selu', 'avg', 5) X = denseBlock(X, 2, 18, 1, 'same', 'relu') X = denseBlock(X, 2, 18, 1, 'same', 'relu') X = denseBlock(X, 2, 18, 1, 'same', 'relu') X = denseBlock(X, 2, 18, 1, 'same', 'relu') X = transition_block(X, 2, 18, 'same', 'relu', 'avg', 2) X = denseBlock(X, 5, 18, 1, 'same', 'selu') X = denseBlock(X, 5, 18, 1, 'same', 'selu') X = denseBlock(X, 5, 18, 1, 'same', 'selu') X = denseBlock(X, 5, 18, 1, 'same', 'selu') X = denseBlock(X, 5, 18, 1, 'same', 'selu') X = transition_block(X, 5, 18, 'same', 'selu', 'max', 4) X = GlobalMaxPooling2D()(X) X = Dense(10, activation='softmax')(X) model = Model(inputs=X_input, outputs=X) return model
def Conv2DModel(model_name, input_shape, kernel_col, kernels=64, kernel_rows=3, learning_rate=0.01, regularization=None, dropout=None): K.clear_session() model = Sequential(name=model_name) regularizer = regularization model.add( Conv2D(kernels, (kernel_rows, kernel_col), strides=(1, 1), input_shape=input_shape, kernel_regularizer=regularizer, name='conv0')) if dropout != None and type(dropout) == float: model.add(Dropout(dropout)) model.add(Activation('relu')) model.add(GlobalMaxPooling2D()) model.add(Flatten()) model.add(Dense(1, activation='sigmoid', name='fc1')) print(model.summary()) compileModel(model, learning_rate) return model
def FCN_model(len_classes=10, dropout_rate=0.2): """ Initialize Generator object. Args len_classes : Number of classes dropout_rate : Rate of dropout to be used """ input = Input(shape=(None, None, 1)) x = Conv2D(32, (3, 3), activation='relu')(input) x = MaxPooling2D((2, 2))(x) x = Dropout(dropout_rate)(x) x = BatchNormalization()(x) x = Conv2D(64, (3, 3), activation='relu')(x) x = MaxPooling2D((2, 2))(x) x = Dropout(dropout_rate)(x) x = BatchNormalization()(x) x = Conv2D(100, (3, 3), activation='relu')(x) x = MaxPooling2D((2, 2))(x) x = Dropout(dropout_rate)(x) x = BatchNormalization()(x) x = Conv2D(len_classes, (1, 1))(x) x = Dropout(dropout_rate)(x) x = BatchNormalization()(x) x = GlobalMaxPooling2D()(x) predictions = Activation('softmax')(x) model = Model(inputs=input, outputs=predictions) print(model.summary()) print(f'Total number of layers for FCN: {len(model.layers)}') return model
def init_model(self): ''' Create and save model as class attribute. ''' i = Input(shape=(self.image_size, self.image_size, 3)) x = Conv2D(32, (3, 3), activation='relu')(i) x = MaxPooling2D(2, 2)(x) x = BatchNormalization()(x) x = Dropout(0.2)(x) x = Conv2D(64, (3, 3), activation='relu')(x) x = MaxPooling2D(2, 2)(x) x = BatchNormalization()(x) x = Dropout(0.2)(x) x = Conv2D(128, (3, 3), activation='relu')(x) x = MaxPooling2D(2, 2)(x) x = BatchNormalization()(x) x = GlobalMaxPooling2D()(x) x = Dense(1024, kernel_regularizer=l2(0.01), bias_regularizer=l2(0.01), activation='relu')(x) x = Dropout(0.2)(x) x = Dense(2)(x) #output is a dense of size 2 (x,y) self.model = Model(inputs=i, outputs=x) print(self.model.summary())
def get_model_cnn( input_shape=(None, None, 1), n_classes=10, ): inputs = Input(input_shape) x = Convolution2D(64, kernel_size=3, activation="relu")(inputs) x = MaxPooling2D(pool_size=2)(x) x = Convolution2D(64, kernel_size=3, activation="relu")(x) x = MaxPooling2D(pool_size=2)(x) x = Convolution2D(64, kernel_size=3, activation="relu")(x) x = GlobalMaxPooling2D()(x) out1 = Dense(2, activation="linear")(x) out = Dense(10, activation="relu")(out1) out = Dense(n_classes, activation="softmax")(out) model = Model(inputs, out) model.compile(optimizer=Adam(0.0001), loss=categorical_crossentropy, metrics=["acc"]) model_aux = Model(inputs, out1) model_aux.compile(optimizer=Adam(0.0001), loss=categorical_crossentropy, metrics=["acc"]) model.summary() return model, model_aux
def getModel(): X_input = X = Input([32, 32, 3]) X = id_block(X, 4, 3, 'selu') X = Conv2D(18, kernel_size=6, strides=2, activation='selu', padding='valid')(X) X = id_block(X, 4, 18, 'relu') X = Conv2D(36, kernel_size=7, strides=3, activation='tanh', padding='same')(X) X = id_block(X, 5, 36, 'tanh') X = AveragePooling2D(pool_size=2, strides=2, padding='same')(X) X = Conv2D(72, kernel_size=3, strides=2, activation='selu', padding='valid')(X) X = GlobalMaxPooling2D()(X) X = Dense(10, activation='softmax')(X) model = Model(inputs=X_input, outputs=X) return model
def getModel(): X_input = X = Input([32, 32, 3]) X = Conv2D(18, kernel_size=2, strides=2, activation='tanh', padding='valid')(X) X = MaxPooling2D(pool_size=7, strides=5, padding='same')(X) X = Conv2D(36, kernel_size=4, strides=3, activation='selu', padding='same')(X) X = denseBlock(X, 5, 36, 3, 'same', 'relu') X = denseBlock(X, 5, 36, 3, 'same', 'relu') X = transition_block(X, 5, 36, 'same', 'relu', 'max', 1) X = Conv2D(72, kernel_size=5, strides=5, activation='tanh', padding='same')(X) X = GlobalMaxPooling2D()(X) X = Dense(10, activation='softmax')(X) model = Model(inputs=X_input, outputs=X) return model
def conv2d_cnn(): model = Sequential() model.add( Embedding(input_dim=2**16, output_dim=output_dim, input_length=max_len)) model.add( Reshape((max_len, output_dim, 1), input_shape=(max_len, output_dim))) model.add( Conv2D(filters=filters, kernel_size=(kernel_size, output_dim), strides=(1, 1), padding='valid')) model.add(GlobalMaxPooling2D()) model.add(Dense(2**6)) model.add(Activation('relu')) model.add(Dropout(0.2)) model.add(Dense(10)) model.add(Activation('softmax')) adam = optimizers.Adam(lr=0.001) model.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy']) model.summary() early_stopping = EarlyStopping(patience=10) history = model.fit(x_train, y_train, validation_split=0.1, epochs=epochs, batch_size=batch_size, verbose=1, callbacks=[early_stopping]) return model, history
def getModel(): X_input = X = Input([32, 32, 3]) X = conv_block(X, 6, 18, 'relu', 1) X = conv_block(X, 7, 36, 'selu', 7) X = GlobalMaxPooling2D()(X) X = Dense(10, activation='softmax')(X) model = Model(inputs=X_input, outputs=X) return model
def build_model(in_layer, filters, n_out): x = Resblock(in_layer, filters, batch_activate_output=False, name='Resblock1') x = Resblock(x, filters, name='Resblock2') x = MaxPool2D(name='Pool1')(x) x = Dropout(0.1)(x) x = Resblock(x, filters * 2, name='Resblock3', after_pool=True) x = MaxPool2D(name='Pool2')(x) x = Dropout(0.1)(x) x = Resblock(x, filters * 4, name='Resblock4', after_pool=True) x = MaxPool2D(name='Pool3')(x) x = Dropout(0.1)(x) x = Resblock(x, filters * 2, name='Resblock5', after_pool=True) x = Resblock(x, filters, name='Resblock6', after_pool=True) x_vp = Conv2D(512, (1, 1), strides=(1, 1), kernel_initializer='he_normal')(x) x_vp = Dense(256, activation='relu', name='Dense_vp', kernel_initializer='he_normal')(x_vp) x_vp = GlobalMaxPooling2D(name='Pool_vp')(x_vp) output_vp = Dense(n_out, activation='linear', name='vp_output', kernel_initializer='he_normal')(x_vp) x_vs = Conv2D(512, (1, 1), strides=(1, 1), kernel_initializer='he_normal')(x) x_vs = Dense(256, activation='relu', name='Dense_vs', kernel_initializer='he_normal')(x_vs) x_vs = GlobalMaxPooling2D(name='Pool_vs')(x_vs) output_vs = Dense(n_out, activation='linear', name='vs_output', kernel_initializer='he_normal')(x_vs) return output_vp, output_vs
def __init__(self): super(Discriminator, self).__init__() self.layer_1 = Conv2D(64, (3, 3), strides=(2, 2), padding='same') self.layer_2 = LeakyReLU(alpha=0.2) self.layer_3 = Conv2D(128, (3, 3), strides=(2, 2), padding='same') self.layer_4 = LeakyReLU(alpha=0.2) self.layer_5 = GlobalMaxPooling2D() self.layer_6 = Dense(1)
def train_model(self): """ Training the model """ print("Training the model") LR = 1e-3 epochs = 200 callbacks = [ EarlyStopping(monitor='val_loss', min_delta=0, patience=30, verbose=0, mode='auto'), ModelCheckpoint('model.h5', monitor='val_loss', mode='min', save_best_only=True), ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) ] # Pre trained model Xception without fully connected layers base_model = Xception(input_shape=(self.img_size[0], self.img_size[1], 3), include_top=False, weights='imagenet') # Unfreeze the layers base_model.trainable = True x = GlobalMaxPooling2D()(base_model.output) x = Dense(512, activation='relu')(x) x = Dense(10, activation='relu')(x) output = Dense(1, activation='linear')(x) model = Model(inputs=base_model.input, outputs=output) model.compile(loss='mse', optimizer=Adam(learning_rate=LR), metrics=[self.mae_in_months]) print(base_model.summary()) print(model.summary()) history = model.fit_generator( self.train_datagen.flow(self.x_train, self.y_train, batch_size=self.batch_size), steps_per_epoch=len(self.x_train) / self.batch_size, validation_data=self.val_datagen.flow(self.x_val, self.y_val, batch_size=self.batch_size), validation_steps=len(self.x_val) / self.batch_size, callbacks=callbacks, epochs=epochs, verbose=1) self.plot_it(history) model.load_weights('model.h5') pred = self.mean_bone_age + self.std_bone_age * (model.predict( self.x_val, batch_size=self.batch_size, verbose=True)) actual = self.mean_bone_age + self.std_bone_age * (self.y_val)
def getModel(): X_input = X = Input([32, 32, 3]) X = Conv2D(18, kernel_size=2, strides=2, activation='relu', padding='valid')(X) X = Conv2D(36, kernel_size=5, strides=3, activation='selu', padding='valid')(X) X = Conv2D(72, kernel_size=6, strides=5, activation='tanh', padding='same')(X) X = GlobalMaxPooling2D()(X) X = Dense(10, activation='softmax')(X) model = Model(inputs=X_input, outputs=X) return model