def VGG_16(image_shape): bn_mode = 0 bn_axis = 1 decay = 1e-5 activation = 'linear' model = Sequential() model.add(ZeroPadding2D((1, 1), input_shape=image_shape)) model.add( Convolution2D(64, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(64, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(128, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(128, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(256, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(256, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(256, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(512, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(512, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(512, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(512, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(512, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add( Convolution2D(512, 3, 3, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization(mode=bn_mode, axis=bn_axis)) model.add(Activation('relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(Flatten()) model.add(Dense(4096, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(4096, activation=activation, W_regularizer=l2(decay))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) return model
model.add(Activation(quantized_tanh)) model.add( QuantizedConv2D(64, kernel_size=kernel_size, data_format='channels_last', H=H, nb=nb, kernel_lr_multiplier=kernel_lr_multiplier, kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), padding='same', use_bias=use_bias, name='block1_conv2')) model.add(BatchNormalization()) model.add(Activation(quantized_tanh)) model.add(MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')) # Block 2 model.add( QuantizedConv2D(128, kernel_size=kernel_size, data_format='channels_last', H=H, nb=nb, kernel_lr_multiplier=kernel_lr_multiplier, kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), padding='same', use_bias=use_bias, name='block2_conv1')) model.add(BatchNormalization())
def nn_base(input_tensor=None, trainable=False): # Determine proper input shape if K.image_dim_ordering() == 'th': input_shape = (3, None, None) else: input_shape = (None, None, 3) 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 if K.image_dim_ordering() == 'tf': bn_axis = 3 else: bn_axis = 1 # Block 1 x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) # Block 2 x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x) x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) # Block 3 x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) # Block 4 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x) # Block 5 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x) # x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x) return x
def conv1(nn): nn.add(Conv2D(32, (3, 3))) nn.add(Activation("relu")) nn.add(MaxPooling2D(pool_size=(2, 2))) return nn
### TODO: Define your architecture. activation = 'relu' for epochs in [10]: for dense1 in [16]: name = '_'.join(str(x) for x in list([dense1, epochs, '3'])) log_dir = os.path.join('./logs/', name) model = Sequential() with K.name_scope('helloworld'): model.add( Conv2D(filters=16, kernel_size=2, padding='valid', activation=activation, input_shape=(224, 224, 3))) model.add(MaxPooling2D(pool_size=2)) model.add( Conv2D(filters=dense1, kernel_size=2, padding='valid', activation=activation)) model.add(MaxPooling2D(pool_size=2)) model.add( Conv2D(filters=32, kernel_size=2, padding='valid', activation=activation)) model.add(MaxPooling2D(pool_size=4)) model.add(Flatten()) # model.add(Dense(500, activation=activation))
from keras.models import Sequential from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout from keras.callbacks import EarlyStopping from keras import backend as K import skimage from sklearn.model_selection import train_test_split import pydicom os.environ["CUDA_VISIBLE_DEVICES"] = "0" classifier = Sequential() classifier.add(Conv2D(64, (5, 5), input_shape=(256, 256, 1), activation='relu')) classifier.add(Dropout(0.2)) classifier.add(MaxPooling2D(pool_size=(4, 4))) classifier.add(Conv2D(32, (3, 3), activation='relu')) classifier.add(Dropout(0.2)) classifier.add(MaxPooling2D(pool_size=(4, 4))) classifier.add(Flatten()) classifier.add(Dense(units=128, activation='relu')) classifier.add(Dropout(0.3)) classifier.add(Dense(units=32, activation='relu')) classifier.add(Dense(units=1, activation='sigmoid')) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) X = [] y = []
def test_layer_design(): x_train, x_test, y_train, y_test = create_data_set(list(range(10)), 20) RI = de.reletive_information(x_train) dis_set = [] effectiveness_set = [] loss_set = [] ac_set = [] loop = 50 bs = 128 for i in range(loop): x_train, x_test, y_train, y_test = create_data_set(list(range(10)), 1000) model = Sequential() model.add(Conv2D(5, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) # model.add(Conv2D(10 + i * 5, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) # # #extra layer # extra layer model.add(Flatten()) # model.add(Dense(128, activation='relu')) # model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) # model.save_weights('Final_experiment/test_information_boundary/init.h5') # model.load_weights('Final_experiment/test_information_boundary_standardinit.h5') model.load_weights('Final_experiment/test_information_boundary_sliminit.h5') model.save_weights('Final_experiment/test_information_boundary/init.h5') model.fit(x_train, y_train, batch_size=bs, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) score = model.evaluate(x_test, y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) bs = bs-2 model.save_weights('Final_experiment/test_information_boundary/end.h5') dis,effectiveness = ef.effectiveness('Final_experiment/test_information_boundary/init.h5', 'Final_experiment/test_information_boundary/end.h5', model, kl.KL_div, RI) loss_set.append(score[0]) ac_set.append(score[1]) dis_set.append(dis) effectiveness_set.append(effectiveness) dr.save_data(loss_set,'Final_experiment/test_information_boundary/loss.csv') dr.save_data(ac_set, 'Final_experiment/test_information_boundary/ac.csv') dr.save_data(dis_set, 'Final_experiment/test_information_boundary/dis.csv') dr.save_data(effectiveness_set, 'Final_experiment/test_information_boundary/ef.csv') plt.plot(range(loop),loss_set,label = 'loss') plt.plot(range(loop), ac_set,label = 'accuracy') plt.legend() plt.savefig('Final_experiment/test_information_boundary/performance_evaluation.png') plt.close() plt.plot(range(loop), dis_set,label = 'dis') plt.legend() plt.savefig('Final_experiment/test_information_boundary/dis.png') plt.show()
model . fit ( x_train , y_train , batch_size = 100 , epochs = 20 ) result_train = model . evaluate ( x_train , y_train ) print ( '\nTrain Acc:\n' , result_train [ 1 ]) result_test = model . evaluate ( x_test , y_test ) print ( '\nTest Acc:\n' , result_test [ 1 ]) # do CNN x_train = x_train . reshape ( x_train . shape [ 0 ], 1 , 28 , 28 ) x_test = x_test . reshape ( x_test . shape [ 0 ], 1 , 28 , 28 ) model2 = Sequential () model2 . add ( Conv2D ( 25 , ( 3 , 3 ), input_shape =( 1 , 28 , 28 ), data_format = 'channels_first' )) model2 . add ( MaxPooling2D (( 2 , 2 ))) model2 . add ( Conv2D ( 50 , ( 3 , 3 ))) model2 . add ( MaxPooling2D (( 2 , 2 ))) model2 . add ( Flatten ()) model2 . add ( Dense ( units = 100 , activation = 'relu' )) model2 . add ( Dense ( units = 10 , activation = 'softmax' )) model2 . summary () model2 . compile ( loss = 'categorical_crossentropy' , optimizer = 'adam' , metrics =[ 'accuracy' ]) model2 . fit ( x_train , y_train , batch_size = 100 , epochs = 20 ) result_train = model2 . evaluate ( x_train , y_train ) print ( '\nTrain CNN Acc:\n' , result_train [ 1 ]) result_test = model2 . evaluate ( x_test , y_test )
def MusicTaggerCNN(): # number of convolutional filters to use nb_filters = 32 # size of pooling area for max pooling nb_pool = 2 # convolution kernel size nb_conv = 3 batch_size = 128 #nb_classes = 10 nb_epoch = 50 feq_num = 12 model = Sequential() # Conv layer 1 output shape (32, 300, 12) model.add( Convolution2D( batch_input_shape=(None, 1, seg_num, feq_num), filters=32, kernel_size=3, strides=1, padding='same', # Padding method data_format='channels_first', )) model.add(Activation('relu')) # Pooling layer 1 (max pooling) output shape (32, 150, 6) model.add( MaxPooling2D( pool_size=2, strides=2, padding='same', # Padding method data_format='channels_first', )) # Conv layer 2 output shape (64, 150, 6) model.add( Convolution2D(64, 3, strides=1, padding='same', data_format='channels_first')) model.add(Activation('relu')) # Pooling layer 2 (max pooling) output shape (64, 75, 3) model.add(MaxPooling2D(2, 2, 'same', data_format='channels_first')) # Fully connected layer 1 input shape (64 * 75 * 3) = (14400), output shape (1024) model.add(Flatten()) model.add(Dense(1024)) model.add(Activation('relu')) # Fully connected layer 2 to shape (40) for 40 classes model.add(Dense(40)) model.add(Activation('softmax')) # Another way to define your optimizer adam = Adam(lr=1e-4) model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy']) model.fit( X_train, Y_train, epochs=nb_epoch, batch_size=batch_size, ) return model
def mnist_cnnv_datagen(): """ 使用keras图片增强 :return: """ batch_size = 128 nb_classes = 10 # 分类数 nb_epoch = 12 # 训练轮数 # 输入图片的维度 img_rows, img_cols = 28, 28 # 卷积滤镜的个数 nb_filters = 32 # 最大池化,池化核大小 pool_size = (2, 2) # 卷积核大小 kernel_size = (3, 3) (X_train, y_train), (X_test, y_test) = mnist.load_data(os.path.join(root_path, "data", "mnist", "mnist.npz")) if K.image_dim_ordering() == 'th': # 使用 Theano 的顺序:(conv_dim1, channels, conv_dim2, conv_dim3) X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols) X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols) input_shape = (1, img_rows, img_cols) else: # 使用 TensorFlow 的顺序:(conv_dim1, conv_dim2, conv_dim3, channels) X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1) X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) model = keras.models.Sequential() model.add(Convolution2D(nb_filters, kernel_size, padding='same', input_shape=input_shape, data_format="channels_last", activation="relu")) model.add(Convolution2D(nb_filters, kernel_size, padding='same', activation="relu")) model.add(Convolution2D(nb_filters, kernel_size, padding='same', activation="relu")) model.add(MaxPooling2D(pool_size=pool_size)) model.add(Dropout(0.25)) model.add(Convolution2D(nb_filters * 2, kernel_size, padding='same', activation="relu")) model.add(Convolution2D(nb_filters * 2, kernel_size, padding='same', activation="relu")) model.add(Convolution2D(nb_filters * 2, kernel_size, padding='same', activation="relu")) model.add(MaxPooling2D(pool_size=pool_size)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation="relu")) model.add(Dropout(0.5)) model.add(Dense(nb_classes, activation="softmax")) model.summary() model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) # 图像增强 train_datagen = image.ImageDataGenerator(rotation_range=10, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True, vertical_flip=False) validation_datagen = image.ImageDataGenerator(rotation_range=10, width_shift_range=0.2, height_shift_range=0.2) train_datagen.fit(X_train) validation_datagen.fit(X_test) train_generate = train_datagen.flow(X_train, Y_train, batch_size=batch_size) validation_generate = train_datagen.flow(X_test, Y_test, batch_size=batch_size) model.fit_generator(train_generate, steps_per_epoch=X_train.shape[0] // batch_size, epochs=nb_epoch, verbose=1, validation_data=validation_generate, validation_steps=X_test.shape[0] // batch_size, workers=1, use_multiprocessing=False) test_loss, test_acc = model.evaluate_generator(validation_generate, steps=X_test.shape[0] // batch_size, workers=1, use_multiprocessing=False) logger.info('Test accuracy: {0} {1}'.format(test_loss, test_acc)) predictions = model.predict(X_test) predictions = np.argmax(predictions, 1) labels = np.argmax(Y_test, 1) for i in range(10): logger.info("predict:{0} , label:{1}".format(predictions[i], labels[i]))
first_image = image_batch[0] data_augmentation = Sequential([ keras.layers.experimental.preprocessing.RandomFlip("horizontal", input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, 3)), keras.layers.experimental.preprocessing.RandomRotation(0.1), keras.layers.experimental.preprocessing.RandomZoom(0.1) ]) num_classes = 120 model = Sequential(name="Dog_Breed_Classifier", layers=[ data_augmentation, keras.layers.experimental.preprocessing.Rescaling(1. / 255), Conv2D(16, 3, padding='same', activation='relu'), MaxPooling2D(), Conv2D(32, 3, padding='same', activation='relu'), MaxPooling2D(), Conv2D(64, 3, padding='same', activation='relu'), MaxPooling2D(), Dropout(0.2), Flatten(), Dense(128, activation='relu'), Dense(num_classes)]) model.compile(optimizer=Adam(), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) epochs = 5
def mnist_conv(): """ 使用卷积神经网络训练图片分类 :return: """ batch_size = 128 nb_classes = 10 # 分类数 nb_epoch = 20 # 训练轮数 # 输入图片的维度 img_rows, img_cols = 28, 28 # 卷积滤镜的个数 nb_filters = 32 # 最大池化,池化核大小 pool_size = (2, 2) # 卷积核大小 kernel_size = (3, 3) (X_train, y_train), (X_test, y_test) = mnist.load_data(os.path.join(root_path, "data", "mnist", "mnist.npz")) if K.image_dim_ordering() == 'th': # 使用 Theano 的顺序:(conv_dim1, channels, conv_dim2, conv_dim3) X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols) X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols) input_shape = (1, img_rows, img_cols) else: # 使用 TensorFlow 的顺序:(conv_dim1, conv_dim2, conv_dim3, channels) X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1) X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) model = keras.models.Sequential() # 可分离卷积 # model.add(SeparableConv2D(nb_filters, kernel_size, padding='valid', activation="relu", # input_shape=input_shape, data_format="channels_last")) model.add(Convolution2D(nb_filters, kernel_size, padding='valid', input_shape=input_shape, data_format="channels_last", activation="relu")) model.add(Convolution2D(nb_filters, kernel_size, padding="valid", activation="relu", data_format="channels_last")) model.add(MaxPooling2D(pool_size=pool_size)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation="relu")) model.add(Dropout(0.25)) model.add(Dense(nb_classes, activation="softmax")) model.summary() # keras.utils.vis_utils.plot_model(model, to_file="keras_mnist_cnn.png") model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) os.makedirs(os.path.join(root_path, "tmp", "mnist", "logs"), exist_ok=True) tensorBoard_callback = keras.callbacks.TensorBoard(os.path.join(root_path, "tmp", "mnist", "logs"), batch_size=batch_size, write_images=True, write_graph=True) os.makedirs(os.path.join(root_path, "tmp", "mnist", "models"), exist_ok=True) model_checkpoint = keras.callbacks.ModelCheckpoint( os.path.join(root_path, "tmp", "mnist", "models", "mnist_model_{epoch:02d}-{val_acc:.4f}.h5"), save_best_only=False, save_weights_only=False, monitor='val_acc') model.fit(X_train, Y_train, batch_size=batch_size, epochs=nb_epoch, verbose=1, validation_data=(X_test, Y_test), callbacks=[tensorBoard_callback, model_checkpoint]) test_loss, test_acc = model.evaluate(X_test, Y_test, verbose=1) logger.info('Test accuracy: {0} {1}'.format(test_loss, test_acc)) predictions = model.predict(X_test) predictions = np.argmax(predictions, 1) labels = np.argmax(Y_test, 1) for i in range(10): logger.info("predict:{0} , label:{1}".format(predictions[i], labels[i]))
# that is itself callable. It is not clear whether it is a function or an object - but we can call it as if it is a function. # This allows us to build computational graphs that are more complex than the Sequential Model allows # Create an input layer inputs = Input(shape=(img_size_flat, )) # Variable used for building the Nerual Network net = inputs # The input is an image as a flattened array with 784 elements # But the convolutional layers expected images with shape (28, 28, 1 net = Reshape(img_shape_full)(net) # First convolutional layer with relu-activation and max-pooling net = Conv2D(filters=16, kernel_size=5, strides=1, padding='same', name='layer_conv1')(net) net = MaxPooling2D(pool_size=2, strides=2)(net) # Second convolutional layer with relu-activation and max-pooling net = Conv2D(filters=36, kernel_size=5, strides=1, padding='same', name='layer_conv2')(net) net = MaxPooling2D(pool_size=2, strides=2)(net) # Flatten the output of the conv-layer from 4-dim to 2-dim net = Flatten()(net) # First fully-connected / dense layer with relu-activation net = Dense(128, activation='relu')(net) # Last fully-connected / dense layer with softmax-activation net = Dense(units=num_classes, activation='softmax')(net) outputs = net
def MyModel(input_shape): model = Sequential([ ############# ENCODER ############### # 224x224x1 Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv0', input_shape=input_shape), # BatchNormalization(axis=3, name='bn0'), # 224x224x64 Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv1'), # BatchNormalization(axis=3, name='bn1'), # 224x224x64 MaxPooling2D((2, 2), strides=(2, 2), name='max_pool1'), # 112x112x64 Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv2'), # BatchNormalization(axis=3, name='bn2'), # 112x112x128 Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv3'), # BatchNormalization(axis=3, name='bn3'), MaxPooling2D((2, 2), strides=(2, 2), name='max_pool3'), # 56x56x128 Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv4'), # BatchNormalization(axis=3, name='bn4'), # 56x56x256 Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv5'), # BatchNormalization(axis=3, name='bn5'), # 56x56x256 Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv6'), # BatchNormalization(axis=3, name='bn6'), # 56x56x256 MaxPooling2D((2, 2), strides=(2, 2), name='max_pool6'), # 28x28x256 Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv7'), # BatchNormalization(axis=3, name='bn7'), # 28x28x512 Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv8'), # BatchNormalization(axis=3, name='bn8'), # 28x28x512 Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv9'), # BatchNormalization(axis=3, name='bn9'), # 28x28x512 MaxPooling2D((2, 2), strides=(2, 2), name='max_pool9'), # 14x14x512 Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv10'), # BatchNormalization(axis=3, name='bn10'), # 14x14x512 Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv11'), # BatchNormalization(axis=3, name='bn11'), # 14x14x512 Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', name='conv12'), # BatchNormalization(axis=3, name='bn12'), # 14x14x512 MaxPooling2D((2, 2), strides=(2, 2), name='max_pool12'), # 7x7x512 ############# DECODER ############### # 7x7x512 Conv2D(512, (1, 1), strides=(1, 1), activation='relu', name='conv13'), # BatchNormalization(axis=3, name='bn13'), Dropout(0.3), # 7x7x512 UpSampling2D(size=(2, 2), name='upsampling14'), Conv2D(512, (5, 5), strides=(1, 1), padding='same', activation='relu', name='conv14'), # BatchNormalization(axis=3, name='bn14'), Dropout(0.3), # 14x14x512 UpSampling2D(size=(2, 2), name='upsampling15'), Conv2D(256, (5, 5), strides=(1, 1), padding='same', activation='relu', name='conv15'), # BatchNormalization(axis=3, name='bn15'), Dropout(0.3), # 28x28x256 UpSampling2D(size=(2, 2), name='upsampling16'), Conv2D(128, (5, 5), strides=(1, 1), padding='same', activation='relu', name='conv16'), # BatchNormalization(axis=3, name='bn16'), Dropout(0.3), # 56x56x128 UpSampling2D(size=(2, 2), name='upsampling17'), Conv2D(64, (5, 5), strides=(1, 1), padding='same', activation='relu', name='conv17'), # BatchNormalization(axis=3, name='bn17'), Dropout(0.3), # 112x112x64 UpSampling2D(size=(2, 2), name='upsampling18'), Conv2D(32, (5, 5), strides=(1, 1), padding='same', activation='relu', name='conv18'), # BatchNormalization(axis=3, name='bn18'), Dropout(0.3), # 224x224x32 Conv2D(2, (5, 5), strides=(1, 1), padding='same', activation='sigmoid', name='conv19'), # BatchNormalization(axis=3, name='bn19'), ], name='MyModel') # 224x224x2 return model
x_test = img_data[ int(split_ratio*np.shape(img_data)[0]):] print(X_train.shape) #.............................................................................. #Define input shape : input_shape = X_train[0].shape print(input_shape) #.............................................................................. # Encode the image : input_img = Input(shape=input_shape) x = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img) x = MaxPooling2D((2, 2), padding='same')(x) x = Conv2D(8, (3, 3), activation='relu', padding='same')(x) x = MaxPooling2D((2, 2), padding='same')(x) x = Conv2D(8, (3, 3), activation='relu', padding='same')(x) encoded = MaxPooling2D((2, 2), padding='same')(x) encoded_shape = encoded.shape print(encoded_shape) #.............................................................................. #Decode the encoded image : x = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded) x = UpSampling2D((2, 2))(x) x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)
FLAGS = flags.FLAGS flags.DEFINE_integer('nb_epochs', 6, 'Number of epochs to train model') flags.DEFINE_integer('batch_size', 128, 'Size of training batches') flags.DEFINE_float('learning_rate', 0.1, 'Learning rate for training') sess = tf.Session() keras.backend.set_session(sess) input_img = Input(shape=(1, 28, 28)) y = tf.placeholder(tf.float32, shape=(None, 10)) encoder = Sequential() x1 = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img) x2 = MaxPooling2D((2, 2), padding='same')(x1) x3 = Conv2D(8, (3, 3), activation='relu', padding='same')(x2) x4 = MaxPooling2D((2, 2), padding='same')(x3) x5 = Conv2D(8, (3, 3), activation='relu', padding='same')(x4) encoded = MaxPooling2D((2, 2), padding='same')(x5) ae = Model(input_img, encoded) encoder.add(ae) encoder.add(Flatten()) encoder.add(Dense(10)) encoder.summary() # at this point the representation is (4, 4, 8) i.e. 128-dimensional x6 = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded) x7 = UpSampling2D((2, 2))(x6) x8 = Conv2D(8, (3, 3), activation='relu', padding='same')(x7)
from keras.preprocessing.image import ImageDataGenerator #define cnn model using transfer learning #def define_model(): #load the model #model= VGG16(include_top= False, input_shape= (128,128,3)) #freeze model layers as not trainable #for layer in model.layers: #layer.trainable= False model= Sequential() model.add(Conv2D(32,(3,3), padding= 'same', activation= 'relu', input_shape=(128,128,3))) model.add(MaxPooling2D(2,2)) model.add(SpatialDropout2D(0.1)) #reduces overfitting model.add(Conv2D(32,(3,3), padding= 'same', activation= 'relu')) model.add(MaxPooling2D(2,2)) model.add(BatchNormalization()) model.add(SpatialDropout2D(0.2)) model.add(Conv2D(32,(3,3), padding= 'same', activation= 'relu')) model.add(MaxPooling2D(2,2)) model.add(BatchNormalization()) model.add(SpatialDropout2D(0.2)) model.add(Conv2D(32,(3,3), padding= 'same', activation= 'relu')) model.add(MaxPooling2D(2,2)) model.add(BatchNormalization())
def build_model(identity_len=57, orientation_len=2, emotion_len=Emotion.length(), initial_shape=(5,4), deconv_layers=5, num_kernels=None, optimizer='adam'): """ Builds a deconvolution FaceGen model. Args (optional): identity_len (int): Length of the identity input vector. orientation_len (int): Length of the orientation input vector. emotion_len (int): Length of the emotion input vector. initial_shape (tuple<int>): The starting shape of the deconv. network. deconv_layers (int): How many deconv. layers to use. More layers gives better resolution, although requires more GPU memory. num_kernels (list<int>): Number of convolution kernels for each layer. optimizer (str): The optimizer to use. Will only use default values. Returns: keras.Model, the constructed model. """ if num_kernels is None: num_kernels = [128, 128, 96, 96, 32, 32, 16] # TODO: Parameter validation identity_input = Input(shape=(identity_len,), name='identity') orientation_input = Input(shape=(orientation_len,), name='orientation') emotion_input = Input(shape=(emotion_len,), name='emotion') # Hidden representation for input parameters id_fc = LeakyReLU()( Dense(512)(identity_input) ) or_fc = LeakyReLU()( Dense(512)(orientation_input) ) em_fc = LeakyReLU()( Dense(512)(emotion_input) ) params = merge([id_fc, or_fc, em_fc], mode='concat') params = LeakyReLU()( Dense(1024)(params) ) # Apply deconvolution layers height, width = initial_shape x = LeakyReLU()( Dense(height*width*num_kernels[0])(params) ) if K.image_dim_ordering() == 'th': x = Reshape((num_kernels[0], height, width))(x) else: x = Reshape((height, width, num_kernels[0]))(x) for i in range(0, deconv_layers): # Pool and upsample x = MaxPooling2D((1,1))(x) x = UpSampling2D((2,2))(x) # Apply 5x5 and 3x3 convolutions # If we didn't specify the number of kernels to use for this many # layers, just repeat the last one in the list. idx = i if i < len(num_kernels) else -1 x = LeakyReLU()( Convolution2D(num_kernels[idx], 5, 5, border_mode='same')(x) ) x = LeakyReLU()( Convolution2D(num_kernels[idx], 3, 3, border_mode='same')(x) ) x = BatchNormalization()(x) # Last deconvolution layer: Create 3-channel image. x = MaxPooling2D((1,1))(x) x = UpSampling2D((2,2))(x) x = LeakyReLU()( Convolution2D(8, 5, 5, border_mode='same')(x) ) x = LeakyReLU()( Convolution2D(8, 3, 3, border_mode='same')(x) ) x = Convolution2D(3, 3, 3, border_mode='same', activation='sigmoid')(x) # Compile the model model = Model(input=[identity_input, orientation_input, emotion_input], output=x) # TODO: Optimizer options model.compile(optimizer=optimizer, loss='msle') return model
from keras.models import Sequential from keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, BatchNormalization, Dropout, GlobalAveragePooling2D from keras.optimizers import Adam from keras.callbacks import ReduceLROnPlateau, ModelCheckpoint model = Sequential() model.add( Conv2D(filters=32, kernel_size=3, activation='relu', padding='same', input_shape=(32, 32, 3))) model.add(Conv2D(filters=10, kernel_size=3, activation='relu', padding='same')) model.add(Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')) model.add(BatchNormalization()) model.add(MaxPooling2D()) model.add(Conv2D(filters=64, kernel_size=3, activation='relu', padding='same')) model.add(Conv2D(filters=10, kernel_size=3, activation='relu', padding='same')) model.add(Conv2D(filters=10, kernel_size=3, activation='relu', padding='same')) model.add(Conv2D(filters=64, kernel_size=3, activation='relu', padding='same')) model.add(BatchNormalization()) model.add(MaxPooling2D()) model.add(Conv2D(filters=128, kernel_size=3, activation='relu', padding='same')) model.add(Conv2D(filters=10, kernel_size=3, activation='relu', padding='same')) model.add(Conv2D(filters=10, kernel_size=3, activation='relu', padding='same')) model.add(Conv2D(filters=128, kernel_size=3, activation='relu', padding='same')) model.add(BatchNormalization()) model.add(MaxPooling2D()) model.add(Conv2D(filters=256, kernel_size=3, activation='relu',
def make_cifar10_model(**args): from keras.models import Sequential, Model from keras.layers import Dense, Activation, Dropout, Flatten, Input, Permute from keras.layers import Convolution2D, MaxPooling2D, Conv2D import keras.backend as K if args: logging.debug("receiving arguments {}".format(args)) nb_classes = 10 img_rows, img_cols = 32, 32 # use 1 kernel size for all convolutional layers ks = args.get('kernel_size', 3) # tune the number of filters for each convolution layer nb_filters1 = args.get('nb_filters1', 48) nb_filters2 = args.get('nb_filters2', 96) nb_filters3 = args.get('nb_filters3', 192) # tune the pool size once ps = args.get('pool_size', 2) pool_size = (ps, ps) # tune the dropout rates independently do4 = args.get('dropout1', 0.25) do5 = args.get('dropout2', 0.5) # tune the dense layers independently dense1 = args.get('dense1', 512) dense2 = args.get('dense2', 256) if K.image_dim_ordering() == 'th': input_shape = (3, img_rows, img_cols) else: input_shape = (img_rows, img_cols, 3) #act = 'sigmoid' act = 'relu' i = Input(input_shape) l = Conv2D(nb_filters1, (ks, ks), padding='same', activation=act)(i) l = MaxPooling2D(pool_size=pool_size)(l) #l = Dropout(do1)(l) l = Conv2D(nb_filters2, (ks, ks), padding='same', activation=act)(l) #l = Conv2D(nb_filters2, (ks, ks))(l) l = MaxPooling2D(pool_size=pool_size)(l) #l = Dropout(do2)(l) l = Conv2D(nb_filters3, (ks, ks), padding='same', activation=act)(l) #l = Conv2D(nb_filters3, (ks, ks))(l) l = MaxPooling2D(pool_size=pool_size)(l) #l = Dropout(do3)(l) l = Flatten()(l) l = Dense(dense1, activation=act)(l) l = Dropout(do4)(l) l = Dense(dense2, activation=act)(l) l = Dropout(do5)(l) o = Dense(nb_classes, activation='softmax')(l) model = Model(inputs=i, outputs=o) #model.summary() return model
from keras.layers import Flatten from keras.layers import Dense #Initialising the CNN classifier = Sequential() # Step 1 -- Convolution classifier.add( Convolution2D(32, 3, 3, input_shape=(64, 64, 3), activation='relu') ) # as we are using the TEnserFlow packet and hence the arguements are accepted in the reverse order # Step 2 --> MAx Pooling classifier.add(MaxPooling2D(pool_size=(2, 2))) # Adding a second Convolution layer classifier.add(Convolution2D( 32, 3, 3, activation='relu')) #since keras knows the images now classifier.add(MaxPooling2D(pool_size=(2, 2))) # Step 3 --> Flattening classifier.add(Flatten()) #Step 4--> Full COnnections classifier.add(Dense(output_dim=128, activation='relu')) #HIDDEN LAYER classifier.add(Dense(output_dim=1, activation='sigmoid')) #OUTPUT LAYER
def buildNetwork(self): """ Assemble shared layers """ inp = Input((self.env_dim)) x = Reshape(self.env_dim)(inp) # Break input into s images for each history window inputs = [] for s in range(self.env_dim[-1]): inputs.append(Reshape((self.env_dim[0], self.env_dim[1], 1)) \ (Lambda(lambda x: x[:,:,:,s])(inp))) ### Create feature extraction network for each history image outs = [] for i in inputs: x = Conv2D(kernel_size=(8, 8), strides=(4, 4), filters=8, activation='relu', padding='same', kernel_regularizer=keras.regularizers.l2(0.01))(i) x = Conv2D(kernel_size=(4, 4), strides=(2, 2), filters=16, activation='relu', padding='same', kernel_regularizer=keras.regularizers.l2(0.01))(x) x = Conv2D(kernel_size=(3, 3), strides=(1, 1), filters=16, activation='relu', padding='same', kernel_regularizer=keras.regularizers.l2(0.01))(x) x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(x) outs.append( Reshape((self.env_dim[0] // 2 // 2 // 2, self.env_dim[1] // 2 // 2 // 2, -1))(x)) ### Concatenate history network outputs x = Concatenate(axis=-1)(outs) x = Conv2D(kernel_size=(3, 3), strides=(1, 1), filters=32, activation='relu', padding='same', kernel_regularizer=keras.regularizers.l2(0.01))(x) x = Conv2D(kernel_size=(3, 3), strides=(1, 1), filters=64, activation='relu', padding='same', kernel_regularizer=keras.regularizers.l2(0.01))(x) x = Conv2D(kernel_size=(3, 3), strides=(1, 1), filters=64, activation='relu', padding='same', kernel_regularizer=keras.regularizers.l2(0.01))(x) x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(x) x = Flatten()(x) return Model(inp, x)
nb_filters = 72 pool_size = (2, 2) kernel_size = (3, 3) input_shape = (img_rows, img_cols, 1) model = Sequential() model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1], border_mode='valid', input_shape=input_shape, name="conv_1", init='glorot_normal')) model.add(MaxPooling2D(pool_size=pool_size, name="maxpool_1")) model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1], name="conv_2", init='glorot_normal')) model.add(MaxPooling2D(pool_size=pool_size, name="maxpool_2")) model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1], name="conv_3", init='glorot_normal')) model.add(MaxPooling2D(pool_size=pool_size, name="maxpool_3")) model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1], name="conv_4", init='glorot_normal')) model.add(MaxPooling2D(pool_size=pool_size, name="maxpool_4")) model.add(BatchNormalization(epsilon=0.001, mode=0, axis=-1, momentum=0.99, weights=None, beta_init='zero', gamma_init='one', gamma_regularizer=None, beta_regularizer=None)) model.add(Flatten()) model.add(Dense(nb_classes, init='glorot_normal')) model.add(Activation('linear')) model.compile(loss='hinge', optimizer='adadelta', metrics=['accuracy'])
batch_size=BS, target_size=TS) valid_batch = generator('data/valid', shuffle=True, batch_size=BS, target_size=TS) SPE = len(train_batch.classes) // BS VS = len(valid_batch.classes) // BS print(SPE, VS) # img,labels= next(train_batch) # print(img.shape) model = Sequential([ Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(24, 24, 1)), MaxPooling2D(pool_size=(1, 1)), Conv2D(32, (3, 3), activation='relu'), MaxPooling2D(pool_size=(1, 1)), #32 convolution filters used each of size 3x3 #again Conv2D(64, (3, 3), activation='relu'), MaxPooling2D(pool_size=(1, 1)), #64 convolution filters used each of size 3x3 #choose the best features via pooling #randomly turn neurons on and off to improve convergence Dropout(0.25), #flatten since too many dimensions, we only want a classification output Flatten(), #fully connected to get all relevant data
def _main(args): print(args.config_path) config_path = os.path.expanduser(args.config_path) weights_path = os.path.expanduser(args.weights_path) print(config_path) assert config_path.endswith('.cfg'), '{} is not a .cfg file'.format( config_path) assert weights_path.endswith( '.weights'), '{} is not a .weights file'.format(weights_path) output_path = os.path.expanduser(args.output_path) assert output_path.endswith( '.h5'), 'output path {} is not a .h5 file'.format(output_path) output_root = os.path.splitext(output_path)[0] # Load weights and config. print('Loading weights.') weights_file = open(weights_path, 'rb') major, minor, revision = np.ndarray( shape=(3, ), dtype='int32', buffer=weights_file.read(12)) if (major*10+minor)>=2 and major<1000 and minor<1000: seen = np.ndarray(shape=(1,), dtype='int64', buffer=weights_file.read(8)) else: seen = np.ndarray(shape=(1,), dtype='int32', buffer=weights_file.read(4)) print('Weights Header: ', major, minor, revision, seen) print('Parsing Darknet config.') unique_config_file = unique_config_sections(config_path) cfg_parser = configparser.ConfigParser() cfg_parser.read_file(unique_config_file) print('Creating Keras model.') input_layer = Input(shape=(None, None, 3)) prev_layer = input_layer all_layers = [] weight_decay = float(cfg_parser['net_0']['decay'] ) if 'net_0' in cfg_parser.sections() else 5e-4 count = 0 out_index = [] for section in cfg_parser.sections(): print('Parsing section {}'.format(section)) if section.startswith('convolutional'): filters = int(cfg_parser[section]['filters']) size = int(cfg_parser[section]['size']) stride = int(cfg_parser[section]['stride']) pad = int(cfg_parser[section]['pad']) activation = cfg_parser[section]['activation'] batch_normalize = 'batch_normalize' in cfg_parser[section] padding = 'same' if pad == 1 and stride == 1 else 'valid' # Setting weights. # Darknet serializes convolutional weights as: # [bias/beta, [gamma, mean, variance], conv_weights] prev_layer_shape = K.int_shape(prev_layer) weights_shape = (size, size, prev_layer_shape[-1], filters) darknet_w_shape = (filters, weights_shape[2], size, size) weights_size = np.product(weights_shape) print('conv2d', 'bn' if batch_normalize else ' ', activation, weights_shape) conv_bias = np.ndarray( shape=(filters, ), dtype='float32', buffer=weights_file.read(filters * 4)) count += filters if batch_normalize: bn_weights = np.ndarray( shape=(3, filters), dtype='float32', buffer=weights_file.read(filters * 12)) count += 3 * filters bn_weight_list = [ bn_weights[0], # scale gamma conv_bias, # shift beta bn_weights[1], # running mean bn_weights[2] # running var ] conv_weights = np.ndarray( shape=darknet_w_shape, dtype='float32', buffer=weights_file.read(weights_size * 4)) count += weights_size # DarkNet conv_weights are serialized Caffe-style: # (out_dim, in_dim, height, width) # We would like to set these to Tensorflow order: # (height, width, in_dim, out_dim) conv_weights = np.transpose(conv_weights, [2, 3, 1, 0]) conv_weights = [conv_weights] if batch_normalize else [ conv_weights, conv_bias ] # Handle activation. act_fn = None if activation == 'leaky': pass # Add advanced activation later. elif activation != 'linear': raise ValueError( 'Unknown activation function `{}` in section {}'.format( activation, section)) # Create Conv2D layer if stride>1: # Darknet uses left and top padding instead of 'same' mode prev_layer = ZeroPadding2D(((1,0),(1,0)))(prev_layer) conv_layer = (Conv2D( filters, (size, size), strides=(stride, stride), kernel_regularizer=l2(weight_decay), use_bias=not batch_normalize, weights=conv_weights, activation=act_fn, padding=padding))(prev_layer) if batch_normalize: conv_layer = (BatchNormalization( weights=bn_weight_list))(conv_layer) prev_layer = conv_layer if activation == 'linear': all_layers.append(prev_layer) elif activation == 'leaky': act_layer = LeakyReLU(alpha=0.1)(prev_layer) prev_layer = act_layer all_layers.append(act_layer) elif section.startswith('route'): ids = [int(i) for i in cfg_parser[section]['layers'].split(',')] layers = [all_layers[i] for i in ids] if len(layers) > 1: print('Concatenating route layers:', layers) concatenate_layer = Concatenate()(layers) all_layers.append(concatenate_layer) prev_layer = concatenate_layer else: skip_layer = layers[0] # only one layer to route all_layers.append(skip_layer) prev_layer = skip_layer elif section.startswith('maxpool'): size = int(cfg_parser[section]['size']) stride = int(cfg_parser[section]['stride']) all_layers.append( MaxPooling2D( pool_size=(size, size), strides=(stride, stride), padding='same')(prev_layer)) prev_layer = all_layers[-1] elif section.startswith('shortcut'): index = int(cfg_parser[section]['from']) activation = cfg_parser[section]['activation'] assert activation == 'linear', 'Only linear activation supported.' all_layers.append(Add()([all_layers[index], prev_layer])) prev_layer = all_layers[-1] elif section.startswith('upsample'): stride = int(cfg_parser[section]['stride']) assert stride == 2, 'Only stride=2 supported.' all_layers.append(UpSampling2D(stride)(prev_layer)) prev_layer = all_layers[-1] elif section.startswith('yolo'): out_index.append(len(all_layers)-1) all_layers.append(None) prev_layer = all_layers[-1] elif section.startswith('net'): pass else: raise ValueError( 'Unsupported section header type: {}'.format(section)) # Create and save model. if len(out_index)==0: out_index.append(len(all_layers)-1) model = Model(inputs=input_layer, outputs=[all_layers[i] for i in out_index]) print(model.summary()) if args.weights_only: model.save_weights('{}'.format(output_path)) print('Saved Keras weights to {}'.format(output_path)) else: model.save('{}'.format(output_path)) print('Saved Keras model to {}'.format(output_path)) # Check to see if all weights have been read. remaining_weights = len(weights_file.read()) / 4 weights_file.close() print('Read {} of {} from Darknet weights.'.format(count, count + remaining_weights)) if remaining_weights > 0: print('Warning: {} unused weights'.format(remaining_weights)) if args.plot_model: plot(model, to_file='{}.png'.format(output_root), show_shapes=True) print('Saved model plot to {}.png'.format(output_root))
def build_cnn(nr_convs): model = Sequential() model.add(Conv2D(32, (5, 5), name="conv1", activation='relu', input_shape=(224,224,3))) model.add(BatchNormalization(axis=3, name="batch1")) model.add(MaxPooling2D(pool_size=(2,2), name="pool1")) if(nr_convs > 1): model.add(Conv2D(16, (5, 5), name="conv2", activation='relu')) model.add(BatchNormalization(axis=3, name="batch2")) model.add(MaxPooling2D(pool_size=(2,2), name="pool2")) if(nr_convs > 2): model.add(Conv2D(64, (5, 5), name="conv3", activation='relu')) model.add(BatchNormalization(axis=3, name="batch3")) model.add(MaxPooling2D(pool_size=(2,2), name="pool3")) if(nr_convs > 3): model.add(Conv2D(32, (3, 3), name="conv4", activation='relu')) model.add(BatchNormalization(axis=3, name="batch4")) model.add(MaxPooling2D(pool_size=(2,2), name="pool4")) if(nr_convs > 4): model.add(Conv2D(32, (3, 3), name="conv5", activation='relu')) model.add(BatchNormalization(axis=3, name="batch5")) model.add(MaxPooling2D(pool_size=(2,2), name="pool5")) if(nr_convs > 5): model.add(Conv2D(32, (3, 3), name="conv6", activation='relu')) model.add(BatchNormalization(axis=3, name="batch6")) model.add(MaxPooling2D(pool_size=(2,2), name="pool6")) if(nr_convs > 6): model.add(Conv2D(16, (3, 3), name="conv7", activation='relu')) model.add(BatchNormalization(axis=3, name="batch7")) model.add(MaxPooling2D(pool_size=(2,2), name="pool7")) if(nr_convs > 7): model.add(Conv2D(8, (3, 3), name="conv8", activation='relu')) model.add(BatchNormalization(axis=3, name="batch8")) model.add(MaxPooling2D(pool_size=(2,2), name="pool8")) if(nr_convs > 8): model.add(Conv2D(8, (3, 3), name="conv9", activation='relu')) model.add(BatchNormalization(axis=3, name="batch9")) model.add(MaxPooling2D(pool_size=(2,2), name="pool9")) #model.add(Dropout(0.25)) # model.add(Flatten()) model.add(Dense(64, activation='relu', name='dense1')) model.add(Dropout(0.25)) model.add(Dense(32, activation='relu', name='dense2')) model.add(Dense(16, activation='relu', name='dense3')) model.add(Dense(2, activation='softmax', name='dense4')) # sgd = SGD(lr=1e-6, decay=4e-5, momentum=0.9, nesterov=False) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) return model
], class_mode='other', batch_size=16) #create model model = Sequential() #add model layers model.add( Conv2D(64, data_format="channels_last", kernel_size=3, input_shape=(108, 192, 3), activation='relu')) model.add(Conv2D(64, kernel_size=3, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(128, kernel_size=3, activation='relu')) model.add(Conv2D(128, kernel_size=3, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(256, kernel_size=3, activation='relu')) model.add(Conv2D(256, kernel_size=3, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(1024, activation='relu')) model.add(Dense(32, activation='relu')) #compile model using accuracy to measure model performance model.compile(optimizer='adam', loss='mean_squared_error', metrics=['accuracy'])
def build_model(image_size, n_classes, min_scale=0.1, max_scale=0.9, scales=None, aspect_ratios_global=[0.5, 1.0, 2.0], aspect_ratios_per_layer=None, two_boxes_for_ar1=True, limit_boxes=True, variances=[1.0, 1.0, 1.0, 1.0], coords='centroids', normalize_coords=False): ''' Build a Keras model with SSD architecture, see references. The model consists of convolutional feature layers and a number of convolutional predictor layers that take their input from different feature layers. The model is fully convolutional. The implementation found here is a smaller version of the original architecture used in the paper (where the base network consists of a modified VGG-16 extended by a few convolutional feature layers), but of course it could easily be changed to an arbitrarily large SSD architecture by following the general design pattern used here. This implementation has 7 convolutional layers and 4 convolutional predictor layers that take their input from layers 4, 5, 6, and 7, respectively. In case you're wondering why this function has so many arguments: All arguments except the first two (`image_size` and `n_classes`) are only needed so that the anchor box layers can produce the correct anchor boxes. In case you're training the network, the parameters passed here must be the same as the ones used to set up `SSDBoxEncoder`. In case you're loading trained weights, the parameters passed here must be the same as the ones used to produce the trained weights. Some of these arguments are explained in more detail in the documentation of the `SSDBoxEncoder` class. Note: Requires Keras v2.0 or later. Training currently works only with the TensorFlow backend (v1.0 or later). Arguments: image_size (tuple): The input image size in the format `(height, width, channels)`. n_classes (int): The number of categories for classification including the background class (i.e. the number of positive classes +1 for the background calss). min_scale (float, optional): The smallest scaling factor for the size of the anchor boxes as a fraction of the shorter side of the input images. Defaults to 0.1. max_scale (float, optional): The largest scaling factor for the size of the anchor boxes as a fraction of the shorter side of the input images. All scaling factors between the smallest and the largest will be linearly interpolated. Note that the second to last of the linearly interpolated scaling factors will actually be the scaling factor for the last predictor layer, while the last scaling factor is used for the second box for aspect ratio 1 in the last predictor layer if `two_boxes_for_ar1` is `True`. Defaults to 0.9. scales (list, optional): A list of floats containing scaling factors per convolutional predictor layer. This list must be one element longer than the number of predictor layers. The first `k` elements are the scaling factors for the `k` predictor layers, while the last element is used for the second box for aspect ratio 1 in the last predictor layer if `two_boxes_for_ar1` is `True`. This additional last scaling factor must be passed either way, even if it is not being used. Defaults to `None`. If a list is passed, this argument overrides `min_scale` and `max_scale`. All scaling factors must be greater than zero. aspect_ratios_global (list, optional): The list of aspect ratios for which anchor boxes are to be generated. This list is valid for all predictor layers. The original implementation uses more aspect ratios for some predictor layers and fewer for others. If you want to do that, too, then use the next argument instead. Defaults to `[0.5, 1.0, 2.0]`. aspect_ratios_per_layer (list, optional): A list containing one aspect ratio list for each predictor layer. This allows you to set the aspect ratios for each predictor layer individually. If a list is passed, it overrides `aspect_ratios_global`. Defaults to `None`. two_boxes_for_ar1 (bool, optional): Only relevant for aspect ratio lists that contain 1. Will be ignored otherwise. If `True`, two anchor boxes will be generated for aspect ratio 1. The first will be generated using the scaling factor for the respective layer, the second one will be generated using geometric mean of said scaling factor and next bigger scaling factor. Defaults to `True`, following the original implementation. limit_boxes (bool, optional): If `True`, limits box coordinates to stay within image boundaries. This would normally be set to `True`, but here it defaults to `False`, following the original implementation. variances (list, optional): A list of 4 floats >0 with scaling factors (actually it's not factors but divisors to be precise) for the encoded predicted box coordinates. A variance value of 1.0 would apply no scaling at all to the predictions, while values in (0,1) upscale the encoded predictions and values greater than 1.0 downscale the encoded predictions. If you want to reproduce the configuration of the original SSD, set this to `[0.1, 0.1, 0.2, 0.2]`, provided the coordinate format is 'centroids'. Defaults to `[1.0, 1.0, 1.0, 1.0]`. coords (str, optional): The box coordinate format to be used. Can be either 'centroids' for the format `(cx, cy, w, h)` (box center coordinates, width, and height) or 'minmax' for the format `(xmin, xmax, ymin, ymax)`. Defaults to 'centroids'. normalize_coords (bool, optional): Set to `True` if the model is supposed to use relative instead of absolute coordinates, i.e. if the model predicts box coordinates within [0,1] instead of absolute coordinates. Defaults to `False`. Returns: model: The Keras SSD model. predictor_sizes: A Numpy array containing the `(height, width)` portion of the output tensor shape for each convolutional predictor layer. During training, the generator function needs this in order to transform the ground truth labels into tensors of identical structure as the output tensors of the model, which is in turn needed for the cost function. References: https://arxiv.org/abs/1512.02325v5 ''' n_predictor_layers = 4 # The number of predictor conv layers in the network # Get a few exceptions out of the way first if aspect_ratios_global is None and aspect_ratios_per_layer is None: raise ValueError("`aspect_ratios_global` and `aspect_ratios_per_layer` cannot both be None. At least one needs to be specified.") if aspect_ratios_per_layer: if len(aspect_ratios_per_layer) != n_predictor_layers: raise ValueError("It must be either aspect_ratios_per_layer is None or len(aspect_ratios_per_layer) == {}, but len(aspect_ratios_per_layer) == {}.".format(n_predictor_layers, len(aspect_ratios_per_layer))) if (min_scale is None or max_scale is None) and scales is None: raise ValueError("Either `min_scale` and `max_scale` or `scales` need to be specified.") if scales: if len(scales) != n_predictor_layers+1: raise ValueError("It must be either scales is None or len(scales) == {}, but len(scales) == {}.".format(n_predictor_layers+1, len(scales))) else: # If no explicit list of scaling factors was passed, compute the list of scaling factors from `min_scale` and `max_scale` scales = np.linspace(min_scale, max_scale, n_predictor_layers+1) if len(variances) != 4: # We need one variance value for each of the four box coordinates raise ValueError("4 variance values must be pased, but {} values were received.".format(len(variances))) variances = np.array(variances) if np.any(variances <= 0): raise ValueError("All variances must be >0, but the variances given are {}".format(variances)) # Set the aspect ratios for each predictor layer. These are only needed for the anchor box layers. if aspect_ratios_per_layer: aspect_ratios_conv4 = aspect_ratios_per_layer[0] aspect_ratios_conv5 = aspect_ratios_per_layer[1] aspect_ratios_conv6 = aspect_ratios_per_layer[2] aspect_ratios_conv7 = aspect_ratios_per_layer[3] else: aspect_ratios_conv4 = aspect_ratios_global aspect_ratios_conv5 = aspect_ratios_global aspect_ratios_conv6 = aspect_ratios_global aspect_ratios_conv7 = aspect_ratios_global # Compute the number of boxes to be predicted per cell for each predictor layer. # We need this so that we know how many channels the predictor layers need to have. if aspect_ratios_per_layer: n_boxes = [] for aspect_ratios in aspect_ratios_per_layer: if (1 in aspect_ratios) & two_boxes_for_ar1: n_boxes.append(len(aspect_ratios) + 1) # +1 for the second box for aspect ratio 1 else: n_boxes.append(len(aspect_ratios)) n_boxes_conv4 = n_boxes[0] n_boxes_conv5 = n_boxes[1] n_boxes_conv6 = n_boxes[2] n_boxes_conv7 = n_boxes[3] else: # If only a global aspect ratio list was passed, then the number of boxes is the same for each predictor layer if (1 in aspect_ratios_global) & two_boxes_for_ar1: n_boxes = len(aspect_ratios_global) + 1 else: n_boxes = len(aspect_ratios_global) n_boxes_conv4 = n_boxes n_boxes_conv5 = n_boxes n_boxes_conv6 = n_boxes n_boxes_conv7 = n_boxes # Input image format img_height, img_width, img_channels = image_size[0], image_size[1], image_size[2] # Design the actual network x = Input(shape=(img_height, img_width, img_channels)) normed = Lambda(lambda z: z/127.5 - 1., # Convert input feature range to [-1,1] output_shape=(img_height, img_width, img_channels), name='lambda1')(x) conv1 = Conv2D(32, (5, 5), name='conv1', strides=(1, 1), padding="same")(normed) conv1 = BatchNormalization(axis=3, momentum=0.99, name='bn1')(conv1) # Tensorflow uses filter format [filter_height, filter_width, in_channels, out_channels], hence axis = 3 conv1 = ELU(name='elu1')(conv1) pool1 = MaxPooling2D(pool_size=(2, 2), name='pool1')(conv1) conv2 = Conv2D(48, (3, 3), name='conv2', strides=(1, 1), padding="same")(pool1) conv2 = BatchNormalization(axis=3, momentum=0.99, name='bn2')(conv2) conv2 = ELU(name='elu2')(conv2) pool2 = MaxPooling2D(pool_size=(2, 2), name='pool2')(conv2) conv3 = Conv2D(64, (3, 3), name='conv3', strides=(1, 1), padding="same")(pool2) conv3 = BatchNormalization(axis=3, momentum=0.99, name='bn3')(conv3) conv3 = ELU(name='elu3')(conv3) pool3 = MaxPooling2D(pool_size=(2, 2), name='pool3')(conv3) conv4 = Conv2D(64, (3, 3), name='conv4', strides=(1, 1), padding="same")(pool3) conv4 = BatchNormalization(axis=3, momentum=0.99, name='bn4')(conv4) conv4 = ELU(name='elu4')(conv4) pool4 = MaxPooling2D(pool_size=(2, 2), name='pool4')(conv4) conv5 = Conv2D(48, (3, 3), name='conv5', strides=(1, 1), padding="same")(pool4) conv5 = BatchNormalization(axis=3, momentum=0.99, name='bn5')(conv5) conv5 = ELU(name='elu5')(conv5) pool5 = MaxPooling2D(pool_size=(2, 2), name='pool5')(conv5) conv6 = Conv2D(48, (3, 3), name='conv6', strides=(1, 1), padding="same")(pool5) conv6 = BatchNormalization(axis=3, momentum=0.99, name='bn6')(conv6) conv6 = ELU(name='elu6')(conv6) pool6 = MaxPooling2D(pool_size=(2, 2), name='pool6')(conv6) conv7 = Conv2D(32, (3, 3), name='conv7', strides=(1, 1), padding="same")(pool6) conv7 = BatchNormalization(axis=3, momentum=0.99, name='bn7')(conv7) conv7 = ELU(name='elu7')(conv7) # The next part is to add the convolutional predictor layers on top of the base network # that we defined above. Note that I use the term "base network" differently than the paper does. # To me, the base network is everything that is not convolutional predictor layers or anchor # box layers. In this case we'll have four predictor layers, but of course you could # easily rewrite this into an arbitrarily deep base network and add an arbitrary number of # predictor layers on top of the base network by simply following the pattern shown here. # Build the convolutional predictor layers on top of conv layers 4, 5, 6, and 7 # We build two predictor layers on top of each of these layers: One for classes (classification), one for box coordinates (localization) # We precidt `n_classes` confidence values for each box, hence the `classes` predictors have depth `n_boxes * n_classes` # We predict 4 box coordinates for each box, hence the `boxes` predictors have depth `n_boxes * 4` # Output shape of `classes`: `(batch, height, width, n_boxes * n_classes)` classes4 = Conv2D(n_boxes_conv4 * n_classes, (3, 3), strides=(1, 1), padding="valid", name='classes4')(conv4) classes5 = Conv2D(n_boxes_conv5 * n_classes, (3, 3), strides=(1, 1), padding="valid", name='classes5')(conv5) classes6 = Conv2D(n_boxes_conv6 * n_classes, (3, 3), strides=(1, 1), padding="valid", name='classes6')(conv6) classes7 = Conv2D(n_boxes_conv7 * n_classes, (3, 3), strides=(1, 1), padding="valid", name='classes7')(conv7) # Output shape of `boxes`: `(batch, height, width, n_boxes * 4)` boxes4 = Conv2D(n_boxes_conv4 * 4, (3, 3), strides=(1, 1), padding="valid", name='boxes4')(conv4) boxes5 = Conv2D(n_boxes_conv5 * 4, (3, 3), strides=(1, 1), padding="valid", name='boxes5')(conv5) boxes6 = Conv2D(n_boxes_conv6 * 4, (3, 3), strides=(1, 1), padding="valid", name='boxes6')(conv6) boxes7 = Conv2D(n_boxes_conv7 * 4, (3, 3), strides=(1, 1), padding="valid", name='boxes7')(conv7) # Generate the anchor boxes # Output shape of `anchors`: `(batch, height, width, n_boxes, 8)` anchors4 = AnchorBoxes(img_height, img_width, this_scale=scales[0], next_scale=scales[1], aspect_ratios=aspect_ratios_conv4, two_boxes_for_ar1=two_boxes_for_ar1, limit_boxes=limit_boxes, variances=variances, coords=coords, normalize_coords=normalize_coords, name='anchors4')(boxes4) anchors5 = AnchorBoxes(img_height, img_width, this_scale=scales[1], next_scale=scales[2], aspect_ratios=aspect_ratios_conv5, two_boxes_for_ar1=two_boxes_for_ar1, limit_boxes=limit_boxes, variances=variances, coords=coords, normalize_coords=normalize_coords, name='anchors5')(boxes5) anchors6 = AnchorBoxes(img_height, img_width, this_scale=scales[2], next_scale=scales[3], aspect_ratios=aspect_ratios_conv6, two_boxes_for_ar1=two_boxes_for_ar1, limit_boxes=limit_boxes, variances=variances, coords=coords, normalize_coords=normalize_coords, name='anchors6')(boxes6) anchors7 = AnchorBoxes(img_height, img_width, this_scale=scales[3], next_scale=scales[4], aspect_ratios=aspect_ratios_conv7, two_boxes_for_ar1=two_boxes_for_ar1, limit_boxes=limit_boxes, variances=variances, coords=coords, normalize_coords=normalize_coords, name='anchors7')(boxes7) # Reshape the class predictions, yielding 3D tensors of shape `(batch, height * width * n_boxes, n_classes)` # We want the classes isolated in the last axis to perform softmax on them classes4_reshaped = Reshape((-1, n_classes), name='classes4_reshape')(classes4) classes5_reshaped = Reshape((-1, n_classes), name='classes5_reshape')(classes5) classes6_reshaped = Reshape((-1, n_classes), name='classes6_reshape')(classes6) classes7_reshaped = Reshape((-1, n_classes), name='classes7_reshape')(classes7) # Reshape the box coordinate predictions, yielding 3D tensors of shape `(batch, height * width * n_boxes, 4)` # We want the four box coordinates isolated in the last axis to compute the smooth L1 loss boxes4_reshaped = Reshape((-1, 4), name='boxes4_reshape')(boxes4) boxes5_reshaped = Reshape((-1, 4), name='boxes5_reshape')(boxes5) boxes6_reshaped = Reshape((-1, 4), name='boxes6_reshape')(boxes6) boxes7_reshaped = Reshape((-1, 4), name='boxes7_reshape')(boxes7) # Reshape the anchor box tensors, yielding 3D tensors of shape `(batch, height * width * n_boxes, 8)` anchors4_reshaped = Reshape((-1, 8), name='anchors4_reshape')(anchors4) anchors5_reshaped = Reshape((-1, 8), name='anchors5_reshape')(anchors5) anchors6_reshaped = Reshape((-1, 8), name='anchors6_reshape')(anchors6) anchors7_reshaped = Reshape((-1, 8), name='anchors7_reshape')(anchors7) # Concatenate the predictions from the different layers and the assosciated anchor box tensors # Axis 0 (batch) and axis 2 (n_classes or 4, respectively) are identical for all layer predictions, # so we want to concatenate along axis 1 # Output shape of `classes_merged`: (batch, n_boxes_total, n_classes) classes_concat = Concatenate(axis=1, name='classes_concat')([classes4_reshaped, classes5_reshaped, classes6_reshaped, classes7_reshaped]) # Output shape of `boxes_final`: (batch, n_boxes_total, 4) boxes_concat = Concatenate(axis=1, name='boxes_concat')([boxes4_reshaped, boxes5_reshaped, boxes6_reshaped, boxes7_reshaped]) # Output shape of `anchors_final`: (batch, n_boxes_total, 8) anchors_concat = Concatenate(axis=1, name='anchors_concat')([anchors4_reshaped, anchors5_reshaped, anchors6_reshaped, anchors7_reshaped]) # The box coordinate predictions will go into the loss function just the way they are, # but for the class predictions, we'll apply a softmax activation layer first classes_softmax = Activation('softmax', name='classes_softmax')(classes_concat) # Concatenate the class and box coordinate predictions and the anchors to one large predictions tensor # Output shape of `predictions`: (batch, n_boxes_total, n_classes + 4 + 8) predictions = Concatenate(axis=2, name='predictions')([classes_softmax, boxes_concat, anchors_concat]) model = Model(inputs=x, outputs=predictions) # Get the spatial dimensions (height, width) of the convolutional predictor layers, we need them to generate the default boxes # The spatial dimensions are the same for the `classes` and `boxes` predictors predictor_sizes = np.array([classes4._keras_shape[1:3], classes5._keras_shape[1:3], classes6._keras_shape[1:3], classes7._keras_shape[1:3]]) return model, predictor_sizes
########################## # source model ########################## input = Input(shape=(IMG_ROWS,IMG_COLS,IMG_CHANNELS)) # build model out = Conv2D(64, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), name='block1_conv1')(input) out = BatchNormalization(name='batch_normalization_1')(out) out = Activation('relu')(out) out = Conv2D(64, (3, 3),padding='same', kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), name='block1_conv2')(out) out = BatchNormalization(name='batch_normalization_2')(out) out = Activation('relu')(out) out = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(out) # Block 2 out = Conv2D(128, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), name='block2_conv1')(out) out = BatchNormalization(name='batch_normalization_3')(out) out = Activation('relu')(out) out = Conv2D(128, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), name='block2_conv2')(out) out = BatchNormalization(name='batch_normalization_4')(out) out = Activation('relu')(out) out = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(out) # Block 3 out = Conv2D(256, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), name='block3_conv1')(out) out = BatchNormalization(name='batch_normalization_5')(out) out = Activation('relu')(out) out = Conv2D(256, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(weight_decay), kernel_initializer=he_normal(), name='block3_conv2')(out)
input_shape = tuple([X_train.shape[x] for x in range(1, len(X_train.shape))]) print(input_shape) inputs = Input(shape=input_shape) zen_layer = Lambda(lambda x: x / 255.0 - 0.5)( inputs) # Normalizes and centers images # First convolutional layer runs filters of conv_shapes sizes on the preprocessed inputs # The outputs are then concatenated into a single layer for shp in conv_shapes: stacks.append( Conv2D(depths[0], (shp, shp), padding='same', activation='elu')(zen_layer)) layer = concatenate(stacks, axis=3) maxPool = MaxPooling2D((2, 2), strides=(2, 2), padding='valid')(layer) # The following convolutional layers each share the stacking-parallel shape for i in range(1, len(depths)): stacks = [] for shp in conv_shapes: stacks.append( Conv2D(depths[i], (shp, shp), padding='same', activation='elu')(maxPool)) layer = concatenate(stacks, axis=3) maxPool = MaxPooling2D((2, 2), strides=(2, 2), padding='valid')(layer) flat_layer = Flatten()(maxPool) flat_layer = Dropout(.5)(flat_layer) # Dropout reduces overfitting