def _build_model(self):
# Neural Net for Deep-Q learning Model
model = Sequential()
#model.add(Conv2D(256, kernel_size = (2,2), activation='relu', input_shape=(self.state_size.shape[0], self.state_size.shape[1],1), padding="same"))
#model.add(Conv2D(712, kernel_size = (2,2), activation='relu', padding="same"))
#model.add(Conv2D(128, kernel_size = (2,2), activation='relu', padding="same"))
model.add(Dense(2048, input_dim=5, activation='relu'))#self.state_size.shape[0] * self.state_size.shape[1]
#model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(32, activation='relu'))
model.add(Dense(16, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(8, activation='relu'))
model.add(Dense(4, activation='linear'))
model.compile(loss='mse',
optimizer=Adam(lr=self.learning_rate))
return model
python类Conv2D()的实例源码
def deepMindAtariNet(nbClasses, inputShape, includeTop=True):
'''Set up the 3 conv layer keras model.
classes: Number of outputs.
inputShape: The input shape without the batch size.
includeTop: If you only want the whole net, or just the convolutions.
'''
inp = Input(shape=inputShape)
x = Conv2D(32, 8, 8, subsample=(4, 4), activation='relu', border_mode='same', name='conv1')(inp)
x = Conv2D(64, 4, 4, subsample=(2, 2), activation='relu', border_mode='same', name='conv2')(x)
x = Conv2D(64, 3, 3, activation='relu', border_mode='same', name='conv3')(x)
if includeTop:
x = Flatten(name='flatten')(x)
x = Dense(512, activation='relu', name='dense1')(x)
out = Dense(nbClasses, activation='softmax', name='output')(x)
else:
out = x
model = Model(inp, out)
return model
def deepMindAtariNet(nbClasses, inputShape, includeTop=True):
'''Set up the 3 conv layer keras model.
classes: Number of outputs.
inputShape: The input shape without the batch size.
includeTop: If you only want the whole net, or just the convolutions.
'''
inp = Input(shape=inputShape)
x = Conv2D(32, 8, 8, subsample=(4, 4), activation='relu', border_mode='same', name='conv1')(inp)
x = Conv2D(64, 4, 4, subsample=(2, 2), activation='relu', border_mode='same', name='conv2')(x)
x = Conv2D(64, 3, 3, activation='relu', border_mode='same', name='conv3')(x)
if includeTop:
x = Flatten(name='flatten')(x)
x = Dense(512, activation='relu', name='dense1')(x)
out = Dense(nbClasses, activation='softmax', name='output')(x)
else:
out = x
model = Model(inp, out)
return model
def model(flags):
inputs = Input(shape=(flags['image_size'] + (3,)))
x = inputs
x, sources = downsamples(x, [40, 40, 80, 100, 100, 100, 80, 80])
x = mix(x, 100)
x = Dropout(0.1)(x)
x = upsamples(x, sources, [100] * 8)
x = Conv2D(30, (1, 1), padding='valid', activation='relu')(x)
x = Conv2D(30, (1, 1), padding='valid', activation='relu')(x)
x = Conv2D(len(flags['example']['y']), (1, 1), padding='valid',
activation='sigmoid')(x)
mod = Model(inputs=inputs, outputs=x)
return mod
def test_find_activation_layer():
conv1_filters = 1
conv2_filters = 1
dense_units = 1
model = Sequential()
model.add(Conv2D(conv1_filters, [3, 3], input_shape=(28, 28, 1), data_format="channels_last", name='conv_1'))
model.add(Activation('relu', name='act_1'))
model.add(MaxPool2D((2, 2), name='pool_1'))
model.add(Conv2D(conv2_filters, [3, 3], data_format="channels_last", name='conv_2'))
model.add(Activation('relu', name='act_2'))
model.add(MaxPool2D((2, 2), name='pool_2'))
model.add(Flatten(name='flat_1'))
model.add(Dense(dense_units, name='dense_1'))
model.add(Activation('relu', name='act_3'))
model.add(Dense(10, name='dense_2'))
model.add(Activation('softmax', name='act_4'))
assert find_activation_layer(model.get_layer('conv_1'), 0) == (model.get_layer('act_1'), 0)
assert find_activation_layer(model.get_layer('conv_2'),
0) == (model.get_layer('act_2'), 0)
assert find_activation_layer(model.get_layer('dense_1'),
0) == (model.get_layer('act_3'), 0)
assert find_activation_layer(model.get_layer('dense_2'),
0) == (model.get_layer('act_4'), 0)
def regionProposalNetwork(base_layers, noOfAnchors):
"""
Region Proposal Network
"""
x = Conv2D(512, (1, 300), padding='same', activation='relu', kernel_initializer='normal', name='rpn_conv1')(base_layers)
print 'INFO: rpn_conv1: ',x
#x = Conv2D(512, (1, 302), padding='same', activation='relu', kernel_initializer='normal', name='rpn_conv2')(base_layers)
#x = MaxPooling2D((1,2), strides = (1,2))(x)
x_class = Conv2D(noOfAnchors, (1, 103), activation='sigmoid', kernel_initializer='uniform', name='rpn_out_class')(x)
print 'INFO: rpn_out_class: ',x_class
x_regr = Conv2D(noOfAnchors * 4, (1, 103), activation='linear', kernel_initializer='zero', name='rpn_out_regress')(x)
print 'INFO: rpn_out_regress: ',x_regr
return [x_class, x_regr, base_layers]
def test_tiny_conv_random(self, model_precision=_MLMODEL_FULL_PRECISION):
np.random.seed(1988)
input_dim = 10
input_shape = (input_dim, input_dim, 1)
num_kernels, kernel_height, kernel_width = 3, 5, 5
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size = (kernel_height, kernel_width)))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Test the keras model
self._test_keras_model(model, model_precision=model_precision)
def test_tiny_conv_dilated(self, model_precision=_MLMODEL_FULL_PRECISION):
np.random.seed(1988)
input_dim = 10
input_shape = (input_dim, input_dim, 1)
num_kernels, kernel_height, kernel_width = 3, 5, 5
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape, dilation_rate=(2,2),
filters = num_kernels, kernel_size = (kernel_height, kernel_width)))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Test the keras model
self._test_keras_model(model, model_precision=model_precision)
def test_tiny_conv_dilated_rect_random(self, model_precision=_MLMODEL_FULL_PRECISION):
np.random.seed(1988)
input_shape = (32, 20, 3)
num_kernels = 2
kernel_height = 3
kernel_width = 3
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape, dilation_rate=(2,2),
filters = num_kernels, kernel_size = (kernel_height, kernel_width)))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Test the keras model
self._test_keras_model(model, model_precision=model_precision)
def test_tiny_conv_rect_kernel_x(self):
np.random.seed(1988)
input_dim = 10
input_shape = (input_dim, input_dim, 1)
num_kernels = 3
kernel_height = 1
kernel_width = 5
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size = (kernel_height, kernel_width),
padding = 'same'))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Test the keras model
self._test_keras_model(model)
def test_tiny_conv_rect_kernel_xy(self,
model_precision=_MLMODEL_FULL_PRECISION):
np.random.seed(1988)
input_dim = 10
input_shape = (input_dim, input_dim, 1)
num_kernels = 3
kernel_height = 5
kernel_width = 3
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size = (kernel_height, kernel_width),
padding = 'valid'))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Test the keras model
self._test_keras_model(model, model_precision=model_precision)
def test_conv_batchnorm_random(self, model_precision=_MLMODEL_FULL_PRECISION):
np.random.seed(1988)
input_dim = 10
input_shape = (input_dim, input_dim, 3)
num_kernels = 3
kernel_height = 5
kernel_width = 5
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size = (kernel_height, kernel_width)))
model.add(BatchNormalization(epsilon=1e-5))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Get the coreml model
self._test_keras_model(model, model_precision=model_precision)
def test_conv_batchnorm_no_gamma_no_beta(self, model_precision=_MLMODEL_FULL_PRECISION):
np.random.seed(1988)
input_dim = 10
input_shape = (input_dim, input_dim, 3)
num_kernels = 3
kernel_height = 5
kernel_width = 5
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size = (kernel_height, kernel_width)))
model.add(BatchNormalization(center=False, scale=False, epsilon=1e-5))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Get the coreml model
self._test_keras_model(model, model_precision=model_precision)
def test_tiny_conv_upsample_random(self):
np.random.seed(1988)
input_dim = 10
input_shape = (input_dim, input_dim, 1)
num_kernels = 3
kernel_height = 5
kernel_width = 5
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size = (kernel_height, kernel_width)))
model.add(UpSampling2D(size = 2))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Test the keras model
self._test_keras_model(model)
def test_tiny_conv_dense_random(self):
np.random.seed(1988)
num_samples = 1
input_dim = 8
input_shape = (input_dim, input_dim, 3)
num_kernels = 2
kernel_height = 5
kernel_width = 5
hidden_dim = 4
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size=(kernel_height, kernel_width)))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(hidden_dim))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Get the coreml model
self._test_keras_model(model)
def test_tiny_conv_dropout_random(self):
np.random.seed(1988)
num_samples = 1
input_dim = 8
input_shape = (input_dim, input_dim, 3)
num_kernels = 2
kernel_height = 5
kernel_width = 5
hidden_dim = 4
# Define a model
model = Sequential()
model.add(Conv2D(input_shape = input_shape,
filters = num_kernels, kernel_size=(kernel_height, kernel_width)))
model.add(SpatialDropout2D(0.5))
model.add(Flatten())
model.add(Dense(hidden_dim))
# Set some random weights
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
# Get the coreml model
self._test_keras_model(model)
def test_shared_vision(self):
digit_input = Input(shape=(27, 27,1))
x = Conv2D(64, (3, 3))(digit_input)
x = Conv2D(64, (3, 3))(x)
out = Flatten()(x)
vision_model = Model(inputs=[digit_input], outputs=[out])
# then define the tell-digits-apart model
digit_a = Input(shape=(27,27,1))
digit_b = Input(shape=(27,27,1))
# the vision model will be shared, weights and all
out_a = vision_model(digit_a)
out_b = vision_model(digit_b)
concatenated = concatenate([out_a, out_b])
out = Dense(1, activation='sigmoid')(concatenated)
model = Model(inputs=[digit_a, digit_b], outputs=out)
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_keras_model(model)
def test_conv_layer_params(self, model_precision=_MLMODEL_FULL_PRECISION):
options = dict(
activation = ['relu', 'tanh', 'sigmoid'], # keras does not support softmax on 4-D
use_bias = [True, False],
padding = ['same', 'valid'],
filters = [1, 3, 5],
kernel_size = [[5,5]], # fails when sizes are different
)
# Define a function that tests a model
input_shape = (10, 10, 1)
def build_model(x):
kwargs = dict(zip(options.keys(), x))
model = Sequential()
model.add(Conv2D(input_shape = input_shape, **kwargs))
return x, model
# Iterate through all combinations
product = itertools.product(*options.values())
args = [build_model(p) for p in product]
# Test the cases
print("Testing a total of %s cases. This could take a while" % len(args))
for param, model in args:
self._run_test(model, param, model_precision=model_precision)
def test_tiny_mcrnn_music_tagger(self):
x_in = Input(shape=(4,6,1))
x = ZeroPadding2D(padding=(0, 1))(x_in)
x = BatchNormalization(axis=2, name='bn_0_freq')(x)
# Conv block 1
x = Conv2D(2, (3, 3), padding='same', name='conv1')(x)
x = BatchNormalization(axis=3, name='bn1')(x)
x = Activation('elu')(x)
x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='pool1')(x)
# Conv block 2
x = Conv2D(4, (3, 3), padding='same', name='conv2')(x)
x = BatchNormalization(axis=3, name='bn2')(x)
x = Activation('elu')(x)
x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='pool2')(x)
# Should get you (1,1,2,4)
x = Reshape((2, 4))(x)
x = GRU(32, return_sequences=True, name='gru1')(x)
x = GRU(32, return_sequences=False, name='gru2')(x)
# Create model.
model = Model(x_in, x)
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_keras_model(model, mode='random_zero_mean', delta=1e-2)
def model_cnn(net_layers, input_shape):
inp = Input(shape=input_shape)
model = inp
for cl in net_layers['conv_layers']:
model = Conv2D(filters=cl[0], kernel_size=cl[1], activation='relu')(model)
if cl[4]:
model = MaxPooling2D()(model)
if cl[2]:
model = BatchNormalization()(model)
if cl[3]:
model = Dropout(0.2)(model)
model = Flatten()(model)
for dl in net_layers['dense_layers']:
model = Dense(dl[0])(model)
model = Activation('relu')(model)
if dl[1]:
model = BatchNormalization()(model)
if dl[2]:
model = Dropout(0.2)(model)
model = Dense(1)(model)
model = Activation('sigmoid')(model)
model = Model(inp, model)
return model
# %%
# LSTM architecture
# conv_layers -> [(filters, kernel_size, BatchNormaliztion, Dropout, MaxPooling)]
# dense_layers -> [(num_neurons, BatchNormaliztion, Dropout)]
