我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用keras.layers.convolutional.Conv2D()。
def __transition_up_block(ip, nb_filters, type='deconv', weight_decay=1E-4): ''' SubpixelConvolutional Upscaling (factor = 2) Args: ip: keras tensor nb_filters: number of layers type: can be 'upsampling', 'subpixel', 'deconv'. Determines type of upsampling performed weight_decay: weight decay factor Returns: keras tensor, after applying upsampling operation. ''' if type == 'upsampling': x = UpSampling2D()(ip) elif type == 'subpixel': x = Conv2D(nb_filters, (3, 3), activation='relu', padding='same', kernel_regularizer=l2(weight_decay), use_bias=False, kernel_initializer='he_normal')(ip) x = SubPixelUpscaling(scale_factor=2)(x) x = Conv2D(nb_filters, (3, 3), activation='relu', padding='same', kernel_regularizer=l2(weight_decay), use_bias=False, kernel_initializer='he_normal')(x) else: x = Conv2DTranspose(nb_filters, (3, 3), activation='relu', padding='same', strides=(2, 2), kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay))(ip) return x
def get_unet0(num_start_filters=32): inputs = Input((img_rows, img_cols, num_channels)) conv1 = ConvBN2(inputs, num_start_filters) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = ConvBN2(pool1, 2 * num_start_filters) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = ConvBN2(pool2, 4 * num_start_filters) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = ConvBN2(pool3, 8 * num_start_filters) pool4 = MaxPooling2D(pool_size=(2, 2))(conv4) conv5 = ConvBN2(pool4, 16 * num_start_filters) up6 = concatenate([UpSampling2D(size=(2, 2))(conv5), conv4]) conv6 = ConvBN2(up6, 8 * num_start_filters) up7 = concatenate([UpSampling2D(size=(2, 2))(conv6), conv3]) conv7 = ConvBN2(up7, 4 * num_start_filters) up8 = concatenate([UpSampling2D(size=(2, 2))(conv7), conv2]) conv8 = ConvBN2(up8, 2 * num_start_filters) up9 = concatenate([UpSampling2D(size=(2, 2))(conv8), conv1]) conv9 = Conv2D(num_start_filters, (3, 3), padding="same", kernel_initializer="he_uniform")(up9) conv9 = BatchNormalization()(conv9) conv9 = Activation('selu')(conv9) conv9 = Conv2D(num_start_filters, (3, 3), padding="same", kernel_initializer="he_uniform")(conv9) crop9 = Cropping2D(cropping=((16, 16), (16, 16)))(conv9) conv9 = BatchNormalization()(crop9) conv9 = Activation('selu')(conv9) conv10 = Conv2D(num_mask_channels, (1, 1))(conv9) model = Model(inputs=inputs, outputs=conv10) return model
def build_simpleCNN(input_shape = (32, 32, 3), num_output = 10): h, w, nch = input_shape assert h == w, 'expect input shape (h, w, nch), h == w' images = Input(shape = (h, h, nch)) x = Conv2D(64, (4, 4), strides = (1, 1), kernel_initializer = init, padding = 'same')(images) x = BatchNormalization()(x) x = Activation('relu')(x) x = MaxPooling2D(pool_size = (2, 2))(x) x = Conv2D(128, (4, 4), strides = (1, 1), kernel_initializer = init, padding = 'same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = MaxPooling2D(pool_size = (2, 2))(x) x = Flatten()(x) outputs = Dense(num_output, kernel_initializer = init, activation = 'softmax')(x) model = Model(inputs = images, outputs = outputs) return model
def _shortcut(inputs, x): # shortcut path _, inputs_w, inputs_h, inputs_ch = K.int_shape(inputs) _, x_w, x_h, x_ch = K.int_shape(x) stride_w = int(round(inputs_w / x_w)) stride_h = int(round(inputs_h / x_h)) equal_ch = inputs_ch == x_ch if stride_w>1 or stride_h>1 or not equal_ch: shortcut = Conv2D(x_ch, (1, 1), strides = (stride_w, stride_h), kernel_initializer = init, padding = 'valid')(inputs) else: shortcut = inputs merged = Add()([shortcut, x]) return merged
def build(input_shape, classes): model = Sequential() # CONV => RELU => POOL model.add(Conv2D(20, kernel_size=5, padding="same", input_shape=input_shape)) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # CONV => RELU => POOL model.add(Conv2D(50, kernel_size=5, padding="same")) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # Flatten => RELU layers model.add(Flatten()) model.add(Dense(500)) model.add(Activation("relu")) # a softmax classifier model.add(Dense(classes)) model.add(Activation("softmax")) return model # network and training
def make_model(batch_size, image_dim): model = Sequential() model.add(BatchNormalization(batch_input_shape=(batch_size,image_dim[1],image_dim[2],1))) model.add(Conv2D( 16 , [3,3], activation='relu',padding='same')) #model.add(Dropout(0.2)) model.add(Conv2D( 32 , [3,3], activation='relu',padding='same')) #model.add(Dropout(0.2)) model.add(Conv2D( 64 , [3,3], activation='relu',padding='same')) model.add(Dropout(0.2)) #model.add(Conv2D( 16 , [3,3], activation='relu',padding='same')) #model.add(Dropout(0.2)) #model.add(Conv2D( 16 , [3,3], activation='relu',padding='same')) #model.add(Dropout(0.2)) #model.add(Conv2D( 16 , [3,3], activation='relu',padding='same')) #model.add(Conv2D(64, (3, 3), activation='relu',padding='same')) #model.add(Conv2D(64, (3, 3), activation='relu',padding='same')) #model.add(Conv2D(64, (3, 3), activation='relu',padding='same')) model.add(Conv2D(1, kernel_size=1, padding='same', activation='sigmoid')) return(model)
def first_2d_block(tensor_input,filters,kernel_size=3,pooling_size=1,dropout=0.5): k1,k2 = filters out = Conv2D(k1,1,padding='same',data_format='channels_last')(tensor_input) out = BatchNormalization()(out) out = Activation('relu')(out) out = Dropout(dropout)(out) out = Conv2D(k2,kernel_size,padding='same',data_format='channels_last')(out) pooling = MaxPooling2D(pooling_size,padding='same',data_format='channels_last')(tensor_input) # out = merge([out,pooling],mode='sum') out = add([out,pooling]) return out
def repeated_2d_block(x,filters,kernel_size=3,pooling_size=1,dropout=0.5): k1,k2 = filters out = BatchNormalization()(x) out = Activation('relu')(out) out = Conv2D(k1,kernel_size,padding='same',data_format='channels_last')(out) out = BatchNormalization()(out) out = Activation('relu')(out) out = Dropout(dropout)(out) out = Conv2D(k2,kernel_size,padding='same',data_format='channels_last')(out) pooling = MaxPooling2D(pooling_size,padding='same',data_format='channels_last')(x) out = add([out, pooling]) #out = merge([out,pooling]) return out
def first_2d_block(tensor_input,filters,kernel_size=3,pooling_size=2,dropout=0.5): k1,k2 = filters out = Conv2D(k1,1,padding='same',data_format='channels_last')(tensor_input) out = BatchNormalization()(out) out = Activation('relu')(out) out = Dropout(dropout)(out) out = Conv2D(k2,kernel_size,2,padding='same',data_format='channels_last')(out) pooling = MaxPooling2D(pooling_size,padding='same',data_format='channels_last')(tensor_input) # out = merge([out,pooling],mode='sum') out = add([out,pooling]) return out
def repeated_2d_block(x,filters,kernel_size=3,pooling_size=1,dropout=0.5): k1,k2 = filters out = BatchNormalization()(x) out = Activation('relu')(out) out = Conv2D(k1,kernel_size,2,padding='same',data_format='channels_last')(out) out = BatchNormalization()(out) out = Activation('relu')(out) out = Dropout(dropout)(out) out = Conv2D(k2,kernel_size,2,padding='same',data_format='channels_last')(out) pooling = MaxPooling2D(pooling_size,padding='same',data_format='channels_last')(x) out = add([out, pooling]) #out = merge([out,pooling]) return out
def build_generator(self): model = Sequential() model.add(Dense(1024, activation='relu', input_dim=self.latent_dim)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(128 * 7 * 7, activation="relu")) model.add(BatchNormalization(momentum=0.8)) model.add(Reshape((7, 7, 128))) model.add(UpSampling2D()) model.add(Conv2D(64, kernel_size=4, padding="same")) model.add(Activation("relu")) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling2D()) model.add(Conv2D(self.channels, kernel_size=4, padding='same')) model.add(Activation("tanh")) model.summary() gen_input = Input(shape=(self.latent_dim,)) img = model(gen_input) return Model(gen_input, img)
def build_generator(self): model = Sequential() model.add(Dense(128 * 7 * 7, activation="relu", input_dim=100)) model.add(Reshape((7, 7, 128))) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling2D()) model.add(Conv2D(128, kernel_size=3, padding="same")) model.add(Activation("relu")) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling2D()) model.add(Conv2D(64, kernel_size=3, padding="same")) model.add(Activation("relu")) model.add(BatchNormalization(momentum=0.8)) model.add(Conv2D(1, kernel_size=3, padding="same")) model.add(Activation("tanh")) model.summary() noise = Input(shape=(100,)) img = model(noise) return Model(noise, img)
def set_cnn_model(ninstance=4, input_dim = 4, input_length = 107): nbfilter = 16 model = Sequential() # #seqs * seqlen * 4 #model.add(brnn) model.add(Conv2D(input_shape=(ninstance, input_length, input_dim), filters=nbfilter, kernel_size=(1,10), padding="valid", #activation="relu", strides=1)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(1,3))) # 32 16 # model.add(Dropout(0.25)) # will be better model.add(Conv2D(filters=nbfilter*2, kernel_size=(1,32), padding='valid', activation='relu', strides=1)) # model.add(Flatten()) #model.add(Softmax4D(axis=1)) #model.add(MaxPooling1D(pool_length=3)) #model.add(Flatten()) #model.add(Recalc(axis=1)) # model.add(Flatten()) # model.add(Dense(nbfilter*2, activation='relu')) model.add(Dropout(0.25)) model.add(Conv2D(filters=1, kernel_size=(1,1), padding='valid', activation='sigmoid', strides=1)) return model
def discriminator_model(): model = Sequential() model.add( Conv2D(64, (5, 5), padding='same', input_shape=(28, 28, 1)) ) model.add(Activation('tanh')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(128, (5, 5))) model.add(Activation('tanh')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(1024)) model.add(Activation('tanh')) model.add(Dense(1)) model.add(Activation('sigmoid')) return model
def create_model(img_height,img_width,img_channel): ip = Input(shape=(img_height, img_width,img_channel)) L1 = Conv2D(32, (11, 11), padding='same', activation='relu', kernel_initializer='glorot_uniform')(ip) L2 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L1) L3 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L2) L4 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L3) L4=concatenate([L4,L1],axis=-1)#Attention!.maybe this connection will influence the result,which means it can be moved. L5 = Conv2D(64, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L4) L6 = Conv2D(64, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L5) L6=concatenate([L6,L1],axis=-1)#Attention!.maybe this connection will influence the result,which means it can be moved. L7 = Conv2D(128, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L6) L8 = Conv2D(img_channel, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L7) deblocking =Model(inputs=ip,outputs= L8) optimizer = optimizers.Adam(lr=1e-4) deblocking.compile(optimizer=optimizer,loss='mean_squared_error', metrics=[psnr,ssim]) return deblocking
def create_model(img_height,img_width,img_channel): ip = Input(shape=(img_height, img_width,img_channel)) L_1 = Conv2D(64, (9, 9), padding='same', activation='linear', kernel_initializer='glorot_uniform')(ip) L_1 = LeakyReLU(alpha=0.25)(L_1) L_2=L_1 for i in range(3): L_2 = residual_block(L_2, 64,3) L_3 = Conv2D(64, (3, 3), padding='same',kernel_initializer='glorot_uniform')(L_2) L_3 = BatchNormalization(axis=-1)(L_3) L_3 = add([L_1,L_3]) L_4= Conv2D(128, (1, 1), padding='same',kernel_initializer='glorot_uniform')(L_3) op = Conv2D(img_channel, (9, 9),padding='same', activation='tanh', kernel_initializer='glorot_uniform')(L_4) deblocking =Model(inputs=ip,outputs= op) optimizer = optimizers.Adam(lr=1e-4) deblocking.compile(optimizer=optimizer,loss='mean_squared_error', metrics=[psnr,ssim]) return deblocking
def create_model(img_height,img_width,img_channel): ip = Input(shape=(img_height, img_width,img_channel)) x_1 = Conv2D(64, (9, 9), padding='same', activation='linear', kernel_initializer='glorot_uniform')(ip) x_1 = LeakyReLU(alpha=0.25)(x_1) x=x_1 for i in range(5):#or 15 x = residual_block(x, 64,3) x = Conv2D(64, (3, 3), padding='same',kernel_initializer='glorot_uniform')(x) x = BatchNormalization(axis=-1)(x) x = add([x_1,x]) x=upscale(x) op = Conv2D(img_channel, (9, 9),padding='same', activation='tanh', kernel_initializer='glorot_uniform')(x) deblocking =Model(inputs=ip,outputs= op) optimizer = optimizers.Adam(lr=1e-4) deblocking.compile(optimizer=optimizer,loss='mean_squared_error', metrics=[psnr,ssim]) return deblocking
def create_model(img_height,img_width,img_channel): ip = Input(shape=(img_height, img_width,img_channel)) L1 = Conv2D(32, (11, 11), padding='same', activation='relu', kernel_initializer='glorot_uniform')(ip) L2 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L1) L3 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L2) L4 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L3) L4=concatenate([L4,L1],axis=-1) L5 = Conv2D(64, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L4) L6 = Conv2D(64, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L5) L6=concatenate([L6,L1],axis=-1) L7 = Conv2D(128, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L6) L8 = Conv2D(img_channel, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L7) deblocking =Model(inputs=ip,outputs= L8) optimizer = optimizers.Adam(lr=1e-4) deblocking.compile(optimizer=optimizer,loss='mean_squared_error', metrics=[psnr,ssim]) return deblocking
def create_model(img_height,img_width,img_channel): ip = Input(shape=(img_height, img_width,img_channel)) x = Conv2D(64, (9, 9), padding='same', activation='linear', kernel_initializer='glorot_uniform')(ip) x = BatchNormalization(axis= -1)(x) x = LeakyReLU(alpha=0.25)(x) for i in range(5): x = residual_block(x, 64,3) x = Conv2D(64, (3, 3), padding='same',kernel_initializer='glorot_uniform')(x) x = BatchNormalization(axis=-1)(x) x=Conv2D(64,(3, 3),padding='same',activation='relu')(x) op=Conv2D(img_channel,(9,9),padding='same',activation='tanh',kernel_initializer='glorot_uniform')(x) deblocking =Model(inputs=ip,outputs= op) optimizer = optimizers.Adam(lr=1e-4) deblocking.compile(optimizer=optimizer,loss='mean_squared_error', metrics=[psnr,ssim]) return deblocking #plot_model(deblocking, to_file='model.png', show_shapes=True, show_layer_names=True)
def make_network(): model = Sequential() model.add(Conv2D(32, (3, 3), padding='same', input_shape=(128, 128, 3))) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(1)) # model.add(Activation('tanh')) return model
def __transition_block(ip, nb_filter, compression=1.0, weight_decay=1e-4): ''' Apply BatchNorm, Relu 1x1, Conv2D, optional compression, dropout and Maxpooling2D Args: ip: keras tensor nb_filter: number of filters compression: calculated as 1 - reduction. Reduces the number of feature maps in the transition block. dropout_rate: dropout rate weight_decay: weight decay factor Returns: keras tensor, after applying batch_norm, relu-conv, dropout, maxpool ''' concat_axis = 1 if K.image_data_format() == 'channels_first' else -1 x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(ip) x = Activation('relu')(x) x = Conv2D(int(nb_filter * compression), (1, 1), kernel_initializer='he_normal', padding='same', use_bias=False, kernel_regularizer=l2(weight_decay))(x) x = AveragePooling2D((2, 2), strides=(2, 2))(x) return x
def __initial_conv_block_imagenet(input, weight_decay=5e-4): ''' Adds an initial conv block, with batch norm and relu for the inception resnext Args: input: input tensor weight_decay: weight decay factor Returns: a keras tensor ''' channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 x = Conv2D(64, (7, 7), padding='same', use_bias=False, kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay), strides=(2, 2))(input) x = BatchNormalization(axis=channel_axis)(x) x = LeakyReLU()(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) return x
def make_network(): model = Sequential() model.add(Conv2D(32, (3, 3), padding='same', input_shape=(128, 128, 3))) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(11)) model.add(Activation('softmax')) return model
def ConvBN2(x, num_filter, stride_size=3): x = Conv2D(num_filter, (stride_size, stride_size), padding='same', kernel_initializer='he_uniform')(x) x = BatchNormalization()(x) x = Activation('selu')(x) x = Conv2D(num_filter, (stride_size, stride_size), padding='same', kernel_initializer='he_uniform')(x) x = BatchNormalization()(x) x = Activation('selu')(x) return x
def _bn_relu_conv(filters, kernel_size = (3, 3), strides = (1, 1)): def f(inputs): x = BatchNormalization()(inputs) x = Activation('relu')(x) x = Conv2D(filters, kernel_size, strides = strides, kernel_initializer = init, padding = 'same')(x) return x return f
def build(input_shape, num_outputs, block_fn, repetitions): inputs = Input(shape = input_shape) conv1 = Conv2D(64, (7, 7), strides = (2, 2), padding = 'same')(inputs) conv1 = BatchNormalization()(conv1) conv1 = Activation('relu')(conv1) pool1 = MaxPooling2D(pool_size = (3, 3), strides = (2, 2), padding = 'same')(conv1) x = pool1 filters = 64 first_layer = True for i, r in enumerate(repetitions): x = _residual_block(block_fn, filters = filters, repetitions = r, is_first_layer = first_layer)(x) filters *= 2 if first_layer: first_layer = False # last activation <- unnecessary??? # x = BatchNormalization()(x) # x = Activation('relu')(x) _, w, h, ch = K.int_shape(x) pool2 = AveragePooling2D(pool_size = (w, h), strides = (1, 1))(x) flat1 = Flatten()(pool2) outputs = Dense(num_outputs, kernel_initializer = init, activation = 'softmax')(flat1) model = Model(inputs = inputs, outputs = outputs) return model
def Discriminator(image_size = 64): L = int(image_size) images = Input(shape = (L, L, 3)) x = Conv2D(64, (4, 4), strides = (2, 2), kernel_initializer = init, padding = 'same')(images) # shape(L/2, L/2, 32) x = LeakyReLU(0.2)(x) x = Conv2D(128, (4, 4), strides = (2, 2), kernel_initializer = init, padding = 'same')(x) # shape(L/4, L/4, 64) x = BatchNormalization()(x) x = LeakyReLU(0.2)(x) x = Conv2D(256, (4, 4), strides = (2, 2), kernel_initializer = init, padding = 'same')(x) # shape(L/8, L/8, 128) x = BatchNormalization()(x) x = LeakyReLU(0.2)(x) x = Conv2D(512, (4, 4), strides = (2, 2), kernel_initializer = init, padding = 'same')(x) # shape(L/16, L/16, 256) x = BatchNormalization()(x) x = LeakyReLU(0.2)(x) x = Flatten()(x) outputs = Dense(1)(x) model = Model(inputs = images, outputs = outputs) model.summary() return model
def bottleneck(encoder, output, upsample=False, reverse_module=False): internal = output // 4 x = Conv2D(internal, (1, 1), use_bias=False)(encoder) x = BatchNormalization(momentum=0.1)(x) x = Activation('relu')(x) if not upsample: x = Conv2D(internal, (3, 3), padding='same', use_bias=True)(x) else: x = Conv2DTranspose(filters=internal, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) x = BatchNormalization(momentum=0.1)(x) x = Activation('relu')(x) x = Conv2D(output, (1, 1), padding='same', use_bias=False)(x) other = encoder if encoder.get_shape()[-1] != output or upsample: other = Conv2D(output, (1, 1), padding='same', use_bias=False)(other) other = BatchNormalization(momentum=0.1)(other) if upsample and reverse_module is not False: other = UpSampling2D(size=(2, 2))(other) if upsample and reverse_module is False: decoder = x else: x = BatchNormalization(momentum=0.1)(x) decoder = add([x, other]) decoder = Activation('relu')(decoder) return decoder
def initial_block(inp, nb_filter=13, nb_row=3, nb_col=3, strides=(2, 2)): conv = Conv2D(nb_filter, (nb_row, nb_col), padding='same', strides=strides)(inp) max_pool = MaxPooling2D()(inp) merged = concatenate([conv, max_pool], axis=3) return merged
def bottleneck(encoder, output, upsample=False, reverse_module=False): internal = output // 4 x = Conv2D(internal, (1, 1), use_bias=False)(encoder) x = BatchNormalization(momentum=0.1)(x) # x = Activation('relu')(x) x = PReLU(shared_axes=[1, 2])(x) if not upsample: x = Conv2D(internal, (3, 3), padding='same', use_bias=True)(x) else: x = Conv2DTranspose(filters=internal, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) x = BatchNormalization(momentum=0.1)(x) # x = Activation('relu')(x) x = PReLU(shared_axes=[1, 2])(x) x = Conv2D(output, (1, 1), padding='same', use_bias=False)(x) other = encoder if encoder.get_shape()[-1] != output or upsample: other = Conv2D(output, (1, 1), padding='same', use_bias=False)(other) other = BatchNormalization(momentum=0.1)(other) if upsample and reverse_module is not False: other = MaxUnpooling2D()([other, reverse_module]) if upsample and reverse_module is False: decoder = x else: x = BatchNormalization(momentum=0.1)(x) decoder = add([x, other]) # decoder = Activation('relu')(decoder) decoder = PReLU(shared_axes=[1, 2])(decoder) return decoder
def initial_block(inp, nb_filter=13, nb_row=3, nb_col=3, strides=(2, 2)): conv = Conv2D(nb_filter, (nb_row, nb_col), padding='same', strides=strides)(inp) max_pool, indices = MaxPoolingWithArgmax2D()(inp) merged = concatenate([conv, max_pool], axis=3) return merged, indices
def build(inp, encoder, nc, valid_shapes): side = conv_block_side(inp) x = Lambda( interp, arguments={'shape': valid_shapes[3]}, name='sub24_sum_interp')(encoder) main = ConvBN( filters=128, kernel_size=3, dilation_rate=2, padding='same', name='conv_sub2')(x) x = Add(name='sub12_sum')([main, side]) x = Activation('relu')(x) x = Lambda( interp, arguments={'shape': valid_shapes[2]}, name='sub12_sum_interp')(x) x = Conv2D( filters=nc, kernel_size=1, name='conv6_cls')(x) out = Lambda( interp, arguments={'shape': valid_shapes[0]}, name='conv6_interp')(x) return out
def build_discriminator(): # build a relatively standard conv net, with LeakyReLUs as suggested in # the reference paper cnn = Sequential() cnn.add(Conv2D(32, 3, padding='same', strides=2, input_shape=(1, 28, 28))) cnn.add(LeakyReLU()) cnn.add(Dropout(0.3)) cnn.add(Conv2D(64, 3, padding='same', strides=1)) cnn.add(LeakyReLU()) cnn.add(Dropout(0.3)) cnn.add(Conv2D(128, 3, padding='same', strides=2)) cnn.add(LeakyReLU()) cnn.add(Dropout(0.3)) cnn.add(Conv2D(256, 3, padding='same', strides=1)) cnn.add(LeakyReLU()) cnn.add(Dropout(0.3)) cnn.add(Flatten()) image = Input(shape=(1, 28, 28)) features = cnn(image) # first output (name=generation) is whether or not the discriminator # thinks the image that is being shown is fake, and the second output # (name=auxiliary) is the class that the discriminator thinks the image # belongs to. fake = Dense(1, activation='sigmoid', name='generation')(features) aux = Dense(10, activation='softmax', name='auxiliary')(features) return Model(image, [fake, aux])
def q_function(input_shape, num_actions): image_input = Input(shape=input_shape) out = Conv2D(filters=32, kernel_size=8, strides=(4, 4), padding='valid', activation='relu')(image_input) out = Conv2D(filters=64, kernel_size=4, strides=(2, 2), padding='valid', activation='relu')(out) out = Conv2D(filters=64, kernel_size=3, strides=(1, 1), padding='valid', activation='relu')(out) out = Flatten()(out) out = Dense(512, activation='relu')(out) q_value = Dense(num_actions)(out) return image_input, q_value
def createModel(self): model = Sequential() model.add(Conv2D(16, (3, 3), strides=(2, 2), input_shape=(self.img_rows, self.img_cols, self.img_channels))) model.add(Activation('relu')) model.add(ZeroPadding2D((1, 1))) model.add(Conv2D(16, (3, 3), strides=(2, 2))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2),strides=(2, 2))) model.add(Flatten()) model.add(Dense(256)) model.add(Activation('relu')) # model.add(Dropout(0.5)) model.add(Dense(self.output_size)) # model.add(Activation('softmax')) # model.compile(RMSprop(lr=self.learningRate), 'MSE') # sgd = SGD(lr=self.learningRate) adam = Adam(lr=self.learningRate) model.compile(loss='mse', optimizer=adam) model.summary() return model
def create_model(opt_='adamax'): model = Sequential() model.add(Conv2D(4, (3, 3), activation='relu', input_shape=(SIZE, SIZE, 3))) model.add(MaxPooling2D(pool_size=(3, 3), strides=(3, 3))) model.add(Conv2D(8, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(3, 3), strides=(3, 3))) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(12, activation='tanh')) model.add(Dropout(0.1)) model.add(Dense(3, activation='softmax')) model.compile(optimizer=opt_, loss='sparse_categorical_crossentropy', metrics=['accuracy']) return model
def build_2d_main_residual_network(batch_size, width, height, channel_size, output_dim, loop_depth=15, dropout=0.3): inp = Input(shape=(width,height,channel_size)) # add mask for filter invalid data out = TimeDistributed(Masking(mask_value=0))(inp) out = Conv2D(128,5,data_format='channels_last')(out) out = BatchNormalization()(out) out = Activation('relu')(out) out = first_2d_block(out,(64,128),dropout=dropout) for _ in range(loop_depth): out = repeated_2d_block(out,(64,128),dropout=dropout) # add flatten out = Flatten()(out) out = BatchNormalization()(out) out = Activation('relu')(out) out = Dense(output_dim)(out) model = Model(inp,out) model.compile(loss='mse',optimizer='adam',metrics=['mse','mae']) return model
def __call__(self): model = Sequential() model.add(Reshape((28, 28, 1), input_shape=(784,))) # Convolution Layer 1 model.add(Conv2D(64, kernel_size=(4, 4), strides=(2, 2), \ kernel_initializer=self.initializer)) model.add(LeakyReLU()) # Convolution Layer 2 model.add(Conv2D(128, kernel_size=(4, 4), strides=(2, 2), \ kernel_initializer=self.initializer)) model.add(LeakyReLU()) # Batch Normalization model.add(BatchNormalization()) # Flatten the input model.add(Flatten()) # Dense Layer model.add(Dense(1024, kernel_initializer=self.initializer)) model.add(LeakyReLU()) # Batch Normalization model.add(BatchNormalization()) # To the output that has two classes model.add(Dense(2, activation='softmax')) return model
def cnn_model(): model = Sequential() # A Convolution2D sera a nossa camada de entrada. Podemos observar que ela possui # 32 mapas de features com tamanho de 5 × 5 e 'relu' como funcao de ativacao. model.add(Conv2D(32, (5, 5), input_shape=(1, 28, 28), activation='relu')) # A camada MaxPooling2D sera nossa segunda camada onde teremos um amostragem de # dimensoes 2 × 2. model.add(MaxPooling2D(pool_size=(2, 2))) # Durante a regularizacao usamos o metodo de Dropout # excluindo 30% dos neuronios na camada, diminuindo nossa chance de overfitting. model.add(Dropout(0.3)) # Usamos a Flatten para converter nossa matriz 2D # numa representacao a ser processada pela fully connected. model.add(Flatten()) # Camada fully connected com 128 neuronios e funcao de ativacao 'relu'. model.add(Dense(128, activation='relu')) # Nossa camada de saida possui o numero de neuronios compativel com o # numero de classes a serem classificadas, com uma funcao de ativacao # do tipo 'softmax'. model.add(Dense(num_classes, activation='softmax', name='preds')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def deeper_cnn_model(): model = Sequential() # A Convolution2D sera a nossa camada de entrada. Podemos observar que ela possui # 30 mapas de features com tamanho de 5 × 5 e 'relu' como funcao de ativacao. model.add(Conv2D(30, (5, 5), input_shape=(1, 28, 28), activation='relu')) # A camada MaxPooling2D sera nossa segunda camada onde teremos um amostragem de # dimensoes 2 × 2. model.add(MaxPooling2D(pool_size=(2, 2))) # Uma nova camada convolucional com 15 mapas de features com dimensoes de 3 × 3 # e 'relu' como funcao de ativacao. model.add(Conv2D(15, (3, 3), activation='relu')) # Uma nova subamostragem com um pooling de dimensoes 2 x 2. model.add(MaxPooling2D(pool_size=(2, 2))) # Dropout com probabilidade de 20% model.add(Dropout(0.2)) # Flatten preparando os dados para a camada fully connected. model.add(Flatten()) # Camada fully connected de 128 neuronios. model.add(Dense(128, activation='relu')) # Seguida de uma nova camada fully connected de 64 neuronios model.add(Dense(64, activation='relu')) # A camada de saida possui o numero de neuronios compativel com o # numero de classes a serem classificadas, com uma funcao de ativacao # do tipo 'softmax'. model.add(Dense(num_classes, activation='softmax', name='preds')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def build_generator(self): noise_shape = (100,) model = Sequential() model.add(Dense(128 * 7 * 7, activation="relu", input_shape=noise_shape)) model.add(Reshape((7, 7, 128))) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling2D()) model.add(Conv2D(128, kernel_size=4, padding="same")) model.add(Activation("relu")) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling2D()) model.add(Conv2D(64, kernel_size=4, padding="same")) model.add(Activation("relu")) model.add(BatchNormalization(momentum=0.8)) model.add(Conv2D(1, kernel_size=4, padding="same")) model.add(Activation("tanh")) model.summary() noise = Input(shape=noise_shape) img = model(noise) return Model(noise, img)
