def DenseNet121(nb_dense_block=4, growth_rate=32, nb_filter=64, reduction=0.0, dropout_rate=0.0, weight_decay=1e-4, classes=1000, weights_path=None): '''Instantiate the DenseNet 121 architecture, # Arguments nb_dense_block: number of dense blocks to add to end growth_rate: number of filters to add per dense block nb_filter: initial number of filters reduction: reduction factor of transition blocks. dropout_rate: dropout rate weight_decay: weight decay factor classes: optional number of classes to classify images weights_path: path to pre-trained weights # Returns A Keras model instance. ''' eps = 1.1e-5 # compute compression factor compression = 1.0 - reduction # Handle Dimension Ordering for different backends global concat_axis if K.image_dim_ordering() == 'tf': concat_axis = 3 img_input = Input(shape=(224, 224, 3), name='data') else: concat_axis = 1 img_input = Input(shape=(3, 224, 224), name='data') # From architecture for ImageNet (Table 1 in the paper) nb_filter = 64 nb_layers = [6, 12, 24, 16] # For DenseNet-121 # Initial convolution x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input) x = Convolution2D(nb_filter, 7, 7, subsample=(2, 2), name='conv1', bias=False)(x) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x) x = Scale(axis=concat_axis, name='conv1_scale')(x) x = Activation('relu', name='relu1')(x) x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x) x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x) # Add dense blocks for block_idx in range(nb_dense_block - 1): stage = block_idx + 2 x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) # Add transition_block x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay) nb_filter = int(nb_filter * compression) final_stage = stage + 1 x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv' + str(final_stage) + '_blk_bn')(x) x = Scale(axis=concat_axis, name='conv' + str(final_stage) + '_blk_scale')(x) x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x) x = GlobalAveragePooling2D(name='pool' + str(final_stage))(x) x = Dense(classes, name='fc6')(x) x = Activation('softmax', name='prob')(x) model = Model(img_input, x, name='densenet') if weights_path is not None: model.load_weights(weights_path) return model
def build_model2(self): vae_input = Input(shape=self.input_dim) #print("vae_input shape " + str(vae_input.shape)) vae_c1 = Conv2D(filters=32, kernel_size=3, padding='same', activation='relu', trainable=True)(vae_input) vae_m1 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c1) vae_c2 = Conv2D(filters=16, kernel_size=3, padding='same', activation='relu', trainable=True)(vae_m1) vae_m2 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c2) vae_c3 = Conv2D(filters=16, kernel_size=3, padding='same', activation='relu', trainable=True)(vae_m2) vae_m3 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c3) vae_c4 = Conv2D(filters=16, kernel_size=3, padding='same', activation='relu', trainable=True)(vae_m3) vae_m4 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c4) vae_c5 = Conv2D(filters=16, kernel_size=3, padding='same', activation='relu', trainable=True)(vae_m4) vae_m5 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c5) vae_c6 = Conv2D(filters=4, kernel_size=3, padding='same', activation='relu', trainable=True)(vae_m5) vae_m6 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c6) vae_z_in = Flatten()(vae_m6) print("vae_z_in shape " + str(vae_z_in.shape)) vae_z = Dense(25, trainable=True)(vae_z_in) print("vae_z shape " + str(vae_z.shape)) vae_z_input = Input(shape=(25, )) print("vae_z_input shape " + str(vae_z_input.shape)) vae_z_out = Reshape((5, 5, 1)) vae_z_out_model = vae_z_out(vae_z) print("vae_z_out_model shape " + str(vae_z_out_model.shape)) #vae_d1 = Conv2D( filters=8, kernel_size=(3, 3), padding='same', activation='relu') vae_u1 = UpSampling2D((3, 4)) vae_d2 = Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu') vae_u2 = UpSampling2D((2, 2)) vae_d3 = Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu') vae_u3 = UpSampling2D((2, 2)) vae_d4 = Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu') vae_u4 = UpSampling2D((2, 2)) vae_d5 = Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu') vae_u5 = UpSampling2D((2, 2)) vae_d6 = Conv2D(filters=1, kernel_size=(3, 3), padding='same', activation='sigmoid') # vae_d1_model = vae_d1(vae_z_out_model) vae_u1_model = vae_u1(vae_z_out_model) vae_d2_model = vae_d2(vae_u1_model) vae_u2_model = vae_u2(vae_d2_model) vae_d3_model = vae_d3(vae_u2_model) vae_u3_model = vae_u3(vae_d3_model) vae_d4_model = vae_d4(vae_u3_model) vae_u4_model = vae_u4(vae_d4_model) vae_d5_model = vae_d5(vae_u4_model) vae_u5_model = vae_u5(vae_d5_model) vae_d6_model = vae_d6(vae_u5_model) #print("vae_d1_model shape " + str(vae_d1_model.shape)) #print("vae_u1_model shape " + str(vae_u1_model.shape)) #print("vae_d2_model shape " + str(vae_d2_model.shape)) #print("vae_u2_model shape " + str(vae_u2_model.shape)) #print("vae_d3_model shape " + str(vae_d3_model.shape)) #print("vae_u3_model shape " + str(vae_u3_model.shape)) #print("vae_d4_model shape " + str(vae_d4_model.shape)) #print("vae_u4_model shape " + str(vae_u4_model.shape)) #print("vae_d5_model shape " + str(vae_d5_model.shape)) #240 120 60 30 15 #320 160 80 40 20 vae_dense_decoder = vae_z_input vae_z_out_decoder = vae_z_out(vae_dense_decoder) #vae_d1_decoder = vae_d1(vae_z_out_decoder) vae_u1_decoder = vae_u1(vae_z_out_decoder) vae_d2_decoder = vae_d2(vae_u1_decoder) vae_u2_decoder = vae_u2(vae_d2_decoder) vae_d3_decoder = vae_d3(vae_u2_decoder) vae_u3_decoder = vae_u3(vae_d3_decoder) vae_d4_decoder = vae_d4(vae_u3_decoder) vae_u4_decoder = vae_u4(vae_d4_decoder) vae_d5_decoder = vae_d5(vae_u4_decoder) vae_u5_decoder = vae_u5(vae_d5_decoder) vae_d6_decoder = vae_d6(vae_u5_decoder) print("vae_d1_decoder shape " + str(vae_u1_decoder.shape)) print("vae_d2_decoder shape " + str(vae_d2_decoder.shape)) print("vae_d3_decoder shape " + str(vae_d3_decoder.shape)) print("vae_d4_decoder shape " + str(vae_d4_decoder.shape)) print("vae_d5_decoder shape " + str(vae_d5_decoder.shape)) # Models vae = Model(vae_input, vae_d6_model) vae_encoder = Model(vae_input, vae_z) vae_decoder = Model(vae_z_input, vae_d6_decoder) #vae.compile(optimizer='rmsprop', loss = vae_loss, metrics = [vae_r_loss, vae_kl_loss]) #vae.compile(optimizer='rmsprop', loss='binary_crossentropy') #optimizer = Adam(lr=0.001) vae.compile(optimizer=Adam(lr=0.0001), loss='binary_crossentropy') vae.summary() return (vae, vae_encoder, vae_decoder)
def create_model(learning_rate, num_dense_layers, num_dense_nodes, activation): """ Hyper-parameters: learning_rate: Learning-rate for the optimizer. num_dense_layers: Number of dense layers. num_dense_nodes: Number of nodes in each dense layer. activation: Activation function for all layers. """ # Start construction of a Keras Sequential model. model = Sequential() # Add an input layer which is similar to a feed_dict in TensorFlow. # Note that the input-shape must be a tuple containing the image-size. model.add(InputLayer(input_shape=(img_size_flat, ))) # The input from MNIST is a flattened array with 784 elements, # but the convolutional layers expect images with shape (28, 28, 1) model.add(Reshape(img_shape_full)) # First convolutional layer. # There are many hyper-parameters in this layer, but we only # want to optimize the activation-function in this example. model.add( Conv2D(kernel_size=5, strides=1, filters=16, padding='same', activation=activation, name='layer_conv1')) model.add(MaxPooling2D(pool_size=2, strides=2)) # Second convolutional layer. # Again, we only want to optimize the activation-function here. model.add( Conv2D(kernel_size=5, strides=1, filters=36, padding='same', activation=activation, name='layer_conv2')) model.add(MaxPooling2D(pool_size=2, strides=2)) # Flatten the 4-rank output of the convolutional layers # to 2-rank that can be input to a fully-connected / dense layer. model.add(Flatten()) # Add fully-connected / dense layers. # The number of layers is a hyper-parameter we want to optimize. for i in range(num_dense_layers): # Name of the layer. This is not really necessary # because Keras should give them unique names. name = 'layer_dense_{0}'.format(i + 1) # Add the dense / fully-connected layer to the model. # This has two hyper-parameters we want to optimize: # The number of nodes and the activation function. model.add(Dense(num_dense_nodes, activation=activation, name=name)) # Last fully-connected / dense layer with softmax-activation # for use in classification. model.add(Dense(num_classes, activation='softmax')) # Use the Adam method for training the network. # We want to find the best learning-rate for the Adam method. optimizer = Adam(lr=learning_rate) # In Keras we need to compile the model so it can be trained. model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy']) return model
def build_model(input_shape=None): input_shape = _obtain_input_shape(input_shape, default_size=im_size, min_size=24, data_format=K.image_data_format(), require_flatten=False, weights='None') img_input = Input(shape=input_shape) reg = regularizers.l2(0.001) # first block x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False, name='block1_conv1', kernel_regularizer=reg)(img_input) x = BatchNormalization(name='block1_conv1_bn')(x) x = Activation('relu', name='block1_conv1_act')(x) x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2', kernel_regularizer=reg)(x) x = BatchNormalization(name='block1_conv2_bn')(x) x = Activation('relu', name='block1_conv2_act')(x) residual = Conv2D(256, (1, 1), strides=(2, 2), padding='same', use_bias=False, name='residual_conv2d_1', kernel_regularizer=reg)(x) residual = BatchNormalization()(residual) # second block x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv1', kernel_regularizer=reg)(x) x = BatchNormalization(name='block2_sepconv1_bn')(x) x = Activation('relu', name='block2_sepconv2_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block2_sepconv2', kernel_regularizer=reg)(x) x = BatchNormalization(name='block2_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block2_pool')(x) x = layers.add([x, residual]) # second residual residual = Conv2D(256, (1, 1), strides=(2, 2), padding='same', use_bias=False, name='residual_conv2d_2', kernel_regularizer=reg)(x) residual = BatchNormalization()(residual) for i in range(2): residual = x prefix = 'block' + str(i + 3) x = Activation('relu', name=prefix + '_sepconv1_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv1', kernel_regularizer=reg)(x) x = BatchNormalization(name=prefix + '_sepconv1_bn')(x) x = Activation('relu', name=prefix + '_sepconv2_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv2', kernel_regularizer=reg)(x) x = BatchNormalization(name=prefix + '_sepconv2_bn')(x) x = Activation('relu', name=prefix + '_sepconv3_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv3', kernel_regularizer=reg)(x) x = BatchNormalization(name=prefix + '_sepconv3_bn')(x) x = layers.add([x, residual]) residual = Conv2D(384, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) # output blocks - block 21 x = Activation('relu', name='block21_sepconv1_act')(x) x = SeparableConv2D(384, (3, 3), padding='same', use_bias=False, name='block21_sepconv1', kernel_regularizer=reg)(x) x = BatchNormalization(name='block21_sepconv1_bn')(x) x = Activation('relu', name='block21_sepconv2_act')(x) x = SeparableConv2D(384, (3, 3), padding='same', use_bias=False, name='block21_sepconv2', kernel_regularizer=reg)(x) x = BatchNormalization(name='block21_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block13_pool')(x) x = layers.add([x, residual]) # block 22 x = SeparableConv2D(512, (3, 3), padding='same', use_bias=False, name='block22_sepconv1', kernel_regularizer=reg)(x) x = BatchNormalization(name='block22_sepconv1_bn')(x) x = Activation('relu', name='block22_sepconv1_act')(x) x = SeparableConv2D(768, (3, 3), padding='same', use_bias=False, name='block22_sepconv2', kernel_regularizer=reg)(x) x = BatchNormalization(name='block22_sepconv2_bn')(x) x = Activation('relu', name='block22_sepconv2_act')(x) # model finish x = GlobalMaxPooling2D()(x) x = Flatten()(x) x = Dense(256, activation='relu', kernel_regularizer=reg)(x) x = Dense(64, activation='relu', kernel_regularizer=reg)(x) x = Dense(num_classes, activation='softmax')(x) model = Model(img_input, x, name='micro_xception_bn_v1') opt = optimizers.Adam(lr=0.0008, decay=0.001) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) return model
input_shape = (w, h, c) learning_rate = 0.00001 regularization_rate = 0.000001 category_count = 30 + 1 model = Sequential() # Layer 1 model.add( Conv2D(32, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4))) # Layer 2 model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.1)) # Layer 3 model.add(Conv2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) # Layer 4 model.add(Conv2D(256, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2))
input_shape = (img_width, img_height, 3) PWD = '.' MODEL = "{}/cnn_model.h5".format(PWD) if os.path.isfile(MODEL): model = keras.models.load_model(MODEL) else: model = Sequential() model.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(32, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(32, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(16, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(6, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
def VGG_16(spatial_size, classes, channels, channel_first=True, weights_path=None): model = Sequential() if channel_first: model.add( ZeroPadding2D((1, 1), input_shape=(channels, spatial_size, spatial_size))) else: model.add( ZeroPadding2D((1, 1), input_shape=(spatial_size, spatial_size, channels))) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(128, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(256, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(256, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(256, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(512, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(512, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(512, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(512, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(512, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(512, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) # 33 model.add(Flatten()) model.add(Dense(4096, activation='relu')) # 34 model.add(Dropout(0.5)) model.add(Dense(4096, activation='relu')) # 35 model.add(Dropout(0.5)) model.add(Dense(2622, activation='softmax')) # Dropped if weights_path: model.load_weights(weights_path) model.pop() model.add(Dense(classes, activation='softmax')) # 36 return model
from tensorflow.python.keras.models import Sequential from tensorflow.python.keras.layers import InputLayer from tensorflow.python.keras.layers import MaxPooling2D from tensorflow.python.keras.layers import Conv2D, Dense, Flatten from tensorflow.python.keras.optimizers import Adam from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets('data/MNIST/', one_hot=True, reshape=False) model = Sequential() model.add(InputLayer(input_shape=(28, 28, 1))) model.add(Conv2D(kernel_size=5, strides=1, filters=32, padding='same', activation='relu', name='conv1')) model.add(MaxPooling2D(pool_size=2, strides=2)) model.add(Conv2D(kernel_size=5, strides=1, filters=64, padding='same', activation='relu', name='conv2')) model.add(MaxPooling2D(pool_size=2, strides=2)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dense(10, activation='softmax')) optimizer = Adam(lr=1e-3) model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy']) model.fit(x=mnist.train.images, y=mnist.train.labels, epochs=5, batch_size=128) result = model.evaluate(x=mnist.train.images, y=mnist.train.labels) print('\n\nAccuracy:', result[1])
data_validacion, target_size=(altura, longitud), batch_size=batch_size, class_mode='categorical') #Crear la red CNN cnn = Sequential() cnn.add( Convolution2D(filtrosConv1, tamano_filtro1, padding='same', input_shape=(altura, longitud, 3), activation='relu')) cnn.add(MaxPooling2D(pool_size=tamano_pool)) cnn.add( Convolution2D(filtrosConv2, tamano_filtro2, padding='same', activation='relu')) cnn.add(MaxPooling2D(pool_size=tamano_pool)) cnn.add(Flatten()) cnn.add(Dense(256, activation='relu')) cnn.add(Dropout(0.5)) cnn.add(Dense(clases, activation='softmax')) cnn.compile(loss='categorical_crossentropy', optimizer=optimizers.Adam(lr=lr),
def train(run_name, start_epoch, stop_epoch, img_w, img_h, build_word_count, max_string_len, save_model_path=None): # Input Parameters words_per_epoch = 96000 val_split = 0.2 val_words = int(words_per_epoch * (val_split)) # Network parameters pool_size = 2 minibatch_size = 32 if K.image_data_format() == 'channels_first': input_shape = (1, img_w, img_h) else: input_shape = (img_w, img_h, 1) img_gen = TextImageGenerator(minibatch_size=minibatch_size, img_w=img_w, img_h=img_h, val_split=words_per_epoch - val_words, build_word_count=build_word_count, max_string_len=max_string_len) act = 'relu' kernel_init = 'glorot_uniform' input_data = Input(name='the_input', shape=input_shape, dtype='float32') inner = Conv2D(64, (3, 3), padding='same', activation=None, kernel_initializer=kernel_init, name='conv1')(input_data) inner = BatchNormalization(axis=3, scale=False, name='bn1')(inner) inner = Activation(activation=act)(inner) inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner) inner = identity_block(inner, 3, [16, 16, 64], stage=2, block='a', train_bn=True) inner = conv_block(inner, 3, [32, 32, 128], stage=3, block='a', train_bn=True) inner = conv_block(inner, 3, [64, 64, 256], stage=4, block='a', train_bn=True) inner = Flatten(name='reshape')(inner) inner = Dense(512, activation=act, name='dense1')(inner) outputs = [] for i in range(max_string_len): output = Dense(img_gen.get_output_size(), activation='softmax', kernel_initializer=kernel_init, name='output{}'.format(i))(inner) outputs.append(output) output = Dense(max_string_len + 1, activation='softmax', kernel_initializer=kernel_init, name='output{}'.format(max_string_len))(inner) outputs.append(output) # clipnorm seems to speeds up convergence sgd = SGD(lr=0.005, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5) model = Model(inputs=[input_data], outputs=outputs) # the loss calc occurs elsewhere, so use a dummy lambda func for the loss model.compile(loss=['sparse_categorical_crossentropy'] * (max_string_len + 1), optimizer=sgd, metrics=['accuracy'] * (max_string_len + 1)) if start_epoch > 0: weight_file = os.path.join( OUTPUT_DIR, os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1))) model.load_weights(weight_file) print("load_weight: ", weight_file) # captures output of softmax so we can decode the output during visualization test_func = K.function([input_data], outputs) viz_cb = VizCallback(run_name, test_func, img_gen.next_val()) model.fit_generator(generator=img_gen.next_train(), steps_per_epoch=(words_per_epoch - val_words) // minibatch_size, epochs=stop_epoch, validation_data=img_gen.next_val(), validation_steps=val_words // minibatch_size, callbacks=[viz_cb, img_gen], initial_epoch=start_epoch, verbose=1) if save_model_path: model.save(save_model_path)
def DenseNet(blocks, include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000): """Instantiates the DenseNet 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 TensorFlow, Theano, and CNTK. The data format convention used by the model is the one specified in your Keras config file. Arguments: blocks: numbers of building blocks for the four dense layers. include_top: whether to include the fully-connected layer at the top of the network. weights: one of `None` (random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. 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, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels. 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 not (weights in {'imagenet', None} or os.path.exists(weights)): raise ValueError('The `weights` argument should be either ' '`None` (random initialization), `imagenet` ' '(pre-training on ImageNet), ' 'or the path to the weights file to be loaded.') 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=221, 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 bn_axis = 3 if K.image_data_format() == 'channels_last' else 1 x = ZeroPadding2D(padding=((3, 3), (3, 3)))(img_input) x = Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x) x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='conv1/bn')(x) x = Activation('relu', name='conv1/relu')(x) x = ZeroPadding2D(padding=((1, 1), (1, 1)))(x) x = MaxPooling2D(3, strides=2, name='pool1')(x) x = dense_block(x, blocks[0], name='conv2') x = transition_block(x, 0.5, name='pool2') x = dense_block(x, blocks[1], name='conv3') x = transition_block(x, 0.5, name='pool3') x = dense_block(x, blocks[2], name='conv4') x = transition_block(x, 0.5, name='pool4') x = dense_block(x, blocks[3], name='conv5') x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='bn')(x) if include_top: x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dense(classes, activation='softmax', name='fc1000')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = GlobalMaxPooling2D(name='max_pool')(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. if blocks == [6, 12, 24, 16]: model = Model(inputs, x, name='densenet121') elif blocks == [6, 12, 32, 32]: model = Model(inputs, x, name='densenet169') elif blocks == [6, 12, 48, 32]: model = Model(inputs, x, name='densenet201') else: model = Model(inputs, x, name='densenet') # Load weights. if weights == 'imagenet': if include_top: if blocks == [6, 12, 24, 16]: weights_path = get_file( 'densenet121_weights_tf_dim_ordering_tf_kernels.h5', DENSENET121_WEIGHT_PATH, cache_subdir='models', file_hash='0962ca643bae20f9b6771cb844dca3b0') elif blocks == [6, 12, 32, 32]: weights_path = get_file( 'densenet169_weights_tf_dim_ordering_tf_kernels.h5', DENSENET169_WEIGHT_PATH, cache_subdir='models', file_hash='bcf9965cf5064a5f9eb6d7dc69386f43') elif blocks == [6, 12, 48, 32]: weights_path = get_file( 'densenet201_weights_tf_dim_ordering_tf_kernels.h5', DENSENET201_WEIGHT_PATH, cache_subdir='models', file_hash='7bb75edd58cb43163be7e0005fbe95ef') else: if blocks == [6, 12, 24, 16]: weights_path = get_file( 'densenet121_weights_tf_dim_ordering_tf_kernels_notop.h5', DENSENET121_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='4912a53fbd2a69346e7f2c0b5ec8c6d3') elif blocks == [6, 12, 32, 32]: weights_path = get_file( 'densenet169_weights_tf_dim_ordering_tf_kernels_notop.h5', DENSENET169_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='50662582284e4cf834ce40ab4dfa58c6') elif blocks == [6, 12, 48, 32]: weights_path = get_file( 'densenet201_weights_tf_dim_ordering_tf_kernels_notop.h5', DENSENET201_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='1c2de60ee40562448dbac34a0737e798') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
trainX = inputX[:70000] trainY = inputY[:70000] valX = inputX[70000:] valY = inputY[70000:] es = EarlyStopping(monitor='val_mae', mode='min', verbose=1, patience=150) # design network model = Sequential() model.add( Conv2D(32, (3, 3), activation='relu', input_shape=(84, 84, 1), padding='same')) model.add(MaxPooling2D((2, 2), padding='same')) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D((2, 2), padding='same')) model.add(Conv2D(8, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D((2, 2), padding='same')) model.add(Conv2D(8, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(32, (3, 3), activation='relu')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(1, (3, 3), padding='same')) model.compile(loss='mse', optimizer='rmsprop', metrics=['mae'])
def FCN(input_shape=None, batch_shape=None): if batch_shape: img_input = Input(batch_shape=batch_shape) image_size = batch_shape[1:3] else: img_input = Input(shape=input_shape) image_size = input_shape[0:2] bn_axis = 3 # just one class, unpickable classes = 1 x = Conv2D(256, (10, 10), strides=(1, 1), padding='same', name='conv1')(img_input) x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=0.9)(x) x = Activation('relu')(x) x = MaxPooling2D((2, 2), strides=(2, 2))(x) 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 = BatchNormalization(axis=bn_axis, name='bn_conv2', momentum=0.9)(x) x = Activation('relu')(x) x = MaxPooling2D((2, 2), strides=(2, 2))(x) #x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x) #x = MaxPooling2D((2, 2), strides=(2, 2))(x) # x = Conv2D(128, (5, 5), strides=(1, 1), padding='same', name='conv3')(x) # x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x) # x = Activation('relu')(x) #x = MaxPooling2D((2, 2), strides=(2, 2))(x) #x = Conv2D(128, (3, 3), strides=(2, 2), padding='same', name='conv4')(x) #x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x) #x = Activation('relu')(x) #x = MaxPooling2D((2, 2), strides=(2, 2))(x) #x = Conv2D(128, (5, 5), strides=(2, 2), padding='same', name='conv3')(img_input) #x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x) #x = Activation('relu')(x) #x = MaxPooling2D((2, 2), strides=(2, 2))(x) #classifying layer #x = Conv2D(classes, (3, 3), dilation_rate=(2, 2), kernel_initializer='normal', activation='linear', padding='same', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x) x = Conv2D(classes, (1, 1), kernel_initializer='he_normal', activation='sigmoid', padding='same', strides=(1, 1))(x) # = BilinearUpSampling2D(target_size=tuple(image_size))(x) #x = tf.image.resize_images(x, [image_size[0], image_size[1]]) x = UpSampling2D(size=(4, 4), data_format=None)(x) model = Model(img_input, x) # weights_path = os.path.expanduser(os.path.join('~', '.keras/models/fcn_resnet50_weights_tf_dim_ordering_tf_kernels.h5')) # model.load_weights(weights_path, by_name=True) return model
def UNet(input_size: Tuple[int, int, int] = (128, 128, 1)) -> tf.keras.Model: """A standard UNet implementation in pytorch Args: input_size: The size of the input tensor (height, width, channels). Raises: ValueError: Length of `input_size` is not 3. ValueError: `input_size`[0] or `input_size`[1] is not a multiple of 16. Returns: A TensorFlow UNet model. """ _check_input_size(input_size) conv_config = { 'activation': 'relu', 'padding': 'same', 'kernel_initializer': 'he_normal' } up_config = {'size': (2, 2), 'interpolation': 'bilinear'} inputs = Input(input_size) conv1 = Conv2D(64, 3, **conv_config)(inputs) conv1 = Conv2D(64, 3, **conv_config)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, **conv_config)(pool1) conv2 = Conv2D(128, 3, **conv_config)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, **conv_config)(pool2) conv3 = Conv2D(256, 3, **conv_config)(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, **conv_config)(pool3) conv4 = Conv2D(512, 3, **conv_config)(conv4) drop4 = Dropout(0.5)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = Conv2D(1024, 3, **conv_config)(pool4) conv5 = Conv2D(1024, 3, **conv_config)(conv5) drop5 = Dropout(0.5)(conv5) up6 = Conv2D(512, 3, **conv_config)(UpSampling2D(**up_config)(drop5)) merge6 = concatenate([drop4, up6], axis=-1) conv6 = Conv2D(512, 3, **conv_config)(merge6) conv6 = Conv2D(512, 3, **conv_config)(conv6) up7 = Conv2D(256, 3, **conv_config)(UpSampling2D(**up_config)(conv6)) merge7 = concatenate([conv3, up7], axis=-1) conv7 = Conv2D(256, 3, **conv_config)(merge7) conv7 = Conv2D(256, 3, **conv_config)(conv7) up8 = Conv2D(128, 3, **conv_config)(UpSampling2D(**up_config)(conv7)) merge8 = concatenate([conv2, up8], axis=-1) conv8 = Conv2D(128, 3, **conv_config)(merge8) conv8 = Conv2D(128, 3, **conv_config)(conv8) up9 = Conv2D(64, 3, **conv_config)(UpSampling2D(**up_config)(conv8)) merge9 = concatenate([conv1, up9], axis=-1) conv9 = Conv2D(64, 3, **conv_config)(merge9) conv9 = Conv2D(64, 3, **conv_config)(conv9) conv10 = Conv2D(1, 1, activation='sigmoid')(conv9) model = Model(inputs=inputs, outputs=conv10) return model
def cifar100_complicated_ensemble_submodel3( input_shape=None, input_tensor=None, n_classes=None, weights_path: Union[None, str] = None) -> Model: """ Defines a cifar100 network. :param n_classes: used in order to be compatible with the main script. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained custom network's weights. :return: Keras functional API Model. """ inputs = create_inputs(input_shape, input_tensor) # Define a weight decay for the regularisation. weight_decay = 1e-7 # Block 1. x = Conv2D(32, (3, 3), padding='same', activation='relu', name='block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x = BatchNormalization(name='block1_batch-norm1')(x) x = Conv2D(32, (3, 3), padding='same', activation='relu', name='block1_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block1_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block1_pool')(x) x = Dropout(0.2, name='block1_dropout', seed=0)(x) # Block 2. x = Conv2D(64, (3, 3), padding='same', activation='relu', name='block2_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm1')(x) x = Conv2D(64, (3, 3), padding='same', activation='relu', name='block2_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block2_pool')(x) x = Dropout(0.3, name='block2_dropout', seed=0)(x) # Block 3. x = Conv2D(128, (3, 3), padding='same', activation='relu', name='block3_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block3_batch-norm1')(x) x = Conv2D(128, (3, 3), padding='same', activation='relu', name='block3_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block3_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block3_pool')(x) x = Dropout(0.4, name='block3_dropout', seed=0)(x) # Block 4. x = Conv2D(256, (3, 3), padding='same', activation='relu', name='block4_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block4_batch-norm1')(x) x = Conv2D(256, (3, 3), padding='same', activation='relu', name='block4_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block4_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block4_pool')(x) x = Dropout(0.5, name='block4_dropout', seed=0)(x) # Add top layers. x = Flatten(name='flatten')(x) outputs = Dense(n_classes, activation='softmax', name='softmax_outputs')(x) # Create Submodel 3. model = Model(inputs, outputs, name='cifar100_complicated_ensemble_submodel3') # Load weights, if they exist. load_weights(weights_path, model) return model
def InceptionV3(include_top=True, weights='imagenet', input_tensor=None, model_input=None, pooling=None, classes=1000, model_path=""): """Instantiates the Inception v3 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. Note that the default input image size for this model is 299x299. # 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 `(299, 299, 3)` (with `channels_last` data format) or `(3, 299, 299)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 139. E.g. `(150, 150, 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 == 'imagenet' and include_top and classes != 1000: raise ValueError('If using `weights` as imagenet with `include_top`' ' as true, `classes` should be 1000') img_input = model_input channel_axis = 3 x = conv2d_bn(img_input, 32, 3, 3, strides=(2, 2), padding='valid') x = conv2d_bn(x, 32, 3, 3, padding='valid') x = conv2d_bn(x, 64, 3, 3) x = MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv2d_bn(x, 80, 1, 1, padding='valid') x = conv2d_bn(x, 192, 3, 3, padding='valid') x = MaxPooling2D((3, 3), strides=(2, 2))(x) # mixed 0, 1, 2: 35 x 35 x 256 branch1x1 = conv2d_bn(x, 64, 1, 1) branch5x5 = conv2d_bn(x, 48, 1, 1) branch5x5 = conv2d_bn(branch5x5, 64, 5, 5) branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 32, 1, 1) x = layers.concatenate( [branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed0') # mixed 1: 35 x 35 x 256 branch1x1 = conv2d_bn(x, 64, 1, 1) branch5x5 = conv2d_bn(x, 48, 1, 1) branch5x5 = conv2d_bn(branch5x5, 64, 5, 5) branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 64, 1, 1) x = layers.concatenate( [branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed1') # mixed 2: 35 x 35 x 256 branch1x1 = conv2d_bn(x, 64, 1, 1) branch5x5 = conv2d_bn(x, 48, 1, 1) branch5x5 = conv2d_bn(branch5x5, 64, 5, 5) branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 64, 1, 1) x = layers.concatenate( [branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed2') # mixed 3: 17 x 17 x 768 branch3x3 = conv2d_bn(x, 384, 3, 3, strides=(2, 2), padding='valid') branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn( branch3x3dbl, 96, 3, 3, strides=(2, 2), padding='valid') branch_pool = MaxPooling2D((3, 3), strides=(2, 2))(x) x = layers.concatenate( [branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed3') # mixed 4: 17 x 17 x 768 branch1x1 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(x, 128, 1, 1) branch7x7 = conv2d_bn(branch7x7, 128, 1, 7) branch7x7 = conv2d_bn(branch7x7, 192, 7, 1) branch7x7dbl = conv2d_bn(x, 128, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed4') # mixed 5, 6: 17 x 17 x 768 for i in range(2): branch1x1 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(x, 160, 1, 1) branch7x7 = conv2d_bn(branch7x7, 160, 1, 7) branch7x7 = conv2d_bn(branch7x7, 192, 7, 1) branch7x7dbl = conv2d_bn(x, 160, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch_pool = AveragePooling2D( (3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed' + str(5 + i)) # mixed 7: 17 x 17 x 768 branch1x1 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(branch7x7, 192, 1, 7) branch7x7 = conv2d_bn(branch7x7, 192, 7, 1) branch7x7dbl = conv2d_bn(x, 192, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed7') # mixed 8: 8 x 8 x 1280 branch3x3 = conv2d_bn(x, 192, 1, 1) branch3x3 = conv2d_bn(branch3x3, 320, 3, 3, strides=(2, 2), padding='valid') branch7x7x3 = conv2d_bn(x, 192, 1, 1) branch7x7x3 = conv2d_bn(branch7x7x3, 192, 1, 7) branch7x7x3 = conv2d_bn(branch7x7x3, 192, 7, 1) branch7x7x3 = conv2d_bn( branch7x7x3, 192, 3, 3, strides=(2, 2), padding='valid') branch_pool = MaxPooling2D((3, 3), strides=(2, 2))(x) x = layers.concatenate( [branch3x3, branch7x7x3, branch_pool], axis=channel_axis, name='mixed8') # mixed 9: 8 x 8 x 2048 for i in range(2): branch1x1 = conv2d_bn(x, 320, 1, 1) branch3x3 = conv2d_bn(x, 384, 1, 1) branch3x3_1 = conv2d_bn(branch3x3, 384, 1, 3) branch3x3_2 = conv2d_bn(branch3x3, 384, 3, 1) branch3x3 = layers.concatenate( [branch3x3_1, branch3x3_2], axis=channel_axis, name='mixed9_' + str(i)) branch3x3dbl = conv2d_bn(x, 448, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 384, 3, 3) branch3x3dbl_1 = conv2d_bn(branch3x3dbl, 384, 1, 3) branch3x3dbl_2 = conv2d_bn(branch3x3dbl, 384, 3, 1) branch3x3dbl = layers.concatenate( [branch3x3dbl_1, branch3x3dbl_2], axis=channel_axis) branch_pool = AveragePooling2D( (3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed' + str(9 + i)) if include_top: # Classification block x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dense(classes, activation='softmax', name='predictions')(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`. inputs = img_input # Create model. model = Model(inputs, x, name='inception_v3') # load weights if weights == 'imagenet': if K.image_data_format() == '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.') if include_top: weights_path = model_path model.load_weights(weights_path) else: weights_path = "" elif (weights == "trained"): weights_path = model_path model.load_weights(weights_path) return model
def DeepConvNet(nb_classes, Chans=64, Samples=256, dropoutRate=0.5): """ Keras implementation of the Deep Convolutional Network as described in Schirrmeister et. al. (2017), Human Brain Mapping. This implementation assumes the input is a 2-second EEG signal sampled at 128Hz, as opposed to signals sampled at 250Hz as described in the original paper. We also perform temporal convolutions of length (1, 5) as opposed to (1, 10) due to this sampling rate difference. Note that we use the max_norm constraint on all convolutional layers, as well as the classification layer. We also change the defaults for the BatchNormalization layer. We used this based on a personal communication with the original authors. ours original paper pool_size 1, 2 1, 3 strides 1, 2 1, 3 conv filters 1, 5 1, 10 Note that this implementation has not been verified by the original authors. """ # start the model input_main = Input((1, Chans, Samples)) block1 = Conv2D(25, (1, 5), input_shape=(1, Chans, Samples), kernel_constraint=max_norm(2., axis=(0, 1, 2)))(input_main) block1 = Conv2D(25, (Chans, 1), kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block1) block1 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block1) block1 = Activation('elu')(block1) block1 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block1) block1 = Dropout(dropoutRate)(block1) block2 = Conv2D(50, (1, 5), kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block1) block2 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block2) block2 = Activation('elu')(block2) block2 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block2) block2 = Dropout(dropoutRate)(block2) block3 = Conv2D(100, (1, 5), kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block2) block3 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block3) block3 = Activation('elu')(block3) block3 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block3) block3 = Dropout(dropoutRate)(block3) block4 = Conv2D(200, (1, 5), kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block3) block4 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block4) block4 = Activation('elu')(block4) block4 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block4) block4 = Dropout(dropoutRate)(block4) flatten = Flatten()(block4) dense = Dense(nb_classes, kernel_constraint=max_norm(0.5))(flatten) softmax = Activation('softmax')(dense) return Model(inputs=input_main, outputs=softmax)
def main(): parser = argparse.ArgumentParser(description='Tensorflow MNIST Example') parser.add_argument('--batch-size', type=int, default=100, metavar='N', help='input batch size for training (default: 100)') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.01, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') args = parser.parse_args() print(args) use_cuda = not args.no_cuda num_classes = 10 # input image dimensions img_rows, img_cols = 28, 28 # the data, shuffled and split between train and test sets (x_train, y_train), (x_test, y_test) = mnist.load_data(path=str(PurePath(data_dir, "mnist.npz"))) if K.image_data_format() == 'channels_first': 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: 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 print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # convert class vectors to binary class matrices y_train = tf.keras.utils.to_categorical(y_train, num_classes) y_test = tf.keras.utils.to_categorical(y_test, num_classes) cp_callback = MyCallback.get_cp_callback(checkpoint_dir) mq_callback = MyCallback.get_mq_callback() with strategy.scope(): model = Sequential() model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.Adadelta(lr=args.lr), metrics=['accuracy']) start_time = time.time() model.fit(x_train, y_train, batch_size=args.batch_size, epochs=args.epochs, verbose=1, validation_data=(x_test, y_test), callbacks=[cp_callback, mq_callback]) duration = (time.time() - start_time) / 60 print("Train finished. Time cost: %.2f minutes" % (duration)) score = model.evaluate(x_test, y_test, batch_size=args.batch_size, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1])
#CAEモデル構築 autoencoder = Sequential() #encoder畳み込み層 autoencoder.add( Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='same', input_shape=(28, 28, 1))) autoencoder.add(MaxPooling2D( pool_size=(2, 2), #strides=1, padding='same')) autoencoder.add( Conv2D( filters=8, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='same', )) autoencoder.add(MaxPooling2D( pool_size=(2, 2), #strides=1, padding='same'))
help="dimension of model ouput") args = parser.parse_args() dataloader = Dataloader(args) p = PointEmbedding(args) p_model = p.build() loss_func = p.custom_loss() x1 = Input((28, 28)) x2 = Input((28, 28)) x1_r = K.reshape(x1, (-1, 28, 28, 1)) x2_r = K.reshape(x2, (-1, 28, 28, 1)) pair1 = K.concatenate([x1_r, x2_r], axis=2) x3 = Input((28, 28)) x4 = Input((28, 28)) x3_r = K.reshape(x3, (-1, 28, 28, 1)) x4_r = K.reshape(x4, (-1, 28, 28, 1)) pair2 = K.concatenate([x3_r, x4_r], axis=2) output = Conv2D(1, (5, 5), (2, 2))(pair1) output = MaxPooling2D((2, 2), (1, 1))(output) output = Conv2D(1, (5, 5), (2, 2))(output) output = MaxPooling2D((2, 2), (1, 1))(output) output = Flatten()(output) output = Dense(2)(output) print(K.square(output)) print(K.sum(K.square(output), axis=-1)) print(K.sigmoid(K.sum(K.square(output), axis=-1)))