def test_find_activation_layer(): conv1_filters = 1 conv2_filters = 1 dense_units = 1 model = Sequential() model.add( Conv2D(conv1_filters, [3, 3], input_shape=(28, 28, 1), data_format="channels_last", name='conv_1')) model.add(Activation('relu', name='act_1')) model.add(MaxPool2D((2, 2), name='pool_1')) model.add( Conv2D(conv2_filters, [3, 3], data_format="channels_last", name='conv_2')) model.add(Activation('relu', name='act_2')) model.add(MaxPool2D((2, 2), name='pool_2')) model.add(Flatten(name='flat_1')) model.add(Dense(dense_units, name='dense_1')) model.add(Activation('relu', name='act_3')) model.add(Dense(10, name='dense_2')) model.add(Activation('softmax', name='act_4')) assert find_activation_layer(model.get_layer('conv_1'), 0) == (model.get_layer('act_1'), 0) assert find_activation_layer(model.get_layer('conv_2'), 0) == (model.get_layer('act_2'), 0) assert find_activation_layer(model.get_layer('dense_1'), 0) == (model.get_layer('act_3'), 0) assert find_activation_layer(model.get_layer('dense_2'), 0) == (model.get_layer('act_4'), 0)
def build_model(img_rows, img_cols, optimizer= 'adam'): ''' This function creates the CNN model ''' # create model model = Sequential() # add layer model.add(Conv2D(filters = 32, kernel_size=(5, 5), activation='relu',padding = 'SAME', strides=2, input_shape=(img_rows, img_cols, 1))) model.add(Conv2D(filters = 32, kernel_size=(5, 5), activation='relu',padding = 'SAME', strides=2)) model.add(MaxPool2D(pool_size=(3,3),padding='SAME')) model.add(Dropout(0.5)) model.add(Conv2D(filters = 64, strides=2, kernel_size=(3, 3),padding = 'SAME', activation='relu')) model.add(Conv2D(filters = 64, strides=2, kernel_size = (3,3),padding = 'SAME', activation ='relu')) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) # avoid overfitting model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dense(1, activation='sigmoid')) # binary prediciton # compile model model.compile(loss=keras.losses.binary_crossentropy, optimizer= optimizer, metrics=['acc']) return model
def build_model(): model = Sequential() model.add(Conv2D(64, (5, 5), (1, 1), "SAME", activation="relu", input_shape=(306, 408, 3))) model.add(MaxPool2D((3, 3), (2, 2), 'same')) model.add(Conv2D(64, (5, 5), (1, 1), "SAME", activation="relu")) model.add(MaxPool2D((3, 3), (2, 2), 'same')) model.add(Conv2D(64, (5, 5), padding="SAME", activation='relu')) model.add(MaxPool2D((3, 3), (2, 2), 'same')) model.add(Conv2D(16, (5, 5), padding="SAME", activation='relu')) model.add(MaxPool2D((3, 3), (2, 2), 'same')) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.3)) model.add(Dense(512, activation='relu')) model.add(Dense(8, activation='relu')) optimizer = Adadelta() model.compile(optimizer, loss=mean_squared_error) print(model.summary()) train_X, train_y = GET_DATA.get_batches_data() cost_values = [] for step in range(1000): cost = model.train_on_batch(train_X, train_y) cost_values.append(cost) if step % 10 == 0: print("step %d , cost value is %.3f" % (step, cost)) model.save("./model1.h5") plt.plot(cost_values) plt.show()
def createModel(X_train): model = Sequential() # model.add(Conv2D(filters = 16, kernel_size = (3,3),padding = 'Same', activation ='relu', input_shape = (X_train.shape[1],X_train.shape[2],X_train.shape[3]))) model.add(MaxPool2D(pool_size=(2,2))) model.add(Dropout(0.25)) # model.add(Conv2D(filters = 32, kernel_size = (3,3),padding = 'Same', activation ='relu')) model.add(MaxPool2D(pool_size=(2,2))) model.add(Dropout(0.25)) ##decode model.add(Conv2D(filters = 16, strides=(2,2), kernel_size = (3,3),padding = 'Same', activation ='relu')) #model.add(UpSampling2D((2,2))) model.add(Conv2D(filters = 16, kernel_size = (3,3),padding = 'Same', activation ='relu')) model.add(UpSampling2D((2,2))) ## # fully connected model.add(Flatten()) model.add(Dense(256, activation = "relu")) model.add(Dropout(0.5)) model.add(Dense(10, activation = "softmax")) #% # Define the optimizer optimizer = tf.keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999) #% model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"]) model.summary() return model
def squeezenet(inputs, num_classes=1000, include_top=False): with tf.name_scope('SqueezeNet'): fine_grained_layers = [] # define the model of SqueezeNet x = Conv2D(64, (3, 3), strides=(2, 2), padding='valid', name='conv1')(inputs) x = Activation('relu', name='relu_conv1')(x) x = MaxPool2D(pool_size=(3, 3), strides=(2, 2), name='pool1')(x) x = fire_module(x, fire_id=2, squeeze=16, expand=64) x = fire_module(x, fire_id=3, squeeze=16, expand=64) x = MaxPool2D(pool_size=(3, 3), strides=(2, 2), name='pool3')(x) x = fire_module(x, fire_id=4, squeeze=32, expand=128) x = fire_module(x, fire_id=5, squeeze=32, expand=128) fine_grained_layers.append(x) x = MaxPool2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x) x = fire_module(x, fire_id=6, squeeze=48, expand=192) x = fire_module(x, fire_id=7, squeeze=48, expand=192) x = fire_module(x, fire_id=8, squeeze=64, expand=256) x = fire_module(x, fire_id=9, squeeze=64, expand=256) if include_top: x = Conv2D(num_classes, (1, 1), padding='valid', name='conv10')(x) x = Activation('relu', name='relu_conv10')(x) x = GlobalAvgPool2D()(x) x = Activation('softmax', name='loss')(x) return x, fine_grained_layers
def __init__(self, optimizer=Adam(), loss=categorical_crossentropy, metrics=[categorical_accuracy, 'top_k_categorical_accuracy']): super().__init__(optimizer=optimizer, loss=loss, metrics=metrics, MODEL_NAME=CIFAR_100_CONV_NAME) self.sequential_layers = [ Conv2D(64, [3, 3], padding='same', activation='elu', kernel_regularizer=l2(), input_shape=(32,32,3)), BatchNormalization(), Conv2D(64, [3, 3], padding='same', activation='elu', kernel_regularizer=l2()), BatchNormalization(), MaxPool2D(), Dropout(rate=0.3), Conv2D(128, [3, 3], padding='same', activation='elu', kernel_regularizer=l2()), BatchNormalization(), Conv2D(128, [3, 3], padding='same', activation='elu', kernel_regularizer=l2()), BatchNormalization(), MaxPool2D(), Dropout(rate=0.4), Conv2D(256, [3, 3], padding='same', activation='elu', kernel_regularizer=l2()), BatchNormalization(), Conv2D(256, [3, 3], padding='same', activation='elu', kernel_regularizer=l2()), BatchNormalization(), MaxPool2D(), Dropout(rate=0.5), Flatten(), Dense(100, activation='softmax') ]
def default_linear(): "fully connected version of the default linear model" img_in = Input(shape=(224, 224, 3), name='img_in') x = img_in # Convolution2D class name is an alias for Conv2D x = Convolution2D(filters=64, kernel_size=(5, 5), strides=(2, 2), activation='elu')(x) #output shape 110x110 x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), activation='elu')(x) #output shape 27x27 x = MaxPool2D(pool_size=(2,2))(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), activation='relu')(x) #output shape 7x7 x = MaxPool2D(pool_size=(2,2))(x) x = Convolution2D(filters=5, kernel_size=(3,3), strides=(2, 2), activation='relu')(x) x = MaxPool2D(pool_size=(2,2))(x) #output 5x5 control_out = Flatten(name='control_out')(x) # control_out = Dense(units=4, activation='relu', name='control_out')(x) # continous output of throttle for later possibly # throttle_out = Dense(units=1, activation='linear', name='throttle_out')(x) model = Model(inputs=[img_in], outputs=[control_out]) model.compile(optimizer='adam', loss={'control_out': 'categorical_crossentropy'}, metrics=['acc']) return model
def Mildnet_vgg16_big(): vgg_model = VGG16(weights="imagenet", include_top=False, input_shape=(224, 224, 3)) for layer in vgg_model.layers[:10]: layer.trainable = False intermediate_layer_outputs = get_layers_output_by_name(vgg_model, ["block1_pool", "block2_pool", "block3_pool", "block4_pool"]) convnet_output = GlobalAveragePooling2D()(vgg_model.output) for layer_name, output in intermediate_layer_outputs.items(): output = GlobalAveragePooling2D()(output) convnet_output = concatenate([convnet_output, output]) convnet_output = Dense(2048, activation='relu')(convnet_output) convnet_output = Dropout(0.6)(convnet_output) convnet_output = Dense(2048, activation='relu')(convnet_output) convnet_output = Lambda(lambda x: K.l2_normalize(x, axis=1))(convnet_output) first_conv = Conv2D(96, kernel_size=(8, 8), strides=(16, 16), padding='same')(vgg_model.input) first_max = MaxPool2D(pool_size=(3, 3), strides=(4, 4), padding='same')(first_conv) first_max = Flatten()(first_max) first_max = Lambda(lambda x: K.l2_normalize(x, axis=1))(first_max) second_conv = Conv2D(96, kernel_size=(8, 8), strides=(32, 32), padding='same')(vgg_model.input) second_max = MaxPool2D(pool_size=(7, 7), strides=(2, 2), padding='same')(second_conv) second_max = Flatten()(second_max) second_max = Lambda(lambda x: K.l2_normalize(x, axis=1))(second_max) merge_one = concatenate([first_max, second_max]) merge_two = concatenate([merge_one, convnet_output], axis=1) emb = Dense(4096)(merge_two) l2_norm_final = Lambda(lambda x: K.l2_normalize(x, axis=1))(emb) final_model = tf.keras.models.Model(inputs=vgg_model.input, outputs=l2_norm_final) return final_model
def get_model(): input_shape = (32, 32, 3) model = Sequential([ Conv2D(16, (3, 3), input_shape=input_shape, padding='same', activation='relu'), Dropout(0.2, noise_shape=None, seed=None), MaxPool2D(pool_size=(2, 2), strides=(2, 2)), Conv2D(32, (3, 3), activation='relu', padding='same'), Dropout(0.2, noise_shape=None, seed=None), MaxPool2D(pool_size=(2, 2), strides=(2, 2)), Conv2D(64, (3, 3), activation='relu', padding='same'), Dropout(0.2, noise_shape=None, seed=None), MaxPool2D(pool_size=(2, 2), strides=(2, 2)), Flatten(), Dropout(0.2, noise_shape=None, seed=None), Dense(64, activation='relu'), Dropout(0.2, noise_shape=None, seed=None), Dense(10, activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) print('Gamma'.ljust(40, '.')) print(model) return model
def ranknet(): vgg_model = VGG19(weights="imagenet", include_top=False, input_shape=(224, 224, 3)) convnet_output = GlobalAveragePooling2D()(vgg_model.output) convnet_output = Dense(4096, activation='relu')(convnet_output) convnet_output = Dropout(0.5)(convnet_output) convnet_output = Dense(4096, activation='relu')(convnet_output) convnet_output = Dropout(0.5)(convnet_output) convnet_output = Lambda(lambda x: K.l2_normalize(x, axis=1))(convnet_output) s1 = MaxPool2D(pool_size=(4, 4), strides=(4, 4), padding='valid')(vgg_model.input) s1 = ZeroPadding2D(padding=(4, 4), data_format=None)(s1) s1 = Conv2D(96, kernel_size=(8, 8), strides=(4, 4), padding='valid')(s1) s1 = ZeroPadding2D(padding=(2, 2), data_format=None)(s1) s1 = MaxPool2D(pool_size=(7, 7), strides=(4, 4), padding='valid')(s1) s1 = Flatten()(s1) s2 = MaxPool2D(pool_size=(8, 8), strides=(8, 8), padding='valid')(vgg_model.input) s2 = ZeroPadding2D(padding=(4, 4), data_format=None)(s2) s2 = Conv2D(96, kernel_size=(8, 8), strides=(4, 4), padding='valid')(s2) s2 = ZeroPadding2D(padding=(1, 1), data_format=None)(s2) s2 = MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding='valid')(s2) s2 = Flatten()(s2) merge_one = concatenate([s1, s2]) merge_one_norm = Lambda(lambda x: K.l2_normalize(x, axis=1))(merge_one) merge_two = concatenate([merge_one_norm, convnet_output], axis=1) emb = Dense(4096)(merge_two) l2_norm_final = Lambda(lambda x: K.l2_normalize(x, axis=1))(emb) final_model = tf.keras.models.Model(inputs=vgg_model.input, outputs=l2_norm_final) return final_model
def visnet_model(): vgg_model = VGG16(weights="imagenet", include_top=False, input_shape=(224, 224, 3)) convnet_output = GlobalAveragePooling2D()(vgg_model.output) convnet_output = Dense(4096, activation='relu')(convnet_output) convnet_output = Dropout(0.6)(convnet_output) convnet_output = Dense(4096, activation='relu')(convnet_output) convnet_output = Dropout(0.6)(convnet_output) convnet_output = Lambda(lambda x: K.l2_normalize(x, axis=1))(convnet_output) first_conv = Conv2D(96, kernel_size=(8, 8), strides=(16, 16), padding='same')(vgg_model.input) first_max = MaxPool2D(pool_size=(3, 3), strides=(4, 4), padding='same')(first_conv) first_max = Flatten()(first_max) first_max = Lambda(lambda x: K.l2_normalize(x, axis=1))(first_max) second_conv = Conv2D(96, kernel_size=(8, 8), strides=(32, 32), padding='same')(vgg_model.input) second_max = MaxPool2D(pool_size=(7, 7), strides=(2, 2), padding='same')(second_conv) second_max = Flatten()(second_max) second_max = Lambda(lambda x: K.l2_normalize(x, axis=1))(second_max) merge_one = concatenate([first_max, second_max]) merge_two = concatenate([merge_one, convnet_output], axis=1) emb = Dense(4096)(merge_two) l2_norm_final = Lambda(lambda x: K.l2_normalize(x, axis=1))(emb) final_model = tf.keras.models.Model(inputs=vgg_model.input, outputs=l2_norm_final) return final_model
def build(self): inLayer = Input(self.inputShape, self.batchSize) x = conv_block(32, kernelSize = 3)(inLayer, training = self.training) x = MaxPool2D((2, 2), strides = (2, 2))(x) x = conv_block(64, kernelSize = 3)(x, training = self.training) x = MaxPool2D((2, 2), strides = (2, 2))(x) x = conv_block(128, kernelSize = 3)(x, training = self.training) x = conv_block(64, kernelSize = 1)(x, training = self.training) x = conv_block(128, kernelSize = 3)(x, training = self.training) x = MaxPool2D((2, 2), strides = (2, 2))(x) x = conv_block(256, kernelSize = 3)(x, training = self.training) x = conv_block(128, kernelSize = 1)(x, training = self.training) x = conv_block(256, kernelSize = 3)(x, training = self.training) x = MaxPool2D((2, 2), strides = (2, 2))(x) x = conv_block(512, kernelSize = 3)(x, training = self.training) x = conv_block(256, kernelSize = 1)(x, training = self.training) x = conv_block(512, kernelSize = 3)(x, training = self.training) x = conv_block(256, kernelSize = 1)(x, training = self.training) x = conv_block(512, kernelSize = 3)(x, training = self.training) x = MaxPool2D((2, 2), strides=(2, 2))(x) x = conv_block(1024, kernelSize = 3)(x, training = self.training) x = conv_block(512, kernelSize = 1)(x, training = self.training) x = conv_block(1024, kernelSize = 3)(x, training = self.training) x = conv_block(512, kernelSize = 1)(x, training = self.training) x = conv_block(1024, kernelSize = 3)(x, training = self.training) mean = Conv2D(filters = self.latentSize, kernel_size = (1, 1), padding = 'same')(x) mean = GlobalAveragePooling2D()(mean) logvar = Conv2D(filters = self.latentSize, kernel_size = (1, 1), padding = 'same')(x) logvar = GlobalAveragePooling2D()(logvar) sample = latent_vector(self.latentConstraints, self.beta)([mean, logvar], training = self.training) return Model(inputs = inLayer, outputs = sample)
def get_model(): img_tensor = Input(shape=(64, 64, 3)) x = Conv2D(filters=32, kernel_size=(5, 5), strides=1, padding='same')(img_tensor) x = BatchNormalization()(x) x = LeakyReLU()(x) x = MaxPool2D(pool_size=(3, 3), strides=2, padding='valid')(x) x = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='valid')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = MaxPool2D(pool_size=(3, 3), strides=2, padding='valid')(x) x = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='valid')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = MaxPool2D(pool_size=(3, 3), strides=2, padding='valid')(x) x = Conv2D(filters=32, kernel_size=(3, 3), strides=1, padding='valid')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = AvgPool2D(pool_size=(2, 2), strides=1, padding='valid')( x ) # Blurred output produced by AvgPool2D, intuitively, gives a better estimate of filters used rather than sharp one produced by MaxPool2D because in blur output the neighboring colors are aggregated and sharp outputs often contain max values due to presence of edges. x = Flatten()(x) x = Dense(units=32, activation='relu')(x) x = Dropout(0.25)(x) predicted_class = Dense(units=num_classes, activation='softmax')(x) model = Model(inputs=[img_tensor], outputs=[predicted_class]) return model
def mnist(data_format): # pylint: disable=no-member if data_format == 'channels_first': input_shape = [1, 28, 28] else: assert data_format == 'channels_last' input_shape = [28, 28, 1] return Sequential([ Reshape(target_shape=input_shape, input_shape=(28 * 28, )), Conv2D(32, 5, padding='same', data_format=data_format, activation=tf.nn.relu, kernel_initializer='random_uniform'), MaxPool2D((2, 2), (2, 2), padding='same', data_format=data_format), Conv2D(64, 5, padding='same', data_format=data_format, activation=tf.nn.relu, kernel_initializer='random_uniform'), MaxPool2D((2, 2), (2, 2), padding='same', data_format=data_format), Flatten(), Dense(1024, activation=tf.nn.relu, kernel_initializer='random_uniform'), Dense(10, kernel_initializer='random_uniform') ])
def build_model(self): print('\n----------BUILD MODEL----------\n') inputs = Input(shape=(IMG_WIDTH, IMG_HEIGHT, IMG_CHANNEL)) # ----------Block 1----------- print('\n---Block 1---') x = Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(inputs) print('Conv2D:', x.get_shape().as_list()) x = MaxPool2D(pool_size=(2, 2), strides=2)(x) print('MaxPool2D:', x.get_shape().as_list()) # ----------Block 2----------- print('\n---Block 2---') x = Conv2D(filters=64, kernel_size=(3, 3), padding='same', activation='relu')(x) print('Conv2D:', x.get_shape().as_list()) x = MaxPool2D(pool_size=(2, 2), strides=2)(x) print('MaxPool2D:', x.get_shape().as_list()) x = BatchNormalization()(x) # ----------Block 3----------- print('\n---Block 3---') x = Conv2D(filters=64, kernel_size=(3, 3), padding='same', activation='relu')(x) print('Conv2D:', x.get_shape().as_list()) x = MaxPool2D(pool_size=(2, 2), strides=2)(x) print('MaxPool2D:', x.get_shape().as_list()) # ----------Merge 2 CNNs---------- print('\n---Merge 2 CNNs---') detector = x detector_shape = detector.get_shape().as_list() extractor = x extractor_shape = extractor.get_shape().as_list() detector = Reshape([detector_shape[1] * detector_shape[2], detector_shape[3]])(detector) print('Detector:', detector.get_shape().as_list()) extractor = Reshape([extractor_shape[1] * extractor_shape[2], extractor_shape[3]])(extractor) print('Extractor:', extractor.get_shape().as_list()) bcnn = Lambda(_outer_product)([detector, extractor]) print('Outer product:', bcnn.get_shape().as_list()) bcnn = Reshape([detector_shape[3] * extractor_shape[3]])(bcnn) print('Reshape:', bcnn.get_shape().as_list()) bcnn = Lambda(_signed_sqrt)(bcnn) print('Signed square root:', bcnn.get_shape().as_list()) bcnn = Lambda(_l2_normalise)(bcnn) print('L2 normalisation:', bcnn.get_shape().as_list()) # ----------Fully Connected---------- bcnn = Dense(units=N_CLASSES, activation='softmax')(bcnn) print('Softmax:', bcnn.get_shape().as_list()) bcnn_model = Model(inputs=[inputs], outputs=[bcnn]) return bcnn_model
def darknet19(inputs, num_classes=1000, include_top=False): """ DarkNet-19 Architecture Definition Args: inputs: num_classes: include_top: Returns: x: model definition fine_grained_layers - a list of fine_grained layers (for detection) """ pass_through_layers = [] with tf.name_scope('DarkNet19'): inputs = Preprocessor(yolov2_preprocess_func, name='preprocessor')(inputs) x = conv_block(inputs, 32, (3, 3), name="Conv2d_1") x = MaxPool2D(strides=2, name="MaxPool2d_1")(x) x = conv_block(x, 64, (3, 3), name="Conv2d_2") x = MaxPool2D(strides=2, name="MaxPool2d_2")(x) x = conv_block(x, 128, (3, 3), name="Conv2d_3") x = conv_block(x, 64, (1, 1), name="Conv2d_4") x = conv_block(x, 128, (3, 3), name="Conv2d_5") x = MaxPool2D(strides=2, name="MaxPool2d_3")(x) x = conv_block(x, 256, (3, 3), name="Conv2d_6") x = conv_block(x, 128, (1, 1), name="Conv2d_7") x = conv_block(x, 256, (3, 3), name="Conv2d_8") x = MaxPool2D(strides=2, name="MaxPool2d_4")(x) x = conv_block(x, 512, (3, 3), name="Conv2d_9") x = conv_block(x, 256, (1, 1), name="Conv2d_10") x = conv_block(x, 512, (3, 3), name="Conv2d_11") x = conv_block(x, 256, (1, 1), name="Conv2d_12") x = conv_block(x, 512, (3, 3), name="Conv2d_13") with tf.name_scope('PassThroughLayers'): pass_through_layers.append(x) x = MaxPool2D(strides=2, name="MaxPool2d_5")(x) x = conv_block(x, 1024, (3, 3), name="Conv2d_14") x = conv_block(x, 512, (1, 1), name="Conv2d_15") x = conv_block(x, 1024, (3, 3), name="Conv2d_16") x = conv_block(x, 512, (1, 1), name="Conv2d_17") x = conv_block(x, 1024, (3, 3), name="Conv2d_18") # ---> feature extraction ends here if include_top: x = Conv2D(num_classes, (1, 1), activation='linear', padding='same')(x) x = GlobalAvgPool2D()(x) x = Activation(activation='softmax')(x) x = Model(inputs, x) return x, pass_through_layers
def VGG11(input_shape, nb_classes, dropout=False, dropout_rate=0.2): """ Creates a vgg11 network. Parameters ---------- input_shape : tuple The shape of the input tensor not including the sample axis. Tensorflow uses the NHWC dimention ordering convention. nb_class : int The number of output class. The network will have this number of output nodes for one-hot encoding. dropout : bool Where or not to implement dropout in the fully-connected layers. dropout_rate : float Dropout rate. Returns ------- keras.models.Sequential() : The create vgg11 network. """ vgg11 = Sequential() # sub-net 1 vgg11.add( Conv2D(filters=8, kernel_size=3, padding='same', activation='relu', input_shape=input_shape)) vgg11.add( Conv2D(filters=8, kernel_size=3, padding='same', activation='relu')) vgg11.add(MaxPool2D(pool_size=2)) # sub-net 2 vgg11.add( Conv2D(filters=12, kernel_size=3, padding='same', activation='relu')) vgg11.add( Conv2D(filters=16, kernel_size=3, padding='same', activation='relu')) vgg11.add(MaxPool2D(pool_size=2)) # sub-net 3 vgg11.add( Conv2D(filters=16, kernel_size=3, padding='same', activation='relu')) vgg11.add( Conv2D(filters=16, kernel_size=3, padding='same', activation='relu')) vgg11.add(MaxPool2D(pool_size=2)) # dense layers vgg11.add(Flatten()) vgg11.add(Dense(units=64, activation='relu')) vgg11.add(Dropout(dropout_rate)) if dropout else None vgg11.add(Dense(units=64, activation='relu')) vgg11.add(Dropout(dropout_rate)) if dropout else None vgg11.add(Dense(units=nb_classes, activation='softmax')) return vgg11
def model_description(self): filter_sizes = [3, 4, 5] num_filters = 10 drop = 0.1 embedding_dim = self.EMBEDDING_DIMENTION inputs = Input(shape=(self.MAX_SEQ_LEN, ), dtype='int32') embedding = self.embedding_layer()(inputs) reshape = Reshape((self.MAX_SEQ_LEN, embedding_dim, 1))(embedding) conv_0 = Conv2D(num_filters, kernel_size=(filter_sizes[0], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape) conv_1 = Conv2D(num_filters, kernel_size=(filter_sizes[1], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape) conv_2 = Conv2D(num_filters, kernel_size=(filter_sizes[2], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape) maxpool_0 = MaxPool2D(pool_size=(self.MAX_SEQ_LEN - filter_sizes[0] + 1, 1), strides=(1, 1), padding='valid')(conv_0) maxpool_1 = MaxPool2D(pool_size=(self.MAX_SEQ_LEN - filter_sizes[1] + 1, 1), strides=(1, 1), padding='valid')(conv_1) maxpool_2 = MaxPool2D(pool_size=(self.MAX_SEQ_LEN - filter_sizes[2] + 1, 1), strides=(1, 1), padding='valid')(conv_2) concatenated_tensor = Concatenate(axis=1)( [maxpool_0, maxpool_1, maxpool_2]) flatten = Flatten()(concatenated_tensor) dropout = Dropout(drop)(flatten) output = Dense(self.num_labels(), activation=self.ACTIVATION)(dropout) # this creates a model that includes model = Model(inputs=inputs, outputs=output) # adam = Adam(lr=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) model.compile(optimizer='adam', loss=self.LOSS_FUNCTION, metrics=['accuracy']) return model
def old_default_linear(): img_in = Input(shape=(120, 160, 3), name='img_in') x = img_in # Convolution2D class name is an alias for Conv2D x = Convolution2D(filters=24, kernel_size=(5, 5), strides=(2, 2), activation='elu')(x) x = MaxPool2D()(x) x = Convolution2D(filters=32, kernel_size=(5, 5), strides=(2, 2), activation='elu')(x) x = MaxPool2D()(x) x = Convolution2D(filters=64, kernel_size=(5, 5), strides=(2, 2), activation='elu')(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), activation='elu')(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation='elu')(x) x = Flatten(name='flattened')(x) x = Dense(units=100, activation='linear')(x) x = Dropout(rate=.1)(x) x = Dense(units=50, activation='linear')(x) x = Dropout(rate=.1)(x) # categorical output of the angle angle_out = Dense(units=1, activation='linear', name='angle_out')(x) # continous output of throttle throttle_out = Dense(units=1, activation='linear', name='throttle_out')(x) model = Model(inputs=[img_in], outputs=[angle_out, throttle_out]) model.compile(optimizer='adam', loss={ 'angle_out': 'mean_squared_error', 'throttle_out': 'mean_squared_error' }, loss_weights={ 'angle_out': 0.5, 'throttle_out': .5 }) return model
def encoder(x): enc_1 = Conv2D(input_shape=input_shape, filters=64, kernel_size=3, padding='same', kernel_regularizer=regularizers.l2(weight_decay), name='conv_1')(x) enc_1 = BatchNormalization(name='batch_1')(enc_1) enc_1 = Activation('relu')(enc_1) enc_1 = Conv2D(filters=64, kernel_size=3, padding='same', kernel_regularizer=regularizers.l2(weight_decay))(enc_1) enc_1 = BatchNormalization()(enc_1) enc_1 = Activation('relu')(enc_1) max_1 = MaxPool2D(strides=2, padding='same')(enc_1) enc_2 = Conv2D(filters=128, kernel_size=3, padding='same', kernel_regularizer=regularizers.l2(weight_decay), name='conv_2')(max_1) enc_2 = BatchNormalization(name='batch_2')(enc_2) enc_2 = Activation('relu')(enc_2) enc_2 = Conv2D(filters=128, kernel_size=3, padding='same', kernel_regularizer=regularizers.l2(weight_decay))(enc_2) enc_2 = BatchNormalization()(enc_2) enc_2 = Activation('relu')(enc_2) max_2 = MaxPool2D(strides=2, padding='same')(enc_2) enc_4 = Conv2D(filters=256, kernel_size=3, padding='same', kernel_regularizer=regularizers.l2(weight_decay), name='conv_3')(max_2) enc_4 = BatchNormalization(name='batch_3')(enc_4) enc_4 = Activation('relu')(enc_4) enc_4 = Conv2D(filters=256, kernel_size=3, padding='same', kernel_regularizer=regularizers.l2(weight_decay))(enc_4) enc_4 = BatchNormalization()(enc_4) enc_4 = Activation('relu')(enc_4) max_4 = MaxPool2D(strides=2, padding='same')(enc_4) return max_4, max_2, max_1
def build(self, x, nb_classes): _x = Conv2D(16, (3, 3), activation='relu', padding='same')(x) _x = Conv2D(16, (3, 3), activation='relu', padding='same')(_x) _x = MaxPool2D()(_x) _x = Conv2D(32, (3, 3), activation='relu', padding='same')(_x) _x = Conv2D(32, (3, 3), activation='relu', padding='same')(_x) _x = MaxPool2D()(_x) feature_map = _x # _x = GlobalAveragePooling2D()(_x) _x = Flatten()(_x) _x = Dense(512, activation='relu')(_x) logits = Dense(nb_classes, activation=None)(_x) outputs = Activation('softmax')(logits) return feature_map, logits, outputs
def Build(self): # create the input layer for feeding the netowrk inLayer = Input(self.inputShape, self.batchSize) net = ConvBnLRelu(32, kernelSize=3)(inLayer, training=self.training) # 1 net = MaxPool2D((2, 2), strides=(2, 2))(net) net = ConvBnLRelu(64, kernelSize=3)(net, training=self.training) # 2 net = MaxPool2D((2, 2), strides=(2, 2))(net) net = ConvBnLRelu(128, kernelSize=3)(net, training=self.training) # 3 net = ConvBnLRelu(64, kernelSize=1)(net, training=self.training) # 4 net = ConvBnLRelu(128, kernelSize=3)(net, training=self.training) # 5 net = MaxPool2D((2, 2), strides=(2, 2))(net) net = ConvBnLRelu(256, kernelSize=3)(net, training=self.training) # 6 net = ConvBnLRelu(128, kernelSize=1)(net, training=self.training) # 7 net = ConvBnLRelu(256, kernelSize=3)(net, training=self.training) # 8 net = MaxPool2D((2, 2), strides=(2, 2))(net) net = ConvBnLRelu(512, kernelSize=3)(net, training=self.training) # 9 net = ConvBnLRelu(256, kernelSize=1)(net, training=self.training) # 10 net = ConvBnLRelu(512, kernelSize=3)(net, training=self.training) # 11 net = ConvBnLRelu(256, kernelSize=1)(net, training=self.training) # 12 net = ConvBnLRelu(512, kernelSize=3)(net, training=self.training) # 13 net = MaxPool2D((2, 2), strides=(2, 2))(net) net = ConvBnLRelu(1024, kernelSize=3)(net, training=self.training) # 14 net = ConvBnLRelu(512, kernelSize=1)(net, training=self.training) # 15 net = ConvBnLRelu(1024, kernelSize=3)(net, training=self.training) # 16 net = ConvBnLRelu(512, kernelSize=1)(net, training=self.training) # 17 net = ConvBnLRelu(1024, kernelSize=3)(net, training=self.training) # 18 # variational encoder output (distributions) mean = Conv2D(filters=self.latentSize, kernel_size=(1, 1), padding='same')(net) mean = GlobalAveragePooling2D()(mean) logvar = Conv2D(filters=self.latentSize, kernel_size=(1, 1), padding='same')(net) logvar = GlobalAveragePooling2D()(logvar) sample = SampleLayer(self.latentConstraints, self.beta)([mean, logvar], training=self.training) return Model(inputs=inLayer, outputs=sample)
def define_sequencial_model(): # building a linear stack of layers with the sequential model model = Sequential() # convolutional layer model.add( Conv2D(50, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu', input_shape=(224, 224, 3))) # convolutional layer model.add( Conv2D(75, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add( Conv2D(125, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Dropout(0.25)) # flatten output of conv model.add(Flatten()) # hidden layer model.add(Dense(500, activation='relu')) model.add(Dropout(0.4)) model.add(Dense(250, activation='relu')) model.add(Dropout(0.3)) # output layer model.add(Dense(2, activation='softmax')) # compiling the sequential model model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam') # training the model for 10 epochs return model
def create_alex_net(input_shape, out_dense, scale=True): model = Sequential() # model.add(input_shape=(32, 32, 3))) # Layer 1 # model.add( Conv2D(48, kernel_size=(3,3),strides=(1,1), activation='relu', padding='same', input_shape=x_train.shape[1:] ) ) model.add( Conv2D(48, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='same', input_shape=(input_shape))) model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2))) # Layer 2 model.add(Conv2D(96, kernel_size=(3, 3), activation='relu', padding='same')) model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2))) # Layer 3 model.add( Conv2D(192, kernel_size=(3, 3), activation='relu', padding='same')) # Layer 4 model.add( Conv2D(192, kernel_size=(3, 3), activation='relu', padding='same')) model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2))) # Layer 5 model.add( Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same')) model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2))) model.add(Flatten()) # Layer 6 model.add(Dense(512, activation='tanh')) # Layer 7 model.add(Dense(256, activation='tanh')) # Prediction model.add(Dense(out_dense, activation='softmax')) model.summary() return model
def keras_estimator(model_dir, config, learning_rate): """Creates a CNN using Keras. This function creates a CNN using TensorFlow's Keras API. The Keras model is converted to a Tensorflow Estimator so that it can be consumed by SageMaker's sagemaker.tensorflow.TensorFlow API. Args: model_dir: (str) File path where training files will be written. config: (tf.estimator.RunConfig) Configuration options to save model. learning_rate: (float) Gradient Descent learning rate. Returns: A keras.Model """ # Input layer name must match the feature dictionary feeding the network # defined in the input_fn() / _parse_fun() inputs = Input(shape=(28, 28, 1), name='image_input') x = Conv2D( filters=32, kernel_size=[3, 3], padding='same', activation=tf.nn.relu)(inputs) x = MaxPool2D(pool_size=(3, 3), strides=2)(x) x = Conv2D( filters=64, kernel_size=[3, 3], padding='same', activation=tf.nn.relu)(x) x = MaxPool2D(pool_size=(2, 2), strides=2)(x) x = Flatten()(x) x = Dense(128, activation=tf.nn.relu)(x) x = Dropout(rate=0.4)(x) output = Dense(10, activation=tf.nn.softmax)(x) model = Model(inputs, output) # Compile model with learning parameters. optimizer = Adam(lr=learning_rate) model.compile( optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy']) # Converts the Keras model to a TensorFlow Estimator estimator = model_to_estimator( keras_model=model, model_dir=model_dir, config=config) return estimator
def new_model(dropout=True, dropout_rate=0.2): model = Sequential() # sub-net 1 model.add( Conv2D(filters=16, kernel_size=3, padding='same', activation='relu', input_shape=img_shape)) model.add( Conv2D(filters=16, kernel_size=3, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=2)) # sub-net 2 model.add( Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')) model.add( Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=2)) # sub-net 3 model.add( Conv2D(filters=64, kernel_size=3, padding='same', activation='relu')) model.add( Conv2D(filters=64, kernel_size=3, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=2)) # dense layers model.add(Flatten()) model.add(BatchNormalization()) model.add(Dense(units=64, activation='softplus')) model.add(Dropout(dropout_rate)) if dropout else None model.add(BatchNormalization()) model.add(Dense(units=64, activation='softplus')) model.add(Dropout(dropout_rate)) if dropout else None model.add(BatchNormalization()) model.add(Dense(units=6, activation='softplus')) model.add(Dropout(dropout_rate)) if dropout else None model.add(BatchNormalization()) model.add(Dense(units=1, activation=expontial)) # Compile Model model.compile(optimizer='adam', loss='mean_absolute_percentage_error') # model.compile(optimizer='adam', loss='mean_squared_logarithmic_error') # model.compile(optimizer='adam', loss=mean_scaled_square_error) return model
def n_grams_channel(self, inputs, n): channel = Conv2D(1, kernel_size=(n, self.embedding_dim), activation='relu')(inputs) channel_mp = MaxPool2D(pool_size=(channel.shape[1], 1))(channel) channel_final = Flatten()(channel_mp) return channel_final
def __init__(self, n_channels): super(SNNonLocalBlock, self).__init__() self.theta = SNConv2D(n_channels // 8, 1, strides=1, padding='SAME', use_bias=False) self.phi = SNConv2D(n_channels // 8, 1, strides=1, padding='SAME', use_bias=False) self.max_pool = MaxPool2D(pool_size=2, strides=2) self.g = SNConv2D(n_channels // 2, 1, strides=1, padding='SAME', use_bias=False) self.sigma = self.add_weight(shape=(), name="sigma", initializer='zeros', trainable=True) self.conv = SNConv2D(filters=n_channels, kernel_size=1, padding='VALID', strides=1)
def AttentionResNetCifar10(shape=(32, 32, 3), n_channels=32, n_classes=10): """ Attention-56 ResNet for Cifar10 Dataset https://arxiv.org/abs/1704.06904 """ input_ = Input(shape=shape) x = Conv2D(n_channels, (5, 5), padding='same')(input_) x = BatchNormalization()(x) x = Activation('relu')(x) x = MaxPool2D(pool_size=(2, 2))(x) # 16x16 x = residual_block(x, input_channels=32, output_channels=128) x = attention_block(x, encoder_depth=2) x = residual_block(x, input_channels=128, output_channels=256, stride=2) # 8x8 x = attention_block(x, encoder_depth=1) x = residual_block(x, input_channels=256, output_channels=512, stride=2) # 4x4 x = attention_block(x, encoder_depth=1) x = residual_block(x, input_channels=512, output_channels=1024) x = residual_block(x, input_channels=1024, output_channels=1024) x = residual_block(x, input_channels=1024, output_channels=1024) x = AveragePooling2D(pool_size=(4, 4), strides=(1, 1))(x) # 1x1 x = Flatten()(x) output = Dense(n_classes, activation='softmax')(x) model = Model(input_, output) return model
def featurenet_block(x, n_filters): """Add a set of layers that make up one unit of the featurenet backbone Args: x (layer): Keras layer object to pass to backbone unit n_filters (int): Number of filters to use for convolutional layers Returns: layer: Keras layer object """ # conv set 1 x = Conv2D(n_filters, (3, 3), strides=(1, 1), padding='same', data_format='channels_last')(x) x = BatchNormalization(axis=-1)(x) x = Activation('relu')(x) # conv set 2 x = Conv2D(n_filters, (3, 3), strides=(1, 1), padding='same', data_format='channels_last')(x) x = BatchNormalization(axis=-1)(x) x = Activation('relu')(x) # Final max pooling stage x = MaxPool2D(pool_size=(2, 2), data_format='channels_last')(x) return x