Python keras.layers.MaxPooling2D() Examples
The following are 30
code examples of keras.layers.MaxPooling2D().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
keras.layers
, or try the search function
.
.
Example #1
| Source File: model.py From ocsvm-anomaly-detection with MIT License | 8 votes |
|
def build_cae_model(height=32, width=32, channel=3):
"""
build convolutional autoencoder model
"""
input_img = Input(shape=(height, width, channel))
# encoder
net = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img)
net = MaxPooling2D((2, 2), padding='same')(net)
net = Conv2D(8, (3, 3), activation='relu', padding='same')(net)
net = MaxPooling2D((2, 2), padding='same')(net)
net = Conv2D(4, (3, 3), activation='relu', padding='same')(net)
encoded = MaxPooling2D((2, 2), padding='same', name='enc')(net)
# decoder
net = Conv2D(4, (3, 3), activation='relu', padding='same')(encoded)
net = UpSampling2D((2, 2))(net)
net = Conv2D(8, (3, 3), activation='relu', padding='same')(net)
net = UpSampling2D((2, 2))(net)
net = Conv2D(16, (3, 3), activation='relu', padding='same')(net)
net = UpSampling2D((2, 2))(net)
decoded = Conv2D(channel, (3, 3), activation='sigmoid', padding='same')(net)
return Model(input_img, decoded)
Example #2
| Source File: mymodel.py From AI_for_Wechat_tiaoyitiao with GNU General Public License v3.0 | 7 votes |
|
def get_model():
model = models.Sequential()
model.add(layers.Conv2D(16,(3,3),activation='relu',input_shape=(135,240,3),padding = 'same'))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Conv2D(32,(3,3),activation='relu',padding = 'same'))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Conv2D(64,(3,3),activation='relu',padding = 'same'))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Conv2D(64,(3,3),activation='relu',padding = 'same'))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Conv2D(128,(3,3),activation='relu',padding = 'same'))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(128,activation="relu"))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(27,activation="softmax"))
return model
#model.summary()
#plot_model(model, to_file='model.png')
Example #3
| Source File: cnn_main.py From Convolutional-Networks-for-Stock-Predicting with MIT License | 6 votes |
|
def create_model():
model = Sequential()
model.add(Convolution2D(32, 3, 3,
border_mode='valid',
input_shape=(100, 100, 3)))
model.add(Activation('relu'))
model.add(Convolution2D(32, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Convolution2D(64, 3, 3,
border_mode='valid'))
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(2))
model.add(Activation('softmax'))
return model
Example #4
| Source File: dual_path_network.py From Keras-DualPathNetworks with Apache License 2.0 | 6 votes |
|
def _initial_conv_block_inception(input, initial_conv_filters, weight_decay=5e-4):
''' Adds an initial conv block, with batch norm and relu for the DPN
Args:
input: input tensor
initial_conv_filters: number of filters for initial conv block
weight_decay: weight decay factor
Returns: a keras tensor
'''
channel_axis = 1 if K.image_data_format() == 'channels_first' else -1
x = Conv2D(initial_conv_filters, (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 = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
return x
Example #5
| Source File: parallel_model.py From dataiku-contrib with Apache License 2.0 | 6 votes |
|
def build_model(x_train, num_classes):
# Reset default graph. Keras leaves old ops in the graph,
# which are ignored for execution but clutter graph
# visualization in TensorBoard.
tf.reset_default_graph()
inputs = KL.Input(shape=x_train.shape[1:], name="input_image")
x = KL.Conv2D(32, (3, 3), activation='relu', padding="same",
name="conv1")(inputs)
x = KL.Conv2D(64, (3, 3), activation='relu', padding="same",
name="conv2")(x)
x = KL.MaxPooling2D(pool_size=(2, 2), name="pool1")(x)
x = KL.Flatten(name="flat1")(x)
x = KL.Dense(128, activation='relu', name="dense1")(x)
x = KL.Dense(num_classes, activation='softmax', name="dense2")(x)
return KM.Model(inputs, x, "digit_classifier_model")
# Load MNIST Data
Example #6
| Source File: keras_ops.py From deep_architect with MIT License | 6 votes |
|
def max_pool2d(h_kernel_size, h_stride):
def compile_fn(di, dh):
layer = layers.MaxPooling2D(pool_size=dh['kernel_size'],
strides=(dh['stride'], dh['stride']),
padding='same')
def fn(di):
return {'out': layer(di['in'])}
return fn
return siso_keras_module('MaxPool2D', compile_fn, {
'kernel_size': h_kernel_size,
'stride': h_stride,
})
Example #7
| Source File: mnist.py From blackbox-attacks with MIT License | 6 votes |
|
def modelF():
model = Sequential()
model.add(Convolution2D(32, 3, 3,
border_mode='valid',
input_shape=(FLAGS.IMAGE_ROWS,
FLAGS.IMAGE_COLS,
FLAGS.NUM_CHANNELS)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(64, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(1024))
model.add(Activation('relu'))
model.add(Dense(FLAGS.NUM_CLASSES))
return model
Example #8
| Source File: model.py From n2n-watermark-remove with MIT License | 6 votes |
|
def get_unet_model(input_channel_num=3, out_ch=3, start_ch=64, depth=4, inc_rate=2., activation='relu',
dropout=0.5, batchnorm=False, maxpool=True, upconv=True, residual=False):
def _conv_block(m, dim, acti, bn, res, do=0):
n = Conv2D(dim, 3, activation=acti, padding='same')(m)
n = BatchNormalization()(n) if bn else n
n = Dropout(do)(n) if do else n
n = Conv2D(dim, 3, activation=acti, padding='same')(n)
n = BatchNormalization()(n) if bn else n
return Concatenate()([m, n]) if res else n
def _level_block(m, dim, depth, inc, acti, do, bn, mp, up, res):
if depth > 0:
n = _conv_block(m, dim, acti, bn, res)
m = MaxPooling2D()(n) if mp else Conv2D(dim, 3, strides=2, padding='same')(n)
m = _level_block(m, int(inc * dim), depth - 1, inc, acti, do, bn, mp, up, res)
if up:
m = UpSampling2D()(m)
m = Conv2D(dim, 2, activation=acti, padding='same')(m)
else:
m = Conv2DTranspose(dim, 3, strides=2, activation=acti, padding='same')(m)
n = Concatenate()([n, m])
m = _conv_block(n, dim, acti, bn, res)
else:
m = _conv_block(m, dim, acti, bn, res, do)
return m
i = Input(shape=(None, None, input_channel_num))
o = _level_block(i, start_ch, depth, inc_rate, activation, dropout, batchnorm, maxpool, upconv, residual)
o = Conv2D(out_ch, 1)(o)
model = Model(inputs=i, outputs=o)
return model
Example #9
| Source File: train_basic_models.py From face_landmark_dnn with MIT License | 5 votes |
|
def facial_landmark_cnn(input_shape=INPUT_SHAPE, output_size=OUTPUT_SIZE):
# Stage 1 #
img_input = Input(shape=input_shape)
## Block 1 ##
x = Conv2D(32, (3,3), strides=(1,1), name='S1_conv1')(img_input)
x = BatchNormalization()(x)
x = Activation('relu', name='S1_relu_conv1')(x)
x = MaxPooling2D(pool_size=(2,2), strides=(2,2), name='S1_pool1')(x)
## Block 2 ##
x = Conv2D(64, (3,3), strides=(1,1), name='S1_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu', name='S1_relu_conv2')(x)
x = Conv2D(64, (3,3), strides=(1,1), name='S1_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu', name='S1_relu_conv3')(x)
x = MaxPooling2D(pool_size=(2,2), strides=(2,2), name='S1_pool2')(x)
## Block 3 ##
x = Conv2D(64, (3,3), strides=(1,1), name='S1_conv4')(x)
x = BatchNormalization()(x)
x = Activation('relu', name='S1_relu_conv4')(x)
x = Conv2D(64, (3,3), strides=(1,1), name='S1_conv5')(x)
x = BatchNormalization()(x)
x = Activation('relu', name='S1_relu_conv5')(x)
x = MaxPooling2D(pool_size=(2,2), strides=(2,2), name='S1_pool3')(x)
## Block 4 ##
x = Conv2D(256, (3,3), strides=(1,1), name='S1_conv8')(x)
x = BatchNormalization()(x)
x = Activation('relu', name='S1_relu_conv8')(x)
x = Dropout(0.2)(x)
## Block 5 ##
x = Flatten(name='S1_flatten')(x)
x = Dense(2048, activation='relu', name='S1_fc1')(x)
x = Dense(output_size, activation=None, name='S1_predictions')(x)
model = Model([img_input], x, name='facial_landmark_model')
return model
Example #10
| Source File: image_train.py From recognition_gender with MIT License | 5 votes |
|
def build_model(self,dataset):
self.model = Sequential()
#进行一层卷积 输出 shape (32,128,128)
self.model.add(Convolution2D(filters=32,kernel_size=5,strides=1, padding='same',data_format='channels_first', input_shape=dataset.X_train.shape[1:]))
#使用relu激励函数
self.model.add(Activation('relu'))
#池化，输出为shape (32,64,64)
self.model.add(MaxPooling2D(pool_size=2,strides=2,padding='same',data_format='channels_first'))
#dropout 防止过拟合
self.model.add(Dropout(0.25))
#进行一层卷积 输出为shape (64,32,32)
self.model.add(Convolution2D(64, 5, strides=1, padding='same', data_format='channels_first'))
# 使用relu激励函数
self.model.add(Activation('relu'))
# 池化，输出为原来的一半 shape (64,32,32)
self.model.add(MaxPooling2D(2, 2, 'same', data_format='channels_first'))
# dropout 防止过拟合
self.model.add(Dropout(0.25))
#全连接层
self.model.add(Flatten())
self.model.add(Dense(512))
self.model.add(Activation('relu'))
self.model.add(Dropout(0.5))
self.model.add(Dense(dataset.nb_classes))
self.model.add(Activation('softmax'))
self.model.summary()
Example #11
| Source File: get_model.py From Dog-Cat-Classifier with Apache License 2.0 | 5 votes |
|
def get_model(num_classes=2):
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(64, 64, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy'])
return model
Example #12
| Source File: train.py From DeepAA with MIT License | 5 votes |
|
def CNN(input_shape=None, classes=1000):
inputs = Input(shape=input_shape)
# Block 1
x = GaussianNoise(0.3)(inputs)
x = CBRD(x, 64)
x = CBRD(x, 64)
x = MaxPooling2D()(x)
# Block 2
x = CBRD(x, 128)
x = CBRD(x, 128)
x = MaxPooling2D()(x)
# Block 3
x = CBRD(x, 256)
x = CBRD(x, 256)
x = CBRD(x, 256)
x = MaxPooling2D()(x)
# Classification block
x = Flatten(name='flatten')(x)
x = DBRD(x, 4096)
x = DBRD(x, 4096)
x = Dense(classes, activation='softmax', name='predictions')(x)
model = Model(inputs=inputs, outputs=x)
return model
Example #13
| Source File: networks.py From posewarp-cvpr2018 with MIT License | 5 votes |
|
def discriminator(param):
img_h = param['IMG_HEIGHT']
img_w = param['IMG_WIDTH']
n_joints = param['n_joints']
pose_dn = param['posemap_downsample']
x_tgt = Input(shape=(img_h, img_w, 3))
x_src_pose = Input(shape=(img_h / pose_dn, img_w / pose_dn, n_joints))
x_tgt_pose = Input(shape=(img_h / pose_dn, img_w / pose_dn, n_joints))
x = my_conv(x_tgt, 64, ks=5)
x = MaxPooling2D()(x) # 128
x = concatenate([x, x_src_pose, x_tgt_pose])
x = my_conv(x, 128, ks=5)
x = MaxPooling2D()(x) # 64
x = my_conv(x, 256)
x = MaxPooling2D()(x) # 32
x = my_conv(x, 256)
x = MaxPooling2D()(x) # 16
x = my_conv(x, 256)
x = MaxPooling2D()(x) # 8
x = my_conv(x, 256) # 8
x = Flatten()(x)
x = Dense(256, activation='relu')(x)
x = Dense(256, activation='relu')(x)
y = Dense(1, activation='sigmoid')(x)
model = Model(inputs=[x_tgt, x_src_pose, x_tgt_pose], outputs=y, name='discriminator')
return model
Example #14
| Source File: model.py From segmentation-unet-maskrcnn with MIT License | 5 votes |
|
def resnet_graph(input_image, architecture, stage5=False):
assert architecture in ["resnet50", "resnet101"]
# Stage 1
x = KL.ZeroPadding2D((3, 3))(input_image)
x = KL.Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=True)(x)
x = BatchNorm(axis=3, name='bn_conv1')(x)
x = KL.Activation('relu')(x)
C1 = x = KL.MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x)
# Stage 2
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')
C2 = x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
# Stage 3
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')
C3 = x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
# Stage 4
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
block_count = {"resnet50": 5, "resnet101": 22}[architecture]
for i in range(block_count):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block=chr(98 + i))
C4 = x
# Stage 5
if stage5:
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
C5 = x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
else:
C5 = None
return [C1, C2, C3, C4, C5]
############################################################
# Proposal Layer
############################################################
Example #15
| Source File: setup_mnist.py From adversarial_genattack with MIT License | 5 votes |
|
def __init__(self, restore = None, session=None, use_log=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Conv2D(32, (3, 3),
input_shape=(28, 28, 1)))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(200))
model.add(Activation('relu'))
model.add(Dense(200))
model.add(Activation('relu'))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
self.model = model
Example #16
| Source File: train_detection.py From WannaPark with GNU General Public License v3.0 | 5 votes |
|
def VGG_16():
'''Model definition'''
model = Sequential()
model.add(Conv2D(64, (11, 11,), padding='valid', strides=(4,4), input_shape=(img_height,img_width,num_channels), name='conv1'))
model.add(Activation('relu', name='relu1'))
model.add(LocalResponseNormalization(name='norm1'))
model.add(MaxPooling2D((2,2), padding='same', name='pool1'))
model.add(Conv2D(256, (5,5), padding='same', name='conv2'))
model.add(Activation('relu', name='relu2'))
model.add(LocalResponseNormalization(name='norm2'))
model.add(MaxPooling2D((2,2), padding='same', name='pool2'))
model.add(Conv2D(256, (3, 3), padding='same', name='conv3'))
model.add(Activation('relu', name='relu3'))
model.add(Conv2D(256, (3, 3), padding='same', name='conv4'))
model.add(Activation('relu', name='relu4'))
model.add(Conv2D(256, (3, 3), padding='same', name='conv5'))
model.add(Activation('relu', name='relu5'))
model.add(MaxPooling2D((2,2), padding='same', name='pool5'))
return model
Example #17
| Source File: setup_cifar.py From adversarial_genattack with MIT License | 5 votes |
|
def __init__(self, restore=None, session=None, use_log=False):
self.num_channels = 3
self.image_size = 32
self.num_labels = 10
model = Sequential()
model.add(Conv2D(64, (3, 3),
input_shape=(32, 32, 3)))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(128, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dense(10))
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
self.model = model
Example #18
| Source File: discriminator.py From Generative-Adversarial-Networks-Cookbook with MIT License | 5 votes |
|
def model(self):
input_layer = Input(shape=self.SHAPE)
x = Convolution2D(96,3,3, subsample=(2,2), border_mode='same',activation='relu')(input_layer)
x = Convolution2D(64,3,3, subsample=(2,2), border_mode='same',activation='relu')(x)
x = MaxPooling2D(pool_size=(3,3),border_mode='same')(x)
x = Convolution2D(32,3,3, subsample=(1,1), border_mode='same',activation='relu')(x)
x = Convolution2D(32,1,1, subsample=(1,1), border_mode='same',activation='relu')(x)
x = Convolution2D(2,1,1, subsample=(1,1), border_mode='same',activation='relu')(x)
output_layer = Reshape((-1,2))(x)
return Model(input_layer,output_layer)
Example #19
| Source File: FEC.py From FECNet with MIT License | 5 votes |
|
def inception_module(x,params,concat_axis,padding='same',data_format=DATA_FORMAT,dilation_rate=(1,1),activation='relu',use_bias=True,kernel_initializer='glorot_uniform',bias_initializer='zeros',kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,weight_decay=None):
(branch1,branch2,branch3,branch4)=params
if weight_decay:
kernel_regularizer=regularizers.l2(weight_decay)
bias_regularizer=regularizers.l2(weight_decay)
else:
kernel_regularizer=None
bias_regularizer=None
#1x1
if branch1[1]>0:
pathway1=Conv2D(filters=branch1[1],kernel_size=(1,1),strides=branch1[0],padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
#1x1->3x3
pathway2=Conv2D(filters=branch2[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
pathway2=Conv2D(filters=branch2[1],kernel_size=(3,3),strides=branch1[0],padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway2)
#1x1->5x5
pathway3=Conv2D(filters=branch3[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
pathway3=Conv2D(filters=branch3[1],kernel_size=(5,5),strides=branch1[0],padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway3)
#3x3->1x1
pathway4=MaxPooling2D(pool_size=(3,3),strides=branch1[0],padding=padding,data_format=DATA_FORMAT)(x)
if branch4[0]>0:
pathway4=Conv2D(filters=branch4[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway4)
if branch1[1]>0:
return concatenate([pathway1,pathway2,pathway3,pathway4],axis=concat_axis)
else:
return concatenate([pathway2, pathway3, pathway4], axis=concat_axis)
Example #20
| Source File: test_keras.py From docker-python with Apache License 2.0 | 5 votes |
|
def test_conv2d(self):
# Generate dummy data
x_train = np.random.random((100, 100, 100, 3))
y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)
x_test = np.random.random((20, 100, 100, 3))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)
model = Sequential()
# input: 100x100 images with 3 channels -> (100, 100, 3) tensors.
# this applies 32 convolution filters of size 3x3 each.
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), activation='relu'))
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(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
# This throws if libcudnn is not properly installed with on a GPU
model.compile(loss='categorical_crossentropy', optimizer=sgd)
model.fit(x_train, y_train, batch_size=32, epochs=1)
model.evaluate(x_test, y_test, batch_size=32)
Example #21
| Source File: FECWithPretrained.py From FECNet with MIT License | 5 votes |
|
def inception_module(x,params,concat_axis,padding='same',data_format=DATA_FORMAT,dilation_rate=(1,1),activation='relu',use_bias=True,kernel_initializer='glorot_uniform',bias_initializer='zeros',kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,weight_decay=None):
(branch1,branch2,branch3,branch4)=params
if weight_decay:
kernel_regularizer=regularizers.l2(weight_decay)
bias_regularizer=regularizers.l2(weight_decay)
else:
kernel_regularizer=None
bias_regularizer=None
#1x1
if branch1[1]>0:
pathway1=Conv2D(filters=branch1[1],kernel_size=(1,1),strides=branch1[0],padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
#1x1->3x3
pathway2=Conv2D(filters=branch2[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
pathway2=Conv2D(filters=branch2[1],kernel_size=(3,3),strides=branch1[0],padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway2)
#1x1->5x5
pathway3=Conv2D(filters=branch3[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
pathway3=Conv2D(filters=branch3[1],kernel_size=(5,5),strides=branch1[0],padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway3)
#3x3->1x1
pathway4=MaxPooling2D(pool_size=(3,3),strides=branch1[0],padding=padding,data_format=DATA_FORMAT)(x)
if branch4[0]>0:
pathway4=Conv2D(filters=branch4[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,dilation_rate=dilation_rate,activation=activation,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway4)
if branch1[1]>0:
return concatenate([pathway1,pathway2,pathway3,pathway4],axis=concat_axis)
else:
return concatenate([pathway2, pathway3, pathway4], axis=concat_axis)
Example #22
| Source File: model.py From Mask-RCNN-Pedestrian-Detection with MIT License | 5 votes |
|
def resnet_graph(input_image, architecture, stage5=False, train_bn=True):
"""Build a ResNet graph.
architecture: Can be resnet50 or resnet101
stage5: Boolean. If False, stage5 of the network is not created
train_bn: Boolean. Train or freeze Batch Norm layres
"""
assert architecture in ["resnet50", "resnet101"]
# Stage 1
x = KL.ZeroPadding2D((3, 3))(input_image)
x = KL.Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=True)(x)
x = BatchNorm(name='bn_conv1')(x, training=train_bn)
x = KL.Activation('relu')(x)
C1 = x = KL.MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x)
# Stage 2
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1), train_bn=train_bn)
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b', train_bn=train_bn)
C2 = x = identity_block(x, 3, [64, 64, 256], stage=2, block='c', train_bn=train_bn)
# Stage 3
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a', train_bn=train_bn)
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b', train_bn=train_bn)
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c', train_bn=train_bn)
C3 = x = identity_block(x, 3, [128, 128, 512], stage=3, block='d', train_bn=train_bn)
# Stage 4
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a', train_bn=train_bn)
block_count = {"resnet50": 5, "resnet101": 22}[architecture]
for i in range(block_count):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block=chr(98 + i), train_bn=train_bn)
C4 = x
# Stage 5
if stage5:
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a', train_bn=train_bn)
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b', train_bn=train_bn)
C5 = x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c', train_bn=train_bn)
else:
C5 = None
return [C1, C2, C3, C4, C5]
############################################################
# Proposal Layer
############################################################
Example #23
| Source File: model.py From EasyPR-python with Apache License 2.0 | 5 votes |
|
def resnet_graph(input_image, architecture, stage5=False):
assert architecture in ["resnet50", "resnet101"]
# Stage 1
x = KL.ZeroPadding2D((3, 3))(input_image)
x = KL.Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=True)(x)
x = BatchNorm(axis=3, name='bn_conv1')(x)
x = KL.Activation('relu')(x)
C1 = x = KL.MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x)
# Stage 2
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')
C2 = x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
# Stage 3
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')
C3 = x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
# Stage 4
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
block_count = {"resnet50": 5, "resnet101": 22}[architecture]
for i in range(block_count):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block=chr(98 + i))
C4 = x
# Stage 5
if stage5:
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
C5 = x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
else:
C5 = None
return [C1, C2, C3, C4, C5]
############################################################
# Proposal Layer
############################################################
Example #24
| Source File: conv_mnist_model.py From Keras-Project-Template with Apache License 2.0 | 5 votes |
|
def build_model(self):
self.model = Sequential()
self.model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu', input_shape=(28, 28, 1)))
self.model.add(Conv2D(64, (3, 3), activation='relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Dropout(0.25))
self.model.add(Flatten())
self.model.add(Dense(128, activation='relu'))
self.model.add(Dropout(0.5))
self.model.add(Dense(10, activation='softmax'))
self.model.compile(
loss='sparse_categorical_crossentropy',
optimizer=self.config.model.optimizer,
metrics=['accuracy'])
Example #25
| Source File: AlexNet.py From convnet-drawer with MIT License | 5 votes |
|
def get_model():
model = Sequential()
model.add(Conv2D(96, kernel_size=(11, 11), strides=(4, 4), input_shape=(227, 227, 3)))
model.add(MaxPooling2D((3, 3), strides=(2, 2)))
model.add(Conv2D(256, (5, 5), padding="same"))
model.add(MaxPooling2D((3, 3), strides=(2, 2)))
model.add(Conv2D(384, (3, 3), padding="same"))
model.add(Conv2D(384, (3, 3), padding="same"))
model.add(Conv2D(256, (3, 3), padding="same"))
model.add(MaxPooling2D((3, 3), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(4096))
model.add(Dense(4096))
model.add(Dense(1000))
return model
Example #26
| Source File: parallel_model.py From Mask-RCNN-Pedestrian-Detection with MIT License | 5 votes |
|
def build_model(x_train, num_classes):
# Reset default graph. Keras leaves old ops in the graph,
# which are ignored for execution but clutter graph
# visualization in TensorBoard.
tf.reset_default_graph()
inputs = KL.Input(shape=x_train.shape[1:], name="input_image")
x = KL.Conv2D(32, (3, 3), activation='relu', padding="same",
name="conv1")(inputs)
x = KL.Conv2D(64, (3, 3), activation='relu', padding="same",
name="conv2")(x)
x = KL.MaxPooling2D(pool_size=(2, 2), name="pool1")(x)
x = KL.Flatten(name="flat1")(x)
x = KL.Dense(128, activation='relu', name="dense1")(x)
x = KL.Dense(num_classes, activation='softmax', name="dense2")(x)
return KM.Model(inputs, x, "digit_classifier_model")
# Load MNIST Data
Example #27
| Source File: backend.py From head-detection-using-yolo with MIT License | 5 votes |
|
def __init__(self, input_size):
input_image = Input(shape=(input_size, input_size, 3))
# Layer 1
x = Conv2D(16, (3,3), strides=(1,1), padding='same', name='conv_1', use_bias=False)(input_image)
x = BatchNormalization(name='norm_1')(x)
x = LeakyReLU(alpha=0.1)(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
# Layer 2 - 5
for i in range(0,4):
x = Conv2D(32*(2**i), (3,3), strides=(1,1), padding='same', name='conv_' + str(i+2), use_bias=False)(x)
x = BatchNormalization(name='norm_' + str(i+2))(x)
x = LeakyReLU(alpha=0.1)(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
# Layer 6
x = Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_6', use_bias=False)(x)
x = BatchNormalization(name='norm_6')(x)
x = LeakyReLU(alpha=0.1)(x)
x = MaxPooling2D(pool_size=(2, 2), strides=(1,1), padding='same')(x)
# Layer 7 - 8
for i in range(0,2):
x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_' + str(i+7), use_bias=False)(x)
x = BatchNormalization(name='norm_' + str(i+7))(x)
x = LeakyReLU(alpha=0.1)(x)
self.feature_extractor = Model(input_image, x)
self.feature_extractor.load_weights(TINY_YOLO_BACKEND_PATH)
Example #28
| Source File: SiameseModel.py From MassImageRetrieval with Apache License 2.0 | 5 votes |
|
def get_Shared_Model(input_dim):
sharedNet = Sequential()
sharedNet.add(Dense(128, input_shape=(input_dim,), activation='relu'))
sharedNet.add(Dropout(0.1))
sharedNet.add(Dense(128, activation='relu'))
sharedNet.add(Dropout(0.1))
sharedNet.add(Dense(128, activation='relu'))
# sharedNet.add(Dropout(0.1))
# sharedNet.add(Dense(3, activation='relu'))
# sharedNet = Sequential()
# sharedNet.add(Dense(4096, activation="tanh", kernel_regularizer=l2(2e-3)))
# sharedNet.add(Reshape(target_shape=(64, 64, 1)))
# sharedNet.add(Conv2D(filters=64, kernel_size=3, strides=(2, 2), padding="same", activation="relu", kernel_regularizer=l2(1e-3)))
# sharedNet.add(MaxPooling2D())
# sharedNet.add(Conv2D(filters=128, kernel_size=3, strides=(2, 2), padding="same", activation="relu", kernel_regularizer=l2(1e-3)))
# sharedNet.add(MaxPooling2D())
# sharedNet.add(Conv2D(filters=64, kernel_size=3, strides=(1, 1), padding="same", activation="relu", kernel_regularizer=l2(1e-3)))
# sharedNet.add(Flatten())
# sharedNet.add(Dense(1024, activation="sigmoid", kernel_regularizer=l2(1e-3)))
return sharedNet
Example #29
| Source File: Coder.py From DigiEncoder with MIT License | 5 votes |
|
def encoder(self):
encoded = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img_conv)
encoded = MaxPooling2D((2, 2), padding='same')(encoded)
encoded = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded)
encoded = MaxPooling2D((2, 2), padding='same')(encoded)
encoded = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded)
encoded = MaxPooling2D((2, 2), padding='same')(encoded)
return encoded
Example #30
| Source File: model.py From udacity-SDC-baseline with MIT License | 5 votes |
|
def build_cnn(image_size=None): image_size = image_size or (60, 80) if K.image_dim_ordering() == 'th': input_shape = (3,) + image_size else: input_shape = image_size + (3, ) img_input = Input(input_shape) x = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(img_input) x = Dropout(0.5)(x) x = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(x) x = Dropout(0.5)(x) x = MaxPooling2D((2, 2), strides=(2, 2))(x) x = Convolution2D(128, 3, 3, activation='relu', border_mode='same')(x) x = Dropout(0.5)(x) # it doesn't fit in my GPU # x = Convolution2D(128, 3, 3, activation='relu', border_mode='same')(x) # x = Dropout(0.5)(x) x = MaxPooling2D((2, 2), strides=(2, 2))(x) y = Flatten()(x) y = Dense(1024, activation='relu')(y) y = Dropout(.5)(y) y = Dense(1024, activation='relu')(y) y = Dropout(.5)(y) y = Dense(1)(y) model = Model(input=img_input, output=y) model.compile(optimizer=Adam(lr=1e-4), loss = 'mse') return model
