def my_cnn(): # Define model model = keras.Sequential() model.add( layers.Convolution2D(16, (3, 3), padding='same', input_shape=(128, 128, 3), activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Convolution2D(32, (3, 3), padding='same', activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Convolution2D(64, (3, 3), padding='same', activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(128, activation='relu')) model.add(layers.Dense(100, activation='softmax')) # Train model # adam = tf.train.AdamOptimizer() # model.compile(loss='categorical_crossentropy', # optimizer=adam, # metrics=['top_k_categorical_accuracy']) print(model.summary()) return model
def initialize_model(): model = models.Sequential() model.add( layers.Convolution2D(16, (3, 3), padding='same', input_shape=(28, 28, 1), activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Convolution2D(32, (3, 3), padding='same', activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Convolution2D(64, (3, 3), padding='same', activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(128, activation='relu')) model.add(layers.Dense(NUM_CLASSES, activation='softmax')) # Train model model.summary() #adam = tf.compat.v1.train.AdamOptimizer() f1 = tfa.metrics.F1Score(num_classes=NUM_CLASSES, average='macro') kappa = tfa.metrics.CohenKappa(num_classes=NUM_CLASSES) top = metrics.TopKCategoricalAccuracy(k=1) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy', kappa, f1, top]) return model
def convolution_block(self, x, nb_channels, dropout_rate=None, bottleneck=False, weight_decay=1e-4): """ Creates a convolution block consisting of BN-ReLU-Conv. Optional: bottleneck, dropout """ # Bottleneck if bottleneck: bottleneckWidth = 4 x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Convolution2D( nb_channels * bottleneckWidth, (1, 1), kernel_regularizer=tf.keras.regularizers.l2(weight_decay))(x) # Dropout if dropout_rate: x = layers.Dropout(dropout_rate)(x) # Standard (BN-ReLU-Conv) x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Convolution2D(nb_channels, (3, 3), padding='same')(x) # Dropout if dropout_rate: x = layers.Dropout(dropout_rate)(x) return x
def build_model_architecture(self): # base = self.pre_train_wh_fine_tuning() # self.model = models.Sequential() # self.model.add(base) # self.model.add(layers.Flatten()) # self.model.add(layers.Dense(256, activation='relu')) # self.model.add(layers.Dense(64, activation='relu')) # self.model.add(layers.Dense(3, activation='softmax')) self.model = models.Sequential() self.model.add(layers.Convolution2D(16, 3, activation='relu', input_shape=self.input_shape)) self.model.add(layers.Convolution2D(32, 3, activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) self.model.add(layers.Convolution2D(64, 3, activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) self.model.add(layers.Convolution2D(128, 3, activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) self.model.add(layers.BatchNormalization()) self.model.add(layers.Flatten()) self.model.add(layers.Dense(256, activation='relu')) self.model.add(layers.Dense(64, activation='relu')) self.model.add(layers.Dense(3, activation='softmax'))
def define_model(input_shape): model = keras.Sequential() # input_shape=X_train.shape[1:] model.add( layers.Convolution2D(16, (3, 3), padding='same', input_shape=input_shape, activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Convolution2D(32, (3, 3), padding='same', activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Convolution2D(64, (3, 3), padding='same', activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(128, activation='relu')) model.add(layers.Dense(100, activation='softmax')) # 训练模型 adam = tf.train.AdamOptimizer() model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['top_k_categorical_accuracy']) return model
def conv_block_td(input_tensor, kernel_size, filters, stage, block, input_shape, strides=(2, 2), trainable=True): # conv block time distributed nb_filter1, nb_filter2, nb_filter3 = filters conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = layers.TimeDistributed(layers.Convolution2D( nb_filter1, (1, 1), strides=strides, trainable=trainable, kernel_initializer='normal'), input_shape=input_shape, name=conv_name_base + '2a')(input_tensor) x = layers.TimeDistributed(layers.BatchNormalization(axis=3), name=bn_name_base + '2a')(x) x = layers.Activation('relu')(x) x = layers.TimeDistributed(layers.Convolution2D( nb_filter2, (kernel_size, kernel_size), padding='same', trainable=trainable, kernel_initializer='normal'), name=conv_name_base + '2b')(x) x = layers.TimeDistributed(layers.BatchNormalization(axis=3), name=bn_name_base + '2b')(x) x = layers.Activation('relu')(x) x = layers.TimeDistributed(layers.Convolution2D( nb_filter3, (1, 1), kernel_initializer='normal'), name=conv_name_base + '2c', trainable=trainable)(x) x = layers.TimeDistributed(layers.BatchNormalization(axis=3), name=bn_name_base + '2c')(x) shortcut = layers.TimeDistributed(layers.Convolution2D( nb_filter3, (1, 1), strides=strides, trainable=trainable, kernel_initializer='normal'), name=conv_name_base + '1')(input_tensor) shortcut = layers.TimeDistributed(layers.BatchNormalization(axis=3), name=bn_name_base + '1')(shortcut) x = layers.Add()([x, shortcut]) x = layers.Activation('relu')(x) return x
def build(input_shape, classes): model = models.Sequential() model.add( layers.Convolution2D(20, (5, 5), activation='relu', input_shape=input_shape)) model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) model.add(layers.Convolution2D(50, (5, 5), activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(500, activation='relu')) model.add(layers.Dense(classes, activation="softmax")) return model
def le_net_5(input_shape, dropout): m = models.Sequential() m.add(layers.Lambda(lambda x: x / 127.5 - 1., input_shape=input_shape)) m.add(layers.Convolution2D(64, 5, 5, activation='relu')) m.add(layers.MaxPooling2D((2, 2))) m.add(layers.Dropout(dropout)) m.add(layers.Convolution2D(36, 5, 5, activation='relu')) m.add(layers.MaxPooling2D((2, 2))) m.add(layers.Flatten()) m.add(layers.Dense(120)) m.add(layers.Dropout(dropout)) m.add(layers.Dense(84)) m.add(layers.Dense(1)) return m
def nin_block(num_channels, kernel_size, strides, padding): net.add( layers.Convolution2D(filters=num_channels, padding=padding, kernel_size=kernel_size, strides=strides, activation='relu')) net.add( layers.Convolution2D(filters=num_channels, kernel_size=1, activation='relu')) net.add( layers.Convolution2D(filters=num_channels, kernel_size=1, activation='relu'))
def convBlock(prev, sz, filters): conv_1 = layers.Convolution2D(filters, (sz, sz), padding="same", activation="relu")(prev) conv_1 = layers.Dropout(0.1)(conv_1) conv_1 = layers.BatchNormalization()(conv_1) return conv_1
def create_bert_cnn_model(num_tokens: int, num_filters: int, filter_size: int, embedding_dim: int, nn_hidden_dim: int, dropout_prob: float): # define the encoder for bert model bert_encoder = TFBertModel.from_pretrained('bert-base-uncased') input_word_ids = tf.keras.Input(shape=(num_tokens, ), dtype=tf.int32, name="input_word_ids") bert_embedding = bert_encoder([input_word_ids]) cnn_input = tf.expand_dims(bert_embedding[0], -1) cnn_output = layers.Convolution2D(filters=num_filters, kernel_size=[filter_size, embedding_dim], activation='relu')(cnn_input) max_pooled_output = tf.nn.max_pool(cnn_output, ksize=[1, 13, 1, 1], strides=[1, 1, 1, 1], padding='VALID') max_pooled_output = tf.reshape(max_pooled_output, [-1, 200]) hidden_output = layers.Dense(nn_hidden_dim, activation='relu')(max_pooled_output) hidden_output = layers.Dropout(dropout_prob)(hidden_output) output = layers.Dense(1, activation='sigmoid')(hidden_output) model = tf.keras.Model(inputs=[input_word_ids], outputs=output) return model
def downsamplingBlockWithLink(prev, sz, filters): link = convBlock(prev, sz, filters) res = link for _ in range(3): res = convBlock(res, sz, filters) res = layers.Convolution2D(filters, (2, 2), strides=2, padding="same")(res) return link, res
def nvidia_model(input_shape, dropout): m = models.Sequential() m.add(layers.Lambda(lambda x: x / 255.0 - 0.5, input_shape=input_shape)) m.add(layers.Cropping2D(cropping=((70, 25), (0, 0)))) m.add(layers.Convolution2D(24, 5, 2, activation='relu')) m.add(layers.Convolution2D(36, 5, 2, activation='relu')) m.add(layers.Convolution2D(48, 5, 2, activation='relu')) m.add(layers.Dropout(dropout)) m.add(layers.Convolution2D(64, 3, activation='relu')) m.add(layers.Convolution2D(64, 3, activation='relu')) m.add(layers.Flatten()) m.add(layers.Dense(100)) m.add(layers.Dropout(dropout)) m.add(layers.Dense(50)) m.add(layers.Dense(10)) m.add(layers.Dense(1)) return m
def make_sr_generator_model(): lr_img = layers.Input(shape=(None, None, NUM_CHANNELS)) #lr_img = layers.Input(shape=(1080, 1080, NUM_CHANNELS)) ################################################################################ ## Now that we have a low res image, we can start the actual generator ResNet ## ################################################################################ x = layers.Convolution2D(64, (9, 9), (1, 1), padding='same')(lr_img) x = layers.ReLU()(x) b_prev = x ##################### ## Residual Blocks ## ##################### for i in range(B): b_curr = layers.Convolution2D(64, (3, 3), (1, 1), padding='same')(b_prev) b_curr = layers.BatchNormalization()(b_curr) b_curr = layers.ReLU()(b_curr) b_curr = layers.Convolution2D(64, (3, 3), (1, 1), padding='same')(b_curr) b_curr = layers.BatchNormalization()(b_curr) b_curr = layers.Add()([b_prev, b_curr]) #skip connection b_prev = b_curr res_out = b_curr # Output of residual blocks x2 = layers.Convolution2D(64, (3, 3), (1, 1), padding='same')(res_out) x2 = layers.BatchNormalization()(x2) x = layers.Add()([x, x2]) #skip connection ####################################################### ## Resolution-enhancing sub-pixel convolution layers ## ####################################################### # Layer 1 (Half of the upsampling) x = layers.Convolution2D(256, (3, 3), (1, 1), padding='same')(res_out) x = SubpixelConv2D(input_shape=(None, None, None, NUM_CHANNELS), scale=DOWNSAMPLING_FACTOR / 2, idx=0)(x) #x = Subpixel(256, kernel_size=(3,3), r=DOWNSAMPLING_FACTOR/2, padding='same', strides=(1,1)) x = layers.ReLU()(x) # Layer 2 (Second half of the upsampling) x = layers.Convolution2D(256, (3, 3), (1, 1), padding='same')(x) x = SubpixelConv2D(input_shape=(None, None, None, NUM_CHANNELS / ((DOWNSAMPLING_FACTOR / 2)**2)), scale=(DOWNSAMPLING_FACTOR / 2), idx=1)(x) #x = Subpixel(256, kernel_size=(3,3), r=DOWNSAMPLING_FACTOR/2, padding='same', strides=(1,1)) x = layers.ReLU()(x) generated_sr_image = layers.Convolution2D(3, (9, 9), (1, 1), padding='same')(x) output_shape = generated_sr_image.get_shape().as_list() #assert output_shape == [None, HR_IMG_HEIGHT, HR_IMG_WIDTH, NUM_CHANNELS] return Model(inputs=lr_img, outputs=generated_sr_image, name='generator')
def make_sr_discriminator_model(): inputs = layers.Input(shape=(HR_IMG_HEIGHT, HR_IMG_WIDTH, NUM_CHANNELS)) # k3n64s1 x = layers.Convolution2D(64, (3, 3), (1, 1), padding='same')(inputs) x = layers.LeakyReLU(alpha=0.2)(x) ################# ## Conv Blocks ## ################# # k3n64s2 x = layers.Convolution2D(64, (3, 3), (2, 2), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) # k3n128s1 x = layers.Convolution2D(128, (3, 3), (1, 1), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) # k3n128s2 x = layers.Convolution2D(128, (3, 3), (2, 2), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) # k3n256s1 x = layers.Convolution2D(256, (3, 3), (1, 1), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) # k3n256s2 x = layers.Convolution2D(256, (3, 3), (2, 2), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) # k3n512s1 x = layers.Convolution2D(512, (3, 3), (1, 1), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) # k3n512s2 x = layers.Convolution2D(512, (3, 3), (2, 2), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) ################ ## Dense Tail ## ################ x = layers.Dense(1024)(x) x = layers.LeakyReLU(alpha=0.2)(x) outputs = layers.Dense(1, activation='sigmoid')(x) return Model(inputs=inputs, outputs=outputs, name='discriminator')
def simple_net(input_shape): m = models.Sequential() m.add(layers.Lambda(lambda x: x / 127.5 - 1., input_shape=input_shape)) m.add(layers.Cropping2D(cropping=((50, 20), (0, 0)))) m.add(layers.Convolution2D(24, 5, 5, activation='relu')) m.add(layers.MaxPooling2D()) m.add(layers.Flatten()) m.add(layers.Dense(120)) m.add(layers.Dense(1)) return m
def __init__(self, embedding_dim: int, filters: List[int], out_channels: int): super(baseCNNmodel, self).__init__() # define the three convolutional layers with respective filter sizes self.filters = filters self.out_channels = out_channels self.conv1 = layers.Convolution2D( filters=out_channels, kernel_size=[filters[0], embedding_dim], activation='relu') self.conv2 = layers.Convolution2D( filters=out_channels, kernel_size=[filters[1], embedding_dim], activation='relu') self.conv3 = layers.Convolution2D( filters=out_channels, kernel_size=[filters[2], embedding_dim], activation='relu')
def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(2, 2), trainable=True): nb_filter1, nb_filter2, nb_filter3 = filters bn_axis = 3 conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = layers.Convolution2D(nb_filter1, (1, 1), strides=strides, name=conv_name_base + '2a', trainable=trainable)(input_tensor) x = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x) x = layers.Activation('relu')(x) x = layers.Convolution2D(nb_filter2, (kernel_size, kernel_size), padding='same', name=conv_name_base + '2b', trainable=trainable)(x) x = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x) x = layers.Activation('relu')(x) x = layers.Convolution2D(nb_filter3, (1, 1), name=conv_name_base + '2c', trainable=trainable)(x) x = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x) shortcut = layers.Convolution2D(nb_filter3, (1, 1), strides=strides, name=conv_name_base + '1', trainable=trainable)(input_tensor) shortcut = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '1')(shortcut) x = layers.Add()([x, shortcut]) x = layers.Activation('relu')(x) return x
def create_model(): model = Sequential( [ layers.Convolution2D(24, (5, 5), (2, 2), input_shape=(66, 200, 3), activation='elu'), layers.Convolution2D(36, (5, 5), (2, 2), activation='elu'), layers.Convolution2D(48, (5, 5), (2, 2), activation='elu'), layers.Convolution2D(64, (3, 3), activation='elu'), layers.Convolution2D(64, (3, 3), activation='elu'), layers.Flatten(), layers.Dense(100, activation='elu'), layers.Dense(50, activation='elu'), layers.Dense(10, activation='elu'), layers.Dense(1) ] ) opt = Adam(learning_rate=0.0003) model.compile(loss='mse', optimizer=opt) return model
def identity_block_td(input_tensor, kernel_size, filters, stage, block, trainable=True): # identity block time distributed nb_filter1, nb_filter2, nb_filter3 = filters conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = layers.TimeDistributed(layers.Convolution2D( nb_filter1, (1, 1), trainable=trainable, kernel_initializer='normal'), name=conv_name_base + '2a')(input_tensor) x = layers.TimeDistributed(layers.BatchNormalization(axis=3), name=bn_name_base + '2a')(x) x = layers.Activation('relu')(x) x = layers.TimeDistributed(layers.Convolution2D( nb_filter2, (kernel_size, kernel_size), trainable=trainable, kernel_initializer='normal', padding='same'), name=conv_name_base + '2b')(x) x = layers.TimeDistributed(layers.BatchNormalization(axis=3), name=bn_name_base + '2b')(x) x = layers.Activation('relu')(x) x = layers.TimeDistributed(layers.Convolution2D( nb_filter3, (1, 1), trainable=trainable, kernel_initializer='normal'), name=conv_name_base + '2c')(x) x = layers.TimeDistributed(layers.BatchNormalization(axis=3), name=bn_name_base + '2c')(x) x = layers.Add()([x, input_tensor]) x = layers.Activation('relu')(x) return x
def build(input_shape, classes, just_fc=False): model = models.Sequential() if not just_fc: # CONV => RELU => POOL model.add( layers.Convolution2D(20, (5, 5), activation='relu', input_shape=input_shape)) model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # CONV => RELU => POOL model.add(layers.Convolution2D(50, (5, 5), activation='relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # Flatten => RELU layers model.add(layers.Flatten()) else: model.add(layers.Flatten(input_shape=input_shape)) model.add(layers.Dense(500, activation='relu')) # a softmax classifier model.add(layers.Dense(classes, activation="softmax")) return model
def build(input_shape, classes): model = models.Sequential() model.add(layers.Convolution2D(32, (3, 3), activation='relu', input_shape=input_shape)) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Dropout(0.25)) model.add(layers.Flatten()) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dropout(0.5)) model.add(layers.Dense(classes, activation='softmax')) return model
def build_model(input_shape, classes): model = models.Sequential() # 1st block model.add(layers.Convolution2D(32, (3, 3), padding='same', input_shape=input_shape, activation='relu')) model.add(layers.BatchNormalization()) model.add(layers.Convolution2D(32, (3, 3), padding='same', activation='relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Dropout(0.2)) # 2nd block model.add(layers.Convolution2D(64, (3, 3), padding='same', activation='relu')) model.add(layers.BatchNormalization()) model.add(layers.Convolution2D(64, (3, 3), padding='same', activation='relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Dropout(0.3)) # 3d block model.add(layers.Convolution2D(128, (3, 3), padding='same', activation='relu')) model.add(layers.BatchNormalization()) model.add(layers.Convolution2D(128, (3, 3), padding='same', activation='relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Dropout(0.4)) # dense model.add(layers.Flatten()) model.add(layers.Dense(classes, activation='softmax')) model.summary() return model
def build_model(self): """ Build the model Returns: Model : Keras model instance """ print('Creating DenseNet %s' % __version__) print('#############################################') print('Dense blocks: %s' % self.dense_blocks) print('Layers per dense block: %s' % self.dense_layers) print('#############################################') img_input = layers.Input(shape=self.input_shape, name='img_input') nb_channels = self.growth_rate # Initial convolution layer x = layers.Convolution2D(2 * self.growth_rate, (3, 3), padding='same', strides=(1, 1), kernel_regularizer=keras.regularizers.l2( self.weight_decay))(img_input) # Building dense blocks for block in range(self.dense_blocks - 1): # Add dense block x, nb_channels = self.dense_block(x, self.dense_layers[block], nb_channels, self.growth_rate, self.dropout_rate, self.bottleneck, self.weight_decay) # Add transition_block x = self.transition_layer(x, nb_channels, self.dropout_rate, self.compression, self.weight_decay) nb_channels = int(nb_channels * self.compression) # Add last dense block without transition but for that with global average pooling x, nb_channels = self.dense_block(x, self.dense_layers[-1], nb_channels, self.growth_rate, self.dropout_rate, self.bottleneck, self.weight_decay) x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.GlobalAveragePooling2D()(x) prediction = layers.Dense(self.nb_classes, activation='softmax')(x) return keras.Model(inputs=img_input, outputs=prediction, name='densenet')
def __init__(self): # initialize CNN self.model = tf.keras.Sequential() # 1. 1st convolution layer # relu activation funtion -> to avoid negative numbers self.model.add( layers.Convolution2D(16, (3, 3), input_shape=(48, 48, 1), activation='relu') ) # number of filters, filterShape, inputShape # 2. Maxpooling self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) # 3. 2nd convolution layer self.model.add(layers.Convolution2D(32, (3, 3), activation='relu')) # 4. Maxpooling self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) # 5. 3rd convolution layer self.model.add(layers.Convolution2D(64, (3, 3), activation='relu')) # 6. Maxpooling self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) # 7 flatten output of maxPooling - Flatten() self.model.add(layers.Flatten()) # fully connected layer - Dense() # 8. input layer self.model.add(layers.Dense(units=512, activation='relu')) # 9. hidden layer self.model.add(layers.Dense(units=1024, activation='relu')) # 10. drop out self.model.add(layers.Dropout(0.3)) # 11. output layer - emtion 카테고리 범위 : 0~6 => output layer의 node 갯수 : 7 self.model.add(layers.Dense(units=7, activation='sigmoid')) # 12. compile CNN # loss function(=cost function) calculates loss -> to find best weights, have to find the lowest loss # optimizer -> update weights self.model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
def transition_layer(self, x, nb_channels, dropout_rate=None, compression=1.0, weight_decay=1e-4): """ Creates a transition layer between dense blocks as transition, which do convolution and pooling. Works as downsampling. """ x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Convolution2D(int(nb_channels * compression), (1, 1), padding='same')(x) # Adding dropout if dropout_rate: x = layers.Dropout(dropout_rate)(x) x = layers.AveragePooling2D((2, 2), strides=(2, 2))(x) return x
def test_lulc_cnn(num_classes=16, p=5, b=220, name='IndianPines'): model = tf.keras.Sequential([ layers.BatchNormalization(axis=-1, input_shape=(p, p, 220)), layers.Convolution2D(32, (3, 3), padding='same', activation='relu', data_format='channels_last'), layers.BatchNormalization(axis=-1), layers.MaxPooling2D(pool_size=(3, 3), strides=(1, 1), padding='same', data_format='channels_last'), layers.Flatten(), layers.Dense(512), layers.Dropout(rate=0.2), layers.Dense(num_classes, activation='softmax') ], name=name) model.compile(optimizer=tf.train.AdamOptimizer(0.01), loss=tf.keras.losses.categorical_crossentropy, metrics=[tf.keras.metrics.categorical_accuracy]) return model
def create_model(self): # Our input feature map is 150x150x3: 150x150 for the image pixels, and 3 for # the three color channels: R, G, and B img_input = layers.Input(shape=(150, 150, 3)) # First convolution extracts 16 filters that are 3x3 # Convolution is followed by max-pooling layer with a 2x2 window x = layers.Conv2D(16, 3, activation='relu')(img_input) x = layers.MaxPooling2D(2)(x) # Second convolution extracts 32 filters that are 3x3 # Convolution is followed by max-pooling layer with a 2x2 window x = layers.Conv2D(32, 3, activation='relu')(x) x = layers.MaxPooling2D(2)(x) # Third convolution extracts 64 filters that are 3x3 # Convolution is followed by max-pooling layer with a 2x2 window x = layers.Convolution2D(64, 3, activation='relu')(x) x = layers.MaxPooling2D(2)(x) # Flatten feature map to a 1-dim tensor x = layers.Flatten()(x) # Create a fully connected layer with ReLU activation and 512 hidden units x = layers.Dense(512, activation='relu')(x) # Add a dropout rate of 0.5 x = layers.Dropout(0.5)(x) # Create output layer with a single node and sigmoid activation output = layers.Dense(1, activation='sigmoid')(x) # Configure and compile the model model = Model(img_input, output) model.compile( loss='binary_crossentropy', optimizer=RMSprop(lr=0.001), metrics=['acc'] ) return model
def build_model(n_kernels, kernel_size, stride, n_dense): model = tf.keras.models.Sequential() model.add(layers.Convolution2D(filters=n_kernels,kernel_size=(kernel_size,kernel_size),activation='relu',input_shape=(16,16,1))) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(strides=(stride,stride))) model.add(layers.Dropout(rate=0.25)) model.add(layers.Flatten()) model.add(layers.Dense(n_dense,activation='relu')) model.add(layers.Dropout(rate=0.5)) model.add(layers.Dense(10,activation='softmax')) adamOptimizer= tf.keras.optimizers.Adam(lr=0.0001) model.compile(optimizer=adamOptimizer,loss='categorical_crossentropy') annealer = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x) history = model.fit(x_trn,y_trn,epochs=2,batch_size =16, verbose=2, validation_data=(x_val, y_val),callbacks=[annealer]) tstError=model.evaluate(x_tst,y_tst) trnError=model.evaluate(x_trn,y_trn) noOfParams=model.count_params() return (tstError,trnError,noOfParams)
def create_model(input_shape=INPUT_SHAPE_384_512): model = models.Sequential([ layers.Convolution2D( 64, 3, strides=2, padding="same", activation="relu", input_shape=input_shape, ), layers.Convolution2D(64, 3, strides=2, activation="relu"), layers.MaxPooling2D(pool_size=2), layers.Dropout(0.2), layers.Convolution2D(128, 3, strides=2, padding="same", activation="relu"), layers.Convolution2D(128, 3, strides=2, activation="relu"), layers.MaxPooling2D(pool_size=2), layers.Dropout(0.2), layers.Convolution2D(256, 3, strides=2, padding="same", activation="relu"), layers.Convolution2D(256, 3, strides=2, padding="same", activation="relu"), layers.MaxPooling2D(pool_size=2), layers.Dropout(0.2), layers.Flatten(), layers.Dense(2048, activation="relu"), layers.Dropout(0.2), layers.Dense(6, activation="softmax"), ]) model.compile( optimizer="adam", loss=keras.losses.categorical_crossentropy, metrics=["accuracy"], ) return model