def build_encoder(self,input_shape):
return [Reshape((*input_shape,1)),
GaussianNoise(self.parameters['noise']),
BN(),
*[Convolution2D(self.parameters['clayer'],(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
Dropout(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),],
*[Convolution2D(self.parameters['clayer'],(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
Dropout(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),],
flatten,
Sequential([
Dense(self.parameters['layer'], activation=self.parameters['activation'], use_bias=False),
BN(),
Dropout(self.parameters['dropout']),
Dense(self.parameters['N']*self.parameters['M']),
])]
python类Convolution2D()的实例源码
def build_encoder(self,input_shape):
return [Reshape((*input_shape,1)),
GaussianNoise(0.1),
BN(),
Convolution2D(self.parameters['clayer'],(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
Dropout(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),
Convolution2D(self.parameters['clayer'],(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
Dropout(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),
Convolution2D(self.parameters['clayer'],(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
Dropout(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),
flatten,]
def build_network(num_actions, agent_history_length, resized_width, resized_height):
state = tf.placeholder("float", [None, agent_history_length, resized_width, resized_height])
inputs_v = Input(shape=(agent_history_length, resized_width, resized_height,))
#model_v = Permute((2, 3, 1))(inputs_v)
model_v = Convolution2D(nb_filter=16, nb_row=8, nb_col=8, subsample=(4,4), activation='relu', border_mode='same')(inputs_v)
model_v = Convolution2D(nb_filter=32, nb_row=4, nb_col=4, subsample=(2,2), activation='relu', border_mode='same')(model_v)
model_v = Flatten()(model_v)
model_v = Dense(output_dim=512)(model_v)
model_v = PReLU()(model_v)
action_probs = Dense(name="p", output_dim=num_actions, activation='softmax')(model_v)
state_value = Dense(name="v", output_dim=1, activation='linear')(model_v)
value_network = Model(input=inputs_v, output=[state_value, action_probs])
return state, value_network
def discriminator_model():
""" return a (b, 1) logits"""
model = Sequential()
model.add(Convolution2D(64, 4, 4,border_mode='same',input_shape=(IN_CH*2, img_cols, img_rows)))
model.add(BatchNormalization(mode=2))
model.add(Activation('tanh'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(128, 4, 4,border_mode='same'))
model.add(BatchNormalization(mode=2))
model.add(Activation('tanh'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(512, 4, 4,border_mode='same'))
model.add(BatchNormalization(mode=2))
model.add(Activation('tanh'))
model.add(Convolution2D(1, 4, 4,border_mode='same'))
model.add(BatchNormalization(mode=2))
model.add(Activation('tanh'))
model.add(Activation('sigmoid'))
return model
def conv2d_bn(x, nb_filter,num_row, num_col, strides=(1,1), padding='same', name=None):
if name is not None:
bn_name = name + '_bn'
conv_name = name + '_conv'
else:
bn_name = None
conv_name = None
if K.image_data_format() == 'channels_first':
bn_axis = 1
else:
bn_axis = 3
x = Convolution2D(nb_filter,[num_row, num_col],padding=padding,strides=strides,activation='relu',name=conv_name)(x)
x = FixedBatchNormalization(axis=bn_axis, name=bn_name)(x)
return x
def build_encoder(self,input_shape):
last_convolution = np.array(input_shape) // 8
self.parameters['clayer'] = 8
self.parameters['N'] = int(np.prod(last_convolution)*self.parameters['clayer'] // self.parameters['M'])
return [Reshape((*input_shape,1)),
GaussianNoise(0.1),
BN(),
Convolution2D(16,(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
Dropout(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),
Convolution2D(64,(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
SpatialDropout2D(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),
Convolution2D(64,(3,3),
activation=self.parameters['activation'],padding='same', use_bias=False),
SpatialDropout2D(self.parameters['dropout']),
BN(),
MaxPooling2D((2,2)),
Convolution2D(64,(1,1),
activation=self.parameters['activation'],padding='same', use_bias=False),
SpatialDropout2D(self.parameters['dropout']),
BN(),
Convolution2D(self.parameters['clayer'],(1,1),
padding='same'),
flatten,
]
# mixin classes ###############################################################
# Now effectively 3 subclasses; GumbelSoftmax in the output, Convolution, Gaussian.
# there are 4 more results of mixins:
def load_model(input_shape, num_classes):
model = Sequential()
model.add(Convolution2D(6, kernel_size=(3, 3), activation='relu', input_shape=input_shape, padding="same"))
model.add(Convolution2D(32, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Convolution2D(64, kernel_size=(3, 3), border_mode='same', activation='relu'))
model.add(Convolution2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
return model
def GatedPixelCNN(input_shape, filters, depth, latent=None, build=True):
height, width, channels = input_shape
palette = 256 # TODO: Make it scalable to any amount of palette.
input_img = Input(shape=input_shape, name=str(channels)+'_channels_'+str(palette)+'_palette')
latent_vector = None
if latent is not None:
latent_vector = Input(shape=(latent,), name='latent_vector')
model = GatedCNNs(filters, depth, latent_vector)(*GatedCNN(filters, latent_vector)(input_img))
for _ in range(2):
model = Convolution2D(filters, 1, 1, border_mode='valid')(model)
model = PReLU()(model)
outs = OutChannels(*input_shape, masked=False, palette=palette)(model)
if build:
model = Model(input=[input_img, latent_vector] if latent is not None else input_img, output=outs)
model.compile(optimizer=Nadam(), loss='binary_crossentropy' if channels == 1 else 'sparse_categorical_crossentropy')
return model
def __call__(self, model1, model2=None):
if model2 is None:
h_model = model1
filter_size = (7, 7)
else:
h_model = model2
filter_size = (3, 3)
v_model = PaddedConvolution2D(self.filters, filter_size, 'vertical')(model1)
feed_vertical = FeedVertical(self.filters)(v_model)
v_model = GatedBlock(self.filters, h=self.h)(v_model)
h_model_new = PaddedConvolution2D(self.filters, filter_size, 'horizontal', 'A')(h_model)
h_model_new = GatedBlock(self.filters, v=feed_vertical, h=self.h, crop_right=True)(h_model_new)
h_model_new = Convolution2D(self.filters, 1, 1, border_mode='valid')(h_model_new)
return (v_model, h_model_new if model2 is None else Merge(mode='sum')([h_model_new, h_model]))
def conv2d_bn(x, nb_filter, nb_row, nb_col,
border_mode='same', subsample=(1, 1),
name=None):
'''Utility function to apply conv + BN.
'''
if name is not None:
bn_name = name + '_bn'
conv_name = name + '_conv'
else:
bn_name = None
conv_name = None
if K.image_dim_ordering() == 'th':
bn_axis = 1
else:
bn_axis = 3
x = Convolution2D(nb_filter, nb_row, nb_col,
subsample=subsample,
activation='relu',
border_mode=border_mode,
name=conv_name)(x)
x = BatchNormalization(axis=bn_axis, name=bn_name)(x)
return x
def fire_module(x, fire_id, squeeze=16, expand=64):
s_id = 'fire' + str(fire_id) + '/'
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = 3
x = Convolution2D(squeeze, (1, 1), padding='valid', name=s_id + sq1x1)(x)
x = Activation('relu', name=s_id + relu + sq1x1)(x)
left = Convolution2D(expand, (1, 1), padding='valid', name=s_id + exp1x1)(x)
left = Activation('relu', name=s_id + relu + exp1x1)(left)
right = Convolution2D(expand, (3, 3), padding='same', name=s_id + exp3x3)(x)
right = Activation('relu', name=s_id + relu + exp3x3)(right)
x = concatenate([left, right], axis=channel_axis, name=s_id + 'concat')
return x
# Original SqueezeNet from paper.
def double_conv_layer(x, size, dropout, batch_norm):
from keras.models import Model
from keras.layers import Input, merge, Convolution2D, MaxPooling2D, UpSampling2D
from keras.layers.normalization import BatchNormalization
from keras.layers.core import Dropout, Activation
conv = Convolution2D(size, 3, 3, border_mode='same')(x)
if batch_norm == True:
conv = BatchNormalization(mode=0, axis=1)(conv)
conv = Activation('relu')(conv)
conv = Convolution2D(size, 3, 3, border_mode='same')(conv)
if batch_norm == True:
conv = BatchNormalization(mode=0, axis=1)(conv)
conv = Activation('relu')(conv)
if dropout > 0:
conv = Dropout(dropout)(conv)
return conv
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
subsample = (subsample_factor, subsample_factor)
x = BatchNormalization(axis=3)(input_tensor)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=subsample, border_mode='same')(x)
x = BatchNormalization(axis=3)(x)
x = Activation('relu')(x)
x = Convolution2D(nb_filters, 3, 3, subsample=(1, 1), border_mode='same')(x)
if subsample_factor > 1:
shortcut = Convolution2D(nb_filters, 1, 1, subsample=subsample, border_mode='same')(input_tensor)
else:
shortcut = input_tensor
x = merge([x, shortcut], mode='sum')
return x
def addLayer(previousLayer, nChannels, nOutChannels, dropRate, blockNum):
bn = BatchNormalization(name = 'denseb_BatchNorm_{}'.format(blockNum) , axis = 1)(previousLayer)
relu = Activation('relu', name ='denseb_relu_{}'.format(blockNum))(bn)
conv = Convolution2D(nOutChannels, 3, 3, border_mode='same', name='denseb_conv_{}'.format(blockNum))(relu)
if dropRate is not None:
dp = Dropout(dropRate, name='denseb_dropout_{}'.format)(conv)
return merge([dp, previousLayer], mode='concat', concat_axis=1)
else:
return merge([conv, previousLayer], mode='concat', concat_axis=1)
def addTransition(previousLayer, nChannels, nOutChannels, dropRate, blockNum):
bn = BatchNormalization(name = 'tr_BatchNorm_{}'.format(blockNum), axis = 1)(previousLayer)
relu = Activation('relu', name ='tr_relu_{}'.format(blockNum))(bn)
conv = Convolution2D(nOutChannels, 1, 1, border_mode='same', name='tr_conv_{}'.format(blockNum))(relu)
if dropRate is not None:
dp = Dropout(dropRate, name='tr_dropout_{}'.format)(conv)
avgPool = AveragePooling2D(pool_size=(2, 2))(dp)
else:
avgPool = AveragePooling2D(pool_size=(2, 2))(conv)
return avgPool
def create_conv_model(self):
# This is the place where neural network model initialized
init = 'glorot_uniform'
self.state_in = Input(self.state_dim)
self.l1 = Convolution2D(32, 8, 8, activation='elu', init=init, subsample=(4, 4), border_mode='same')(
self.state_in)
self.l2 = Convolution2D(64, 4, 4, activation='elu', init=init, subsample=(2, 2), border_mode='same')(
self.l1)
# self.l3 = Convolution2D(64, 3, 3, activation='relu', init=init, subsample=(1, 1), border_mode='same')(
# self.l2)
self.l3 = self.l2
self.h = Flatten()(self.l3)
self.hidden = Dense(256, init=init, activation='elu')(self.h)
self.value = Dense(1, init=init)(self.hidden)
self.policy = Dense(self.action_dim, init=init, activation='softmax')(self.hidden)
self.q_values = self.entropy_coef * (Theano.log(self.policy + 1e-18) -
Theano.tile(Theano.sum(Theano.log(self.policy + 1e-18) * self.policy,
axis=[1], keepdims=True), (1, self.action_dim)))
self.q_values = self.q_values + Theano.tile(self.value, (1, self.action_dim))
self.model = Model(self.state_in, output=[self.policy, self.value])
def createModel(w=None,h=None):
# Input placeholder
original = Input(shape=(w, h, 4), name='icon_goes_here')
# Model layer stack
x = original
x = Convolution2D(64, 4, 4, activation='relu', border_mode='same', b_regularizer=l2(0.1))(x)
x = Convolution2D(64, 4, 4, activation='relu', border_mode='same', b_regularizer=l2(0.1))(x)
x = Convolution2D(64, 4, 4, activation='relu', border_mode='same', b_regularizer=l2(0.1))(x)
x = Convolution2D(64, 4, 4, activation='relu', border_mode='same', b_regularizer=l2(0.1))(x)
x = AveragePooling2D((2, 2), border_mode='valid')(x)
x = Convolution2D(16, 4, 4, activation='relu', border_mode='same', b_regularizer=l2(0.1))(x)
x = Convolution2D(4, 4, 4, activation='relu', border_mode='same', b_regularizer=l2(0.1))(x)
downscaled = x
# Compile model
hintbot = Model(input=original, output=downscaled)
hintbot.compile(optimizer='adam', loss='mean_squared_error')
# Train
if (os.path.isfile(load_weights_filepath)):
hintbot.load_weights(load_weights_filepath)
return hintbot
