features = features.reshape(features.shape[0], 224, 224, 3) features.shape features /= 255 #normalize in [0, 1] train_x, test_x, train_y, test_y = train_test_split( features, target_classes, test_size=0.30) #, random_state=42), stratify=target_classes) #VGG-Face model model = Sequential() model.add(ZeroPadding2D((1, 1), input_shape=(224, 224, 3))) model.add(Convolution2D(64, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(128, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(256, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(256, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(256, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2)))
inp = Input(X_train.shape[1:]) num_ens = 2 outs = [] for i in range(0, num_ens): conv1 = Conv2D(32, (3, 3), kernel_initializer='he_uniform', activation='relu')(inp) conv1 = BatchNormalization()(conv1) conv1 = Dropout(0.3)(conv1) conv3 = Conv2D(32, (3, 3), kernel_initializer='he_uniform', activation='relu')(conv1) conv3 = BatchNormalization()(conv3) conv3 = MaxPooling2D()(conv3) conv3 = Dropout(0.3)(conv3) conv4 = Conv2D(64, (3, 3), kernel_initializer='he_uniform', activation='relu')(conv3) conv4 = BatchNormalization()(conv4) conv4 = MaxPooling2D()(conv4) conv4 = Dropout(0.3)(conv4) conv5 = Conv2D(64, (3, 3), kernel_initializer='he_uniform', activation='relu')(conv4) conv5 = BatchNormalization()(conv5) conv5 = MaxPooling2D()(conv5) conv5 = Dropout(0.3)(conv5)
def RESNET50(include_top=True, weights='vggface', input_tensor=None, input_shape=None, pooling=None, classes=8631): input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=K.image_data_format(), require_flatten=include_top, weights=weights) 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_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 x = Conv2D( 64, (7, 7), use_bias=False, strides=(2, 2), padding='same', name='conv1/7x7_s2')(img_input) x = BatchNormalization(axis=bn_axis, name='conv1/7x7_s2/bn')(x) x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2))(x) x = resnet_conv_block(x, 3, [64, 64, 256], stage=2, block=1, strides=(1, 1)) x = resnet_identity_block(x, 3, [64, 64, 256], stage=2, block=2) x = resnet_identity_block(x, 3, [64, 64, 256], stage=2, block=3) x = resnet_conv_block(x, 3, [128, 128, 512], stage=3, block=1) x = resnet_identity_block(x, 3, [128, 128, 512], stage=3, block=2) x = resnet_identity_block(x, 3, [128, 128, 512], stage=3, block=3) x = resnet_identity_block(x, 3, [128, 128, 512], stage=3, block=4) x = resnet_conv_block(x, 3, [256, 256, 1024], stage=4, block=1) x = resnet_identity_block(x, 3, [256, 256, 1024], stage=4, block=2) x = resnet_identity_block(x, 3, [256, 256, 1024], stage=4, block=3) x = resnet_identity_block(x, 3, [256, 256, 1024], stage=4, block=4) x = resnet_identity_block(x, 3, [256, 256, 1024], stage=4, block=5) x = resnet_identity_block(x, 3, [256, 256, 1024], stage=4, block=6) x = resnet_conv_block(x, 3, [512, 512, 2048], stage=5, block=1) x = resnet_identity_block(x, 3, [512, 512, 2048], stage=5, block=2) x = resnet_identity_block(x, 3, [512, 512, 2048], stage=5, block=3) x = AveragePooling2D((7, 7), name='avg_pool')(x) if include_top: x = Flatten()(x) x = Dense(classes, activation='softmax', name='classifier')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='vggface_resnet50') # load weights if weights == 'vggface': if include_top: weights_path = get_file('rcmalli_vggface_tf_resnet50.h5', utils.RESNET50_WEIGHTS_PATH, cache_subdir=utils.VGGFACE_DIR) else: weights_path = get_file('rcmalli_vggface_tf_notop_resnet50.h5', utils.RESNET50_WEIGHTS_PATH_NO_TOP, cache_subdir=utils.VGGFACE_DIR) model.load_weights(weights_path) if K.backend() == 'theano': layer_utils.convert_all_kernels_in_model(model) if include_top: maxpool = model.get_layer(name='avg_pool') shape = maxpool.output_shape[1:] dense = model.get_layer(name='classifier') layer_utils.convert_dense_weights_data_format(dense, shape, 'channels_first') if K.image_data_format() == 'channels_first' and K.backend() == 'tensorflow': warnings.warn('You are using the TensorFlow backend, yet you ' 'are using the Theano ' 'image data format convention ' '(`image_data_format="channels_first"`). ' 'For best performance, set ' '`image_data_format="channels_last"` in ' 'your Keras config ' 'at ~/.keras/keras.json.') elif weights is not None: model.load_weights(weights) return model
from keras.layers import Conv2D, MaxPooling2D from keras.models import Sequential from keras.layers import Flatten, Dense from keras.datasets import mnist from keras.utils import to_categorical model = Sequential() model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1))) model.add(MaxPooling2D((2, 2))) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2))) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(Flatten()) model.add(Dense(64, activation='relu')) model.add(Dense(10, activation='softmax')) (train_images, train_labels), (test_images, test_labels) = mnist.load_data() train_images = train_images.reshape((60000, 28, 28, 1)) train_images = train_images.astype('float32') / 255 test_images = test_images.reshape((10000, 28, 28, 1)) test_images = test_images.astype('float32') / 255 train_labels = to_categorical(train_labels) test_labels = to_categorical(test_labels) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(train_images, train_labels, epochs=5, batch_size=64)
# load model (x_train, y_train), (x_test, y_test) = cifar10.load_data() model = Sequential() weight_decay = 0.0005 model.add(Conv2D(64, (3, 3), padding='same', input_shape=x_train.shape[1:],kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add(Conv2D(64, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization())
def get_model(height, nclass): input = Input(shape=(height, None, 1), name='the_input') m = Conv2D(64, kernel_size=(3, 3), activation='relu', padding='same', name='conv1')(input) m = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='pool1')(m) m = Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same', name='conv2')(m) m = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='pool2')(m) m = Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same', name='conv3')(m) m = Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same', name='conv4')(m) m = ZeroPadding2D(padding=(0, 1))(m) m = MaxPooling2D(pool_size=(2, 2), strides=(2, 1), padding='valid', name='pool3')(m) m = Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', name='conv5')(m) m = BatchNormalization(axis=1)(m) m = Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', name='conv6')(m) m = BatchNormalization(axis=1)(m) m = ZeroPadding2D(padding=(0, 1))(m) m = MaxPooling2D(pool_size=(2, 2), strides=(2, 1), padding='valid', name='pool4')(m) m = Conv2D(512, kernel_size=(2, 2), activation='relu', padding='valid', name='conv7')(m) m = Permute((2, 1, 3), name='permute')(m) m = TimeDistributed(Flatten(), name='timedistrib')(m) m = Bidirectional(GRU(rnnunit, return_sequences=True), name='blstm1')(m) m = Dense(rnnunit, name='blstm1_out', activation='linear')(m) m = Bidirectional(GRU(rnnunit, return_sequences=True), name='blstm2')(m) y_pred = Dense(nclass, name='blstm2_out', activation='softmax')(m) basemodel = Model(inputs=input, outputs=y_pred) labels = Input(name='the_labels', shape=[ None, ], dtype='float32') input_length = Input(name='input_length', shape=[1], dtype='int64') label_length = Input(name='label_length', shape=[1], dtype='int64') loss_out = Lambda(ctc_lambda_func, output_shape=(1, ), name='ctc')([y_pred, labels, input_length, label_length]) model = Model(inputs=[input, labels, input_length, label_length], outputs=[loss_out]) sgd = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5) #model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer='adadelta') model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd) model.summary() return model, basemodel
def training(model_num, HY, num_epochs): #keras.backend.clear_session() #print(HY) #time.sleep(2) # reshape training data into 2d X_train_c = X_train.reshape(len(X_train), 28, 28, 1) X_test_c = X_test.reshape(len(X_test), 28, 28, 1) model = Sequential() no_conv_layers = True no_dense_layers = True # ADD CONVOLUTION LAYERS for i,c_params in enumerate(HY["conv_layers"]): no_conv_layers = False num_filters, kernel_size, pooling_size = c_params # if it's the first layer, need to specify input shape if i==0: model.add(Conv2D(num_filters, kernel_size, kernel_regularizer=keras.regularizers.l2(HY["k_reg"]), input_shape=(28,28,1))) else: model.add(Conv2D(num_filters, kernel_size, kernel_regularizer=keras.regularizers.l2(HY["k_reg"]))) # add activation, pooling, dropout model.add(Activation(HY["activation"])) if pooling_size: model.add(MaxPooling2D(pool_size=pooling_size)) if HY["dropout"]: model.add(Dropout(HY["dropout"])) if not no_conv_layers: model.add(Flatten()) for i,dense_nodes in enumerate(HY["dense_layers"]): no_dense_layers = False if no_conv_layers and i==0: model.add(Dense(dense_nodes, kernel_regularizer=keras.regularizers.l2(HY["k_reg"]), input_dim=784)) else: model.add(Dense(dense_nodes, kernel_regularizer=keras.regularizers.l2(HY["k_reg"]))) # add activation and dropout model.add(Activation(HY["activation"])) if HY["dropout"]: model.add(Dropout(HY["dropout"])) # once all the hidden nodes are added, add the output layer with a softmax activation if no_conv_layers and no_dense_layers: model.add(Dense(10, input_dim=784)) else: model.add(Dense(10)) model.add(Activation('softmax')) model.compile(optimizer=keras.optimizers.SGD(lr=HY["learning_rate"], clipnorm=HY["grad_clip_norm"]), loss='categorical_crossentropy', metrics=['accuracy']) def report_ep_loss(ep,logs): leader.update(ep, model_num, float(logs['val_loss'])) if no_conv_layers: model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=num_epochs, verbose=1, callbacks=[keras.callbacks.LambdaCallback(on_epoch_end=report_ep_loss)]) else: model.fit(X_train_c, y_train, validation_data=(X_test_c, y_test), epochs=num_epochs, verbose=1, callbacks=[keras.callbacks.LambdaCallback(on_epoch_end=report_ep_loss)]) leader.model_finished(model_num) keras.backend.clear_session()
def build_model_GSLRE(classSize, x=4): model = keras.Sequential() model.add( Conv2D(filters=96, kernel_size=(3, 3), padding='same', name='conv1', input_shape=(96, 96, 1))) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) D = channelD(96, 128, 48, 48, 3, x) model.add( Conv2D(filters=D, kernel_size=(3, 1), padding='same', name='conv2_de1')) model.add( Conv2D(filters=128, kernel_size=(1, 3), padding='same', name='conv2_de2')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) D = channelD(128, 160, 24, 24, 3, x) model.add( Conv2D(filters=D, kernel_size=(3, 1), padding='same', name='conv3_de1')) model.add( Conv2D(filters=160, kernel_size=(1, 3), padding='same', name='conv3_de2')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) D = channelD(160, 256, 12, 12, 3, x) model.add( Conv2D(filters=D, kernel_size=(3, 1), padding='same', name='conv4_1_de1')) model.add( Conv2D(filters=256, kernel_size=(1, 3), padding='same', name='conv4_1_de2')) model.add(BatchNormalization()) model.add(PReLU()) D = channelD(256, 256, 12, 12, 3, x) model.add( Conv2D(filters=D, kernel_size=(3, 1), padding='same', name='conv4_2_de1')) model.add( Conv2D(filters=256, kernel_size=(1, 3), padding='same', name='conv4_2_de2')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) D = channelD(256, 384, 6, 6, 3, x) model.add( Conv2D(filters=D, kernel_size=(3, 1), padding='same', name='conv5_1_de1')) model.add( Conv2D(filters=384, kernel_size=(1, 3), padding='same', name='conv5_1_de2')) model.add(BatchNormalization()) model.add(PReLU()) D = channelD(384, 384, 6, 6, 3, x) model.add( Conv2D(filters=D, kernel_size=(3, 1), padding='same', name='conv5_2_de1')) model.add( Conv2D(filters=384, kernel_size=(1, 3), padding='same', name='conv5_2_de2')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) model.add(Flatten()) model.add(Dense(1024, name='fc1')) model.add(BatchNormalization()) model.add(PReLU()) model.add(Dropout(0.5)) model.add(Dense(classSize, activation='softmax', name='fc2')) return model
*LSTM - Recurrent Layer *GRU - Recurrent Integration version Layer *MaxPooling2D - Max pooling to a convolutional neural network in code *Flatten - used to reshape the tensor to such a shape which is equal to the number of elements present in the tensor """ # Training model from one input (CT scan picture) model_CT_lungs = Sequential() model_CT_lungs.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(224, 224, 3))) model_CT_lungs.add(Conv2D(128, (3, 3), activation='relu')) model_CT_lungs.add(MaxPooling2D(pool_size=(2, 2))) model_CT_lungs.add(Dropout(0.25)) model_CT_lungs.add(Conv2D(64, (3, 3), activation='relu')) model_CT_lungs.add(MaxPooling2D(pool_size=(2, 2))) model_CT_lungs.add(Dropout(0.25)) model_CT_lungs.add(Conv2D(128, (3, 3), activation='relu')) model_CT_lungs.add(MaxPooling2D(pool_size=(2, 2))) model_CT_lungs.add(Dropout(0.25)) model_CT_lungs.add(Flatten()) model_CT_lungs.add(Dense(64, activation='relu')) model_CT_lungs.add(Dropout(0.5)) model_CT_lungs.add(Dense(1, activation='sigmoid')) """
strides=(1, 1), padding='valid', data_format='channels_first', kernel_regularizer=keras.regularizers.l2(reg3))(x3) x3 = BatchNormalization(axis=1)(x3) x3 = Activation('relu')(x3) x3 = Conv2D(filters=128, kernel_size=3, strides=(1, 1), padding='valid', data_format='channels_first', kernel_regularizer=keras.regularizers.l2(reg3))(x3) x3 = BatchNormalization(axis=1)(x3) x3 = Activation('relu')(x3) x3 = MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format='channels_first')(x3) x3 = Flatten()(x3) x3 = Dropout(rate=.5, seed=seed)(x3) reg5 = reg3 x5 = Conv2D(filters=6, kernel_size=5, strides=(1, 1), padding='valid', data_format='channels_first', kernel_regularizer=keras.regularizers.l2(reg5))(main_in) x5 = BatchNormalization(axis=1)(x5) x5 = Activation('relu')(x5) x5 = Conv2D(filters=128, kernel_size=5,
def build_model(classSize, x=4): model = keras.Sequential() model.add( Conv2D(filters=96, kernel_size=(3, 3), padding='same', name='conv1', input_shape=(96, 96, 1))) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) model.add( Conv2D(filters=128, kernel_size=(3, 3), padding='same', name='conv2')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) model.add( Conv2D(filters=160, kernel_size=(3, 3), padding='same', name='conv3')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) model.add( Conv2D(filters=256, kernel_size=(3, 3), padding='same', name='conv4_1')) model.add(BatchNormalization()) model.add(PReLU()) model.add( Conv2D(filters=256, kernel_size=(3, 3), padding='same', name='conv4_2')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) model.add( Conv2D(filters=384, kernel_size=(3, 3), padding='same', name='conv5_1')) model.add(BatchNormalization()) model.add(PReLU()) model.add( Conv2D(filters=384, kernel_size=(3, 3), padding='same', name='conv5_2')) model.add(BatchNormalization()) model.add(PReLU()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) model.add(Flatten()) model.add(Dense(1024, name='fc1')) model.add(BatchNormalization()) model.add(PReLU()) model.add(Dropout(0.5)) model.add(Dense(classSize, activation='softmax', name='fc2')) return model
train_data, test_data = train_data/255, test_data/255 train_label = keras.utils.to_categorical(train_label, 2) test_label = keras.utils.to_categorical(test_label, 2) # AlexNet model = Sequential() #第一段 model.add(Conv2D(filters=96, kernel_size=(11,11), strides=(4,4), padding='valid', input_shape=(resize,resize,3), activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(3,3), strides=(2,2), padding='valid')) #第二段 model.add(Conv2D(filters=256, kernel_size=(5,5), strides=(1,1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(3,3), strides=(2,2), padding='valid')) #第三段 model.add(Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu')) model.add(Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), padding='same',
def build_model(SHAPE, nb_classes, bn_axis, seed=None): # We can't use ResNet50 directly, as it might cause a negative dimension # error. if seed: np.random.seed(seed) input_layer = Input(shape=SHAPE) # block 1 x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(input_layer) 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) x = Flatten(name='flatten')(x) x = Dense(4096, activation='relu', name='fc1')(x) x = Dense(4096, activation='relu', name='fc2')(x) x = Dense(nb_classes, activation='softmax', name='predictions')(x) model = Model(input_layer, x) return model
rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True) datagen.fit(x_train) validgen.fit(x_test) #Define the NN architecture from keras.models import Sequential from keras.layers import Dense, Activation, Conv2D, MaxPooling2D, Flatten #Two hidden layers nn = Sequential() nn.add(Conv2D(32, 3, 3, activation='relu', input_shape=input_shape)) nn.add(Conv2D(32, 3, 3, activation='relu')) nn.add(MaxPooling2D(pool_size=(2, 2))) nn.add(Conv2D(64, 3, 3, activation='relu')) nn.add(Conv2D(64, 3, 3, activation='relu')) nn.add(MaxPooling2D(pool_size=(2, 2))) nn.add(Conv2D(128, 3, 3, activation='relu')) nn.add(Flatten()) nn.add(Dense(256, activation='relu')) nn.add(Dense(10, activation='softmax')) #Model visualization #We can plot the model by using the ```plot_model``` function. We need to install *pydot, graphviz and pydot-ng*. #from keras.util import plot_model #plot_model(nn, to_file='nn.png', show_shapes=true) #Compile the NN nn.compile(optimizer='sgd',loss='categorical_crossentropy',metrics=['accuracy'])
def ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000): """Instantiates the ResNet50 architecture. Optionally loads weights pre-trained on ImageNet. Note that when using TensorFlow, for best performance you should set `image_data_format="channels_last"` in your Keras config at ~/.keras/keras.json. The model and the weights are compatible with both TensorFlow and Theano. The data format convention used by the model is the one specified in your Keras config file. # Arguments include_top: whether to include the fully-connected layer at the top of the network. weights: one of `None` (random initialization) or "imagenet" (pre-training on ImageNet). input_tensor: optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. input_shape: optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 244)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 197. E.g. `(200, 200, 3)` would be one valid value. pooling: Optional pooling mode for feature extraction when `include_top` is `False`. - `None` means that the output of the model will be the 4D tensor output of the last convolutional layer. - `avg` means that global average pooling will be applied to the output of the last convolutional layer, and thus the output of the model will be a 2D tensor. - `max` means that global max pooling will be applied. classes: optional number of classes to classify images into, only to be specified if `include_top` is True, and if no `weights` argument is specified. # Returns A Keras model instance. # Raises ValueError: in case of invalid argument for `weights`, or invalid input shape. """ if weights not in {'imagenet', None}: raise ValueError('The `weights` argument should be either ' '`None` (random initialization) or `imagenet` ' '(pre-training on ImageNet).') if weights == 'imagenet' and include_top and classes != 1000: raise ValueError('If using `weights` as imagenet with `include_top`' ' as true, `classes` should be 1000') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=197, data_format=K.image_data_format(), require_flatten=include_top) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if K.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 x = ZeroPadding2D((3, 3))(img_input) x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x) x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x) x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1)) x = identity_block(x, 3, [64, 64, 256], stage=2, block='b') x = identity_block(x, 3, [64, 64, 256], stage=2, block='c') x = conv_block(x, 3, [128, 128, 512], stage=3, block='a') x = identity_block(x, 3, [128, 128, 512], stage=3, block='b') x = identity_block(x, 3, [128, 128, 512], stage=3, block='c') x = identity_block(x, 3, [128, 128, 512], stage=3, block='d') x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f') x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c') x = AveragePooling2D((7, 7), name='avg_pool')(x) if include_top: x = Flatten()(x) x = Dense(classes, activation='softmax', name='fc1000')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='resnet50') # load weights if weights == 'imagenet': PATH = os.getcwd() if include_top: weights_path = os.path.join(PATH, 'resnet50_weights_tf_dim_ordering_tf_kernels.h5') ''' get_file('resnet50_weights_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH, cache_subdir='models', md5_hash='a7b3fe01876f51b976af0dea6bc144eb') ''' else: weights_path = os.path.join(PATH, 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5') ''' get_file('resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5', WEIGHTS_PATH_NO_TOP, cache_subdir='models', md5_hash='a268eb855778b3df3c7506639542a6af') ''' model.load_weights(weights_path) if K.backend() == 'theano': layer_utils.convert_all_kernels_in_model(model) if K.image_data_format() == 'channels_first': if include_top: maxpool = model.get_layer(name='avg_pool') shape = maxpool.output_shape[1:] dense = model.get_layer(name='fc1000') layer_utils.convert_dense_weights_data_format(dense, shape, 'channels_first') if K.backend() == 'tensorflow': warnings.warn('You are using the TensorFlow backend, yet you ' 'are using the Theano ' 'image data format convention ' '(`image_data_format="channels_first"`). ' 'For best performance, set ' '`image_data_format="channels_last"` in ' 'your Keras config ' 'at ~/.keras/keras.json.') return model
print('X_train shape:', X_train.shape) print(X_train.shape[0], 'train samples') print('X_train shape:', X_crop_train.shape) print(X_crop_train.shape[0], 'train samples') nb_filters = 32 kernel_size = (3, 3) pool_size = (2, 2) input_img = Input(shape=(img_rows, img_cols, 1)) encoded = Convolution2D(nb_filters, kernel_size[0], kernel_size[1], border_mode="same", activation='relu')(input_img) encoded = MaxPooling2D(pool_size=(2, 2))(encoded) encoded = Flatten()(encoded) encoded = Dense(1024, activation='sigmoid')(encoded) autoencoder = Model(input_img, encoded) autoencoder.compile(optimizer='adadelta', loss='poisson') # at this point the representation is (32*32, 1) # autoencoder.load_weights("cnn_autoencoder_weights.h5") if __name__ == "__main__": autoencoder.fit(X_train, X_crop_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, callbacks=[TensorBoard(log_dir='/tmp/autoencoder')])
def model(train_gen, test_gen): ''' Model providing function: Create Keras model with double curly brackets dropped-in as needed. Return value has to be a valid python dictionary with two customary keys: - loss: Specify a numeric evaluation metric to be minimized - status: Just use STATUS_OK and see hyperopt documentation if not feasible The last one is optional, though recommended, namely: - model: specify the model just created so that we can later use it again. ''' #numpy.random.seed(8994) nb_classes = 11 sequence_length = 5 img_rows, img_cols, img_depth = 64, 64, 3 input_shape = (img_rows, img_cols, img_depth) nb_epoch = 12 nb_filters = {{choice([32, 64, 128])}} pool_size = (2, 2) kernel_size = (3, 3) cls_weights = [1., 1., 1., 1., 1., 1., 2*{{uniform(0, 1)}}] #optimizer = {{choice(['rmsprop', 'adam', 'sgd', 'adadelta'])}} # TODO: leads to inf loss optimizer = 'adadelta' main_input = Input(shape=input_shape, dtype='float32', name='main_input') shared = Convolution2D(nb_filters, kernel_size[0], kernel_size[1], border_mode='valid', input_shape=input_shape)(main_input) shared = Activation('relu')(shared) shared = Convolution2D(nb_filters, kernel_size[0], kernel_size[1])(shared) shared = Activation('relu')(shared) shared = MaxPooling2D(pool_size=pool_size)(shared) # Conditional extra convolutional layer if conditional({{choice(['two', 'three'])}}) == 'three': shared = Convolution2D(nb_filters, kernel_size[0], kernel_size[1], border_mode='valid', input_shape=input_shape)(main_input) shared = Activation('relu')(shared) shared = MaxPooling2D(pool_size=pool_size)(shared) dropout_coef = {{uniform(0, 1)}} shared = Dropout(dropout_coef)(shared) shared = Flatten()(shared) shared = Dense(128)(shared) shared = Activation('relu')(shared) shared = Dropout(dropout_coef)(shared) length_cls = Dense((sequence_length + 1))(shared) # to account for sequence length + 1 length_cls = Activation('softmax', name="length_cls")(length_cls) # 2. First digit classifier first_cls = Dense(nb_classes)(shared) first_cls = Activation('softmax', name="first_cls")(first_cls) # 3. Second digit classifier second_cls = Dense(nb_classes)(shared) second_cls = Activation('softmax', name="second_cls")(second_cls) # 4. Third digit classifier third_cls = Dense(nb_classes)(shared) third_cls = Activation('softmax', name="third_cls")(third_cls) # 5. Forth digit classifier forth_cls = Dense(nb_classes)(shared) forth_cls = Activation('softmax', name="forth_cls")(forth_cls) # 6. Fifth digit classifier fifth_cls = Dense(nb_classes)(shared) fifth_cls = Activation('softmax', name="fifth_cls")(fifth_cls) #7. Digit boxes coordinates regresssion coord_regr = Dense(20, name="coord_regr")(shared) # model compilation and training model = Model(input=[main_input], output=[length_cls, first_cls, second_cls, third_cls, forth_cls, fifth_cls, coord_regr]) model.compile(loss={'length_cls': 'categorical_crossentropy', 'first_cls': 'categorical_crossentropy', 'second_cls': 'categorical_crossentropy', 'third_cls': 'categorical_crossentropy', 'forth_cls': 'categorical_crossentropy', 'fifth_cls': 'categorical_crossentropy', 'coord_regr': 'mean_squared_error'}, optimizer=optimizer, metrics={'length_cls': 'accuracy', 'first_cls': 'accuracy', 'second_cls': 'accuracy', 'third_cls': 'accuracy', 'forth_cls': 'accuracy', 'fifth_cls': 'accuracy', 'coord_regr': iou_metric_func}, loss_weights=cls_weights) directory = "output/" + str(datetime.datetime.now()) if not os.path.exists(directory): os.makedirs(directory) checkpointer = ModelCheckpoint(filepath=directory + "/weights.hdf5", verbose=1, save_best_only=True) tensorboard = TensorBoard(log_dir=directory, histogram_freq=0, write_graph=True, write_images=False) # Todo: P2 add EarlyStopping callback # Todo: P3 add LearningRateSchedule callback # TODO: P2 batch size are not randomized model.fit_generator(train_gen, samples_per_epoch=33401, nb_epoch=nb_epoch, verbose=1, validation_data=test_gen, nb_val_samples=13068, callbacks=[checkpointer, tensorboard]) score = model.evaluate_generator(test_gen, val_samples=13068) print('Test accuracy:', score) return {'loss': score[0], 'status': STATUS_OK, 'model': model}
from keras.layers import Conv2D, Input, MaxPooling2D, Flatten x = Input(shape=(256, 256, 3)) y = Conv2D(3, (3, 3), padding='same')(x) import keras z = keras.layers.add([x, y]) # 视觉问答model main_input = Input( None, None, ) model = Conv2D(64, (3, 3), activation='relu', padding='same')(main_input) model = Conv2D(64, (3, 3), activation='relu')(model) model = MaxPooling2D((2, 2))(model) model = Conv2D(256, (3, 3), activation='relu', padding='same')(model) model = Conv2D(256, (3, 3), activation='relu')(model) model = MaxPooling2D((2, 2))(model) model = Flatten(model) input_img = None encode_img = model(input_img) ques_input = None input_ques = None encode_ques = model(input_ques)
y_test = keras.utils.to_categorical(y_test, num_classes) #Below is where we define model architecture! model = Sequential( ) # The layers are stacked sequentially. Ask me about the functional API if you want! model.add( Conv2D( 32, kernel_size=( 3, 3), # We'll have 32 3x3 filters with RANDOM weights to start activation= 'relu', # This is our non-linear activation function so we can take advantage of multiple layers input_shape=input_shape) ) # Keras handles this automatically for other layers model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=( 2, 2))) # A non-linear filter that takes the max of each 2x2 block. model.add( Dropout(0.25) ) # Helps prevent overfitting by randomly excluding 25% of neurons during an epoch model.add(Flatten()) # a 3x3 matrix will beoome a 1x9 vector. model.add( Dense(128, activation='relu') ) # Now we look for all possible combinations of features and how they fit together model.add(Dropout(0.5)) model.add( Dense(num_classes, activation='softmax') ) # We have one last dense connected layer with each of our outputs! Softmax acts as a probability. #We compile the model now so we can train it. model.compile( loss=keras.losses.
show_image(train_images[1]) import keras from keras.models import Sequential from keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout model = Sequential() model = Sequential([ Conv2D(filters = 8, kernel_size=(3, 3), activation='relu',padding='same',input_shape=(28, 28, 1)), Dropout(0.5), Conv2D(filters = 8, kernel_size=(3, 3), activation='relu'), Dropout(0.5), MaxPooling2D(pool_size=(2, 2),strides=4), Flatten(), Dense(256, activation='relu'), Dropout(0.05), Dense(128, activation='relu'), Dense(64, activation='relu'), Dropout(0.05), Dense(32, activation='relu'), Dense(10, activation='softmax') ]) #literally compiles the model, u have to run after any changes in the model
def fcn_8(input_shape=(para.img_cols, para.img_rows, para.channels), classes=para.num_classes, input_tensor=None): #img_input = Input(shape=input_shape) input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=56, data_format=K.image_data_format(), include_top=False) 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 #print(img_input.shape) x = img_input # Encoder x = Conv2D(64, (3, 3), padding="same", name="block1_conv0")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(64, (3, 3), padding="same", name="block1_conv1")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = MaxPooling2D(pool_size=(2, 2))(x) y1 = x x = Conv2D(128, (3, 3), padding="same", name="block2_conv0")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(128, (3, 3), padding="same", name="block2_conv1")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = MaxPooling2D(pool_size=(2, 2))(x) y2 = x x = Conv2D(256, (3, 3), padding="same", name="block3_conv0")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(256, (3, 3), padding="same", name="block3_conv1")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(256, (3, 3), padding="same", name="block3_conv2")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = MaxPooling2D(pool_size=(2, 2))(x) y3 = x x = Conv2D(512, (3, 3), padding="same", name="block4_conv0")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(512, (3, 3), padding="same", name="block4_conv1")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(512, (3, 3), padding="same", name="block4_conv2")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = MaxPooling2D(pool_size=(2, 2))(x) y4 = x x = Conv2D(512, (3, 3), padding="same", name="block5_conv0")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(512, (3, 3), padding="same", name="block5_conv1")(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(512, (3, 3), padding="same", name="block5_conv2")(x) x = BatchNormalization()(x) x = Activation("relu")(x) y5 = x # ============= # The Decoder # ============= # Block 6 o = y5 o = (Conv2D(classes, (1, 1), padding='same', name='block6_conv1'))(o) # Block 7 o2 = y4 o2 = (Conv2D(classes, (1, 1), padding='same', name='block7_conv1'))(o2) o, o2 = crop(o, o2, img_input) o = Add()([o, o2]) o = UpSampling2D(size=(2, 2))(o) # Block 8 o2 = y3 o2 = (Conv2D(classes, (1, 1), padding='same', name='block8_conv1'))(o2) o2, o = crop(o2, o, img_input) o = Add()([o2, o]) o = UpSampling2D(size=(2, 2))(o) # Block 9 o2 = y2 o2 = (Conv2D(classes, (1, 1), padding='same', name='block9_conv1'))(o2) o2, o = crop(o2, o, img_input) o = Add()([o2, o]) o = UpSampling2D(size=(2, 2))(o) # Block 10 o2 = y1 o2 = (Conv2D(classes, (1, 1), padding='same', name='block10_conv1'))(o2) o2, o = crop(o2, o, img_input) o = Add()([o2, o]) o = UpSampling2D(size=(2, 2))(o) model = Model(img_input, o) cols = model.output_shape[1] rows = model.output_shape[2] o = Conv2D(classes, (1, 1), padding="valid")(o) o = Reshape((cols * rows, classes))(o) # ***************** o = Activation("softmax")(o) if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input model = Model(inputs, o) return model, rows, cols
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
if __name__ == "__main__": # Convolutional Neural Network # Part 1 - Data Pre-processing # for our dogs/cats dataset, this work has already manually been done. # Part 2 - Building the CNN # Initialize our CNN classifier = Sequential() # Step 1 - Convolution classifier.add(Convolution2D(32, 3, 3, input_shape = (64, 64, 3), activation = 'relu')) # Step 2 - Max Pooling classifier.add(MaxPooling2D(pool_size = (2, 2))) # Add second convolutional layer to improve accuracy classifier.add(Convolution2D(32, 3, 3, activation = 'relu')) classifier.add(MaxPooling2D(pool_size = (2, 2))) # Step 3 - Flattening classifier.add(Flatten()) # Step 4 - Full connection classifier.add(Dense(units = 128, activation = 'relu')) classifier.add(Dense(units = 1, activation = 'sigmoid')) # Step 5 - Compiling the CNN classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
np.set_printoptions(threshold=np.inf) #Print complete arrays batch_size = 64 epochs = 50 learning_rate = 0.0001 first_layer_filters = 32 second_layer_filters = 64 ks = 2 mp = 2 dense_layer_size = 128 #model model = Sequential() model.add(Conv2D(first_layer_filters, kernel_size=(ks, ks), activation='relu', input_shape= (7, 7, 1))) model.add(MaxPooling2D(pool_size=(mp, mp))) model.add(Conv2D(second_layer_filters, (ks, ks), activation='relu')) model.add(MaxPooling2D(pool_size=(mp, mp))) model.add(Flatten()) model.add(Dense(dense_layer_size, activation='relu')) model.add(Dense(2, activation='softmax')) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(lr=learning_rate), metrics=['accuracy']) #Train network history = model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(X_test, y_test),
def Conv_Block(inpt,nb_filter,kernel_size,strides=(1,1), with_conv_shortcut=False): x = Conv2d_BN(inpt,nb_filter=nb_filter,kernel_size=kernel_size,strides=strides,padding='same') x = Conv2d_BN(x, nb_filter=nb_filter, kernel_size=kernel_size,padding='same') if with_conv_shortcut: shortcut = Conv2d_BN(inpt,nb_filter=nb_filter,strides=strides,kernel_size=kernel_size) x = add([x,shortcut]) return x else: x = add([x,inpt]) return x inpt = Input(shape=(height,width,num_channels)) x = ZeroPadding2D((0,0))(inpt) x = Conv2d_BN(x,nb_filter=32,kernel_size=(7,7),strides=(1,1),padding='same') x = BatchNormalization()(x) x = MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same')(x) # #(56,56,64) x = Conv_Block(x,nb_filter=32,kernel_size=(5,5),strides=(1,1),with_conv_shortcut=False) # x = Conv_Block(x,nb_filter=64,kernel_size=(5,5),strides=(2,2),with_conv_shortcut=True) # x = Conv_Block(x,nb_filter=64,kernel_size=(5,5),strides=(2,2),with_conv_shortcut=True) x = MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same')(x) # x = Conv2d_BN(x,nb_filter=64,kernel_size=(5,5),strides=(1,1),padding='same') x = Conv_Block(x,nb_filter=64,kernel_size=(3,3),strides=(1,1),with_conv_shortcut=True) x = MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same')(x) # x = Conv_Block(x,nb_filter=64,kernel_size=(3,3),strides=(1,1),with_conv_shortcut=False) # x = MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same')(x) x = Conv_Block(x,nb_filter=64,kernel_size=(3,3),strides=(1,1),with_conv_shortcut=False) x = MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same')(x) x = Conv_Block(x,nb_filter=128,kernel_size=(3,3),strides=(1,1),with_conv_shortcut=True) x = MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same')(x)
def _main(args): config_path = os.path.expanduser(args.config_path) weights_path = os.path.expanduser(args.weights_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') weights_header = np.ndarray( shape=(5, ), dtype='int32', buffer=weights_file.read(20)) print('Weights Header: ', weights_header) # TODO: Check transpose flag when implementing fully connected layers. # transpose = (weight_header[0] > 1000) or (weight_header[1] > 1000) 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.') if args.fully_convolutional: image_height, image_width = None, None else: image_height = int(cfg_parser['net_0']['height']) image_width = int(cfg_parser['net_0']['width']) prev_layer = Input(shape=(image_height, image_width, 3)) all_layers = [prev_layer] outputs = [] weight_decay = float(cfg_parser['net_0']['decay'] ) if 'net_0' in cfg_parser.sections() else 5e-4 count = 0 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] # Setting weights. # Darknet serializes convolutional weights as: # [bias/beta, [gamma, mean, variance], conv_weights] prev_layer_shape = K.int_shape(prev_layer) # TODO: This assumes channel last dim_ordering. 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 # TODO: Keras BatchNormalization mistakenly refers to var # as std. 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) # TODO: Add check for Theano dim ordering. 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)) padding = 'same' if pad == 1 and stride == 1 else 'valid' # Adjust padding model for darknet. if stride == 2: prev_layer = ZeroPadding2D(((1, 0), (1, 0)))(prev_layer) # Create Conv2D 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(prev_layer) elif section.startswith('maxpool'): size = int(cfg_parser[section]['size']) stride = int(cfg_parser[section]['stride']) all_layers.append( MaxPooling2D( padding='same', pool_size=(size, size), strides=(stride, stride))(prev_layer)) prev_layer = all_layers[-1] elif section.startswith('avgpool'): if cfg_parser.items(section) != []: raise ValueError('{} with params unsupported.'.format(section)) all_layers.append(GlobalAveragePooling2D()(prev_layer)) prev_layer = all_layers[-1] elif section.startswith('route'): ids = [int(i) for i in cfg_parser[section]['layers'].split(',')] if len(ids) == 2: for i, item in enumerate(ids): if item != -1: ids[i] = item + 1 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('shortcut'): ids = [int(i) for i in cfg_parser[section]['from'].split(',')][0] activation = cfg_parser[section]['activation'] shortcut = add([all_layers[ids], prev_layer]) if activation == 'linear': shortcut = Activation('linear')(shortcut) all_layers.append(shortcut) prev_layer = all_layers[-1] elif section.startswith('upsample'): stride = int(cfg_parser[section]['stride']) all_layers.append( UpSampling2D( size=(stride, stride))(prev_layer)) prev_layer = all_layers[-1] elif section.startswith('yolo'): classes = int(cfg_parser[section]['classes']) # num = int(cfg_parser[section]['num']) # mask = int(cfg_parser[section]['mask']) n1, n2 = int(prev_layer.shape[1]), int(prev_layer.shape[2]) n3 = 3 n4 = (4 + 1 + classes) yolo = Reshape((n1, n2, n3, n4))(prev_layer) all_layers.append(yolo) prev_layer = all_layers[-1] outputs.append(len(all_layers) - 1) elif (section.startswith('net')): pass # Configs not currently handled during model definition. else: raise ValueError( 'Unsupported section header type: {}'.format(section)) # Create and save model. model = Model(inputs=all_layers[0], outputs=[all_layers[i] for i in outputs]) print(model.summary()) 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)) plot(model, to_file='{}.png'.format(output_root), show_shapes=True) print('Saved model plot to {}.png'.format(output_root))
def _reduction_A(ip, p, filters, weight_decay=5e-5, id=None): '''Adds a Reduction cell for NASNet-A (Fig. 4 in the paper) # Arguments: ip: input tensor `x` p: input tensor `p` filters: number of output filters weight_decay: l2 regularization weight id: string id # Returns: a Keras tensor ''' """""" channel_dim = 1 if K.image_data_format() == 'channels_first' else -1 with K.name_scope('reduction_A_block_%s' % id): p = _adjust_block(p, ip, filters, weight_decay, id) h = Activation('relu')(ip) h = Conv2D(filters, (1, 1), strides=(1, 1), padding='same', name='reduction_conv_1_%s' % id, use_bias=False, kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay))(h) h = BatchNormalization(axis=channel_dim, momentum=_BN_DECAY, epsilon=_BN_EPSILON, name='reduction_bn_1_%s' % id)(h) with K.name_scope('block_1'): x1_1 = _separable_conv_block(h, filters, (5, 5), strides=(2, 2), weight_decay=weight_decay, id='reduction_left1_%s' % id) x1_2 = _separable_conv_block(p, filters, (7, 7), strides=(2, 2), weight_decay=weight_decay, id='reduction_1_%s' % id) x1 = add([x1_1, x1_2], name='reduction_add_1_%s' % id) with K.name_scope('block_2'): x2_1 = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='reduction_left2_%s' % id)(h) x2_2 = _separable_conv_block(p, filters, (7, 7), strides=(2, 2), weight_decay=weight_decay, id='reduction_right2_%s' % id) x2 = add([x2_1, x2_2], name='reduction_add_2_%s' % id) with K.name_scope('block_3'): x3_1 = AveragePooling2D((3, 3), strides=(2, 2), padding='same', name='reduction_left3_%s' % id)(h) x3_2 = _separable_conv_block(p, filters, (5, 5), strides=(2, 2), weight_decay=weight_decay, id='reduction_right3_%s' % id) x3 = add([x3_1, x3_2], name='reduction_add3_%s' % id) with K.name_scope('block_4'): x4 = AveragePooling2D((3, 3), strides=(1, 1), padding='same', name='reduction_left4_%s' % id)(x1) x4 = add([x2, x4]) with K.name_scope('block_5'): x5_1 = _separable_conv_block(x1, filters, (3, 3), weight_decay=weight_decay, id='reduction_left4_%s' % id) x5_2 = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='reduction_right5_%s' % id)(h) x5 = add([x5_1, x5_2], name='reduction_add4_%s' % id) x = concatenate([x2, x3, x4, x5], axis=channel_dim, name='reduction_concat_%s' % id) return x, ip
plt.show() (X_train, _), (X_test, _) = mnist.load_data() X_train = X_train.astype('float32') / 255. X_test = X_test.astype('float32') / 255. X_train = X_train[..., np.newaxis] X_test = X_test[..., np.newaxis] input_size = 784 epochs = 5 batch_size = 256 input_img = Input(shape=(28, 28, 1)) x = Conv2D(8, (3, 3), padding='same')(input_img) x = BatchNormalization()(x) x = Activation('relu')(x) x = MaxPooling2D((2, 2), padding='same')(x) x = Conv2D(16, (3, 3), padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) encoded = MaxPooling2D((2, 2), padding='same')(x) # at this point the representation is (7, 7, 16) x = Conv2DTranspose(16, (3, 3), padding='same')(encoded) x = BatchNormalization()(x) x = Activation('relu')(x) x = UpSampling2D((2, 2))(x) x = Conv2DTranspose(8, (3, 3), padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = UpSampling2D((2, 2))(x) decoded = Conv2DTranspose(1, (3, 3), activation='sigmoid', padding='same')(x)
def VGG16(include_top=True, weights='vggface', input_tensor=None, input_shape=None, pooling=None, classes=2622): input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=48, data_format=K.image_data_format(), require_flatten=include_top) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor # Block 1 x = Conv2D(64, (3, 3), activation='relu', padding='same', name='conv1_1')( img_input) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='conv1_2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(x) # Block 2 x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_1')( x) x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_2')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool2')(x) # Block 3 x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_1')( x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_2')( x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_3')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool3')(x) # Block 4 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_1')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_2')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_3')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool4')(x) # Block 5 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_1')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_2')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_3')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool5')(x) if include_top: # Classification block x = Flatten(name='flatten')(x) x = Dense(4096, name='fc6')(x) x = Activation('relu', name='fc6/relu')(x) x = Dense(4096, name='fc7')(x) x = Activation('relu', name='fc7/relu')(x) x = Dense(classes, name='fc8')(x) x = Activation('softmax', name='fc8/softmax')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='vggface_vgg16') # load weights if weights == 'vggface': if include_top: weights_path = get_file('rcmalli_vggface_tf_vgg16.h5', utils. VGG16_WEIGHTS_PATH, cache_subdir=utils.VGGFACE_DIR) else: weights_path = get_file('rcmalli_vggface_tf_notop_vgg16.h5', utils.VGG16_WEIGHTS_PATH_NO_TOP, cache_subdir=utils.VGGFACE_DIR) model.load_weights(weights_path, by_name=True) if K.backend() == 'theano': layer_utils.convert_all_kernels_in_model(model) if K.image_data_format() == 'channels_first': if include_top: maxpool = model.get_layer(name='pool5') shape = maxpool.output_shape[1:] dense = model.get_layer(name='fc6') layer_utils.convert_dense_weights_data_format(dense, shape, 'channels_first') if K.backend() == 'tensorflow': warnings.warn('You are using the TensorFlow backend, yet you ' 'are using the Theano ' 'image data format convention ' '(`image_data_format="channels_first"`). ' 'For best performance, set ' '`image_data_format="channels_last"` in ' 'your Keras config ' 'at ~/.keras/keras.json.') return model
# 借助全连接层实现CNN分类 model = Sequential() # model.add(BatchNormalization(axis=-1)) model.add(Conv2D(filters=32, kernel_size=(3, 3), input_shape=(28, 28, 1))) # 输入28*28,1代表灰度 # 需训练的参数:3*3*1*32 + 32 = 320 # 1代表输入深度 model.add(Activation('relu')) # relu激活 model.add(BatchNormalization(axis=-1)) # 批量标准化 model.add(Conv2D(filters=32, kernel_size=(3, 3))) # 因采用3*3卷积核,正常卷积,输出dim(26-2)*(26-2)*32 # 需训练的参数:3*3*32* 32 + 32 = 9248 # 32代表偏置 model.add(Activation('relu')) # relu激活 model.add(MaxPooling2D(pool_size=(2, 2))) # max poling池化,di = 12*12*32 model.add(BatchNormalization(axis=-1)) # 归一化 model.add(Conv2D(filters=64, kernel_size=(3, 3))) # 需训练的参数:3*3*32 * 64 + 64 = 18496 model.add(Activation('relu')) BatchNormalization(axis=1) model.add(Conv2D(filters=64, kernel_size=(3, 3))) # 需训练的参数:3*3*64 * 64 + 64 = 36928 model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Flatten()) # Flatten层用来将输入“压平”,即把多维的输入一维化,常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。