def attention_block(x, gating, inter_shape):
shape_x = K.int_shape(x)
shape_g = K.int_shape(gating)
theta_x = layers.Conv2D(inter_shape, (2, 2),
strides=(2, 2),
padding='same')(x) # 16
shape_theta_x = K.int_shape(theta_x)
phi_g = layers.Conv2D(inter_shape, (1, 1), padding='same')(gating)
upsample_g = layers.Conv2DTranspose(
inter_shape, (3, 3),
strides=(shape_theta_x[1] // shape_g[1],
shape_theta_x[2] // shape_g[2]),
padding='same')(phi_g) # 16
concat_xg = layers.add([upsample_g, theta_x])
act_xg = layers.Activation('relu')(concat_xg)
psi = layers.Conv2D(1, (1, 1), padding='same')(act_xg)
sigmoid_xg = layers.Activation('sigmoid')(psi)
shape_sigmoid = K.int_shape(sigmoid_xg)
upsample_psi = layers.UpSampling2D(size=(shape_x[1] // shape_sigmoid[1],
shape_x[2] // shape_sigmoid[2]))(
sigmoid_xg) # 32
upsample_psi = expend_as(upsample_psi, shape_x[3])
y = layers.multiply([upsample_psi, x])
result = layers.Conv2D(shape_x[3], (1, 1), padding='same')(y)
result_bn = layers.BatchNormalization()(result)
return result_bn
def add_resnet_unit(path, **params):
block_input = path
# add Conv2D
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
print path
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
print path
path = L.Activation('relu')(path)
print path
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
print path
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
print path
path = L.Add()([block_input, path])
print path
path = L.Activation('relu')(path)
print path
return path
def conv_block(input_tensor, num_filters):
encoder = layers.Conv2D(num_filters, (3, 3), padding='same')(input_tensor)
encoder = layers.BatchNormalization()(encoder)
encoder = layers.Activation('relu')(encoder)
encoder = layers.Conv2D(num_filters, (3, 3), padding='same')(encoder)
encoder = layers.BatchNormalization()(encoder)
encoder = layers.Activation('relu')(encoder)
return encoder
def decoder_block(input_tensor, concat_tensor, num_filters):
decoder = layers.Conv2DTranspose(num_filters, (2, 2), strides=(2, 2), padding='same')(input_tensor)
decoder = layers.concatenate([concat_tensor, decoder], axis=-1)
decoder = layers.BatchNormalization()(decoder)
decoder = layers.Activation('relu')(decoder)
decoder = layers.Conv2D(num_filters, (3, 3), padding='same')(decoder)
decoder = layers.BatchNormalization()(decoder)
decoder = layers.Activation('relu')(decoder)
decoder = layers.Conv2D(num_filters, (3, 3), padding='same')(decoder)
decoder = layers.BatchNormalization()(decoder)
decoder = layers.Activation('relu')(decoder)
return decoder
def build_model(self):
"""Build an actor (policy) network that maps states -> actions."""
# Define input layer (states)
states = layers.Input(shape=(self.state_size, ), name='states')
#--------- copy from DDPG quadcopter -----------
net = layers.Dense(units=400)(states)
# net = layers.BatchNormalization()(net)
net = layers.Activation("relu")(net)
net = layers.Dense(units=200)(net)
# net = layers.BatchNormalization()(net)
net = layers.Activation("relu")(net)
actions = layers.Dense(units=self.action_size,
activation='softmax',
name='actions',
kernel_initializer=initializers.RandomUniform(
minval=-1, maxval=1))(net)
# actions = layers.Dense(units=self.action_size, activation='sigmoid', name='actions',
# kernel_initializer=initializers.RandomUniform(minval=-0.001, maxval=0.001))(net)
# Add hidden layers
# net = layers.Dense(units=16,activation=activations.sigmoid)(states)
# net = layers.BatchNormalization()(net)
# net = layers.Dense(units=16,activation=activations.sigmoid)(net)
# net = layers.BatchNormalization()(net)
# net = layers.Dense(units=128,activation=activations.relu)(net)
# net = layers.BatchNormalization()(net)
# Add final output layer with sigmoid activation
# actions = layers.Dense(units=self.action_size, activation='linear', # sigmoid
# name='raw_actions' )(net)
# Scale [0, 1] output for each action dimension to proper range
# actions = layers.Lambda(lambda x: (x * self.action_range) + self.action_low,
# name='actions')(raw_actions)
# Create Keras model
self.model = models.Model(inputs=states, outputs=actions)
action_gradients = layers.Input(shape=(self.action_size, ))
loss = K.mean(-action_gradients * actions)
# Define optimizer and training function
optimizer = optimizers.Adam(lr=.0001)
updates_op = optimizer.get_updates(params=self.model.trainable_weights,
loss=loss)
self.train_fn = K.function(
inputs=[self.model.input, action_gradients,
K.learning_phase()],
outputs=[],
updates=updates_op)
def create_model(self, img_shape, num_class):
self.handle_dim_ordering()
K.set_learning_phase(True)
#model = models.Sequential()
inputs = layers.Input(shape = img_shape)
x = self.conv_bn_relu(inputs, (3, 3),(1, 1), 32, 'conv0_1')
net = self.conv_bn_relu(x, (3, 3), (1, 1), 64, 'conv0_2')
bn1 = layers.BatchNormalization(momentum=0.99, name='conv0_3_bn')(self.conv(
net, (3, 3), (1, 1), 32, 'conv0_3'))
act1 = layers.Activation('relu')(bn1)
bn2, act2 = self.down_block(act1, 32, 'down1')
bn3, act3 = self.down_block(act2, 32, 'down2')
bn4, act4 = self.down_block(act3, 32, 'down3')
bn5, act5 = self.down_block(act4, 32, 'down4')
bn6, act6 = self.down_block(act5, 32, 'down5')
bn7, act7 = self.down_block(act6, 32, 'down6')
temp = self.up_block(act7, bn6, 32, 'up6')
temp = self.up_block(temp, bn5, 32, 'up5')
temp = self.up_block(temp, bn4, 32, 'up4')
temp = self.up_block(temp, bn3, 32, 'up3')
temp = self.up_block(temp, bn2, 32, 'up2')
temp = self.up_block(temp, bn1, 32, 'up1')
output = self.conv(temp, (1, 1), (1, 1), num_class, 'output')
model = models.Model(outputs=output, inputs=inputs)
print(model.summary())
return model
def conv2_bn(x, filts, k=3, stride=1, rate=1, name=None, pad='same'):
x = l.Conv2D(filts, (k, k),
strides=(stride, stride),
dilation_rate=rate,
padding=pad,
name=name)(x)
x = l.BatchNormalization(name=name + '_bn')(x)
x = l.Activation('relu', name=name + '_relu')(x)
return x
def residual_layer(input_tensor, nb_in_filters=64, nb_bottleneck_filters=16, filter_sz=3, stage=0, reg=0.0):
bn_name = 'bn' + str(stage)
conv_name = 'conv' + str(stage)
relu_name = 'relu' + str(stage)
merge_name = 'add' + str(stage)
# batchnorm-relu-conv, from nb_in_filters to nb_bottleneck_filters via 1x1 conv
if stage>1: # first activation is just after conv1
x = layers.BatchNormalization(axis=-1, name=bn_name+'a')(input_tensor)
x = layers.Activation('relu', name=relu_name+'a')(x)
else:
x = input_tensor
x = layers.Conv2D(nb_bottleneck_filters, (1, 1),
kernel_initializer='glorot_normal',
kernel_regularizer=regularizers.l2(reg),
use_bias=False,
name=conv_name+'a')(x)
# batchnorm-relu-conv, from nb_bottleneck_filters to nb_bottleneck_filters via FxF conv
x = layers.BatchNormalization(axis=-1, name=bn_name+'b')(x)
x = layers.Activation('relu', name=relu_name+'b')(x)
x = layers.Conv2D(nb_bottleneck_filters, (filter_sz, filter_sz),
padding='same',
kernel_initializer='glorot_normal',
kernel_regularizer=regularizers.l2(reg),
use_bias = False,
name=conv_name+'b')(x)
# batchnorm-relu-conv, from nb_in_filters to nb_bottleneck_filters via 1x1 conv
x = layers.BatchNormalization(axis=-1, name=bn_name+'c')(x)
x = layers.Activation('relu', name=relu_name+'c')(x)
x = layers.Conv2D(nb_in_filters, (1, 1),
kernel_initializer='glorot_normal',
kernel_regularizer=regularizers.l2(reg),
name=conv_name+'c')(x)
# merge
x = layers.add([x, input_tensor], name=merge_name)
return x
def depth2_bn(x, filts, stride=1, multiplier=1, k=3, name=None, pad='same'):
x = dw.DepthWiseConv2D(filts, (k, k),
strides=(stride, stride),
depth_multiplier=multiplier,
padding=pad,
use_bias=False,
name=name + '_dw')(x)
x = l.BatchNormalization(name=name + '_bn')(x)
x = l.Activation('relu', name=name + '_relu')(x)
return x
def up_block(self, act, bn, f, name):
x = layers.UpSampling2D(
size=(2,2), name='upsample_{}'.format(name))(act)
temp = layers.concatenate([bn, x], axis=1)
temp = self.conv_bn_relu(temp, (3, 3), (1, 1),
2*f, 'layer2_{}'.format(name))
temp = layers.BatchNormalization(self.conv(temp, (3, 3), (1, 1), f, 'layer3_{}'.format(
name)), momentum=0.99, name='layer3_bn_{}'.format(name))
#bn = layers.add([bn,x])
bn = self.shortcut(x, bn)
act = layers.Activation('relu')(bn)
return act
def add_resnet_unit(path, **params):
"""Add a resnet unit to path
Returns new path
"""
block_input = path
# add Conv2D
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
# add BatchNorm
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
# add ReLU
path = L.Activation('relu')(path)
# add Conv2D
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
# add BatchNorm
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
# Merge 'input layer' with the path
path = L.Add()([block_input, path])
# add ReLU
path = L.Activation('relu')(path)
return path
def down_block(self, data, f, name):
x = layers.MaxPooling2D(pool_size=(2,2), strides=(2,2))(data)
# temp = conv_bn_relu(data, (3, 3), (2, 2), (1, 1),
# f, 'layer1_{}'.format(name))
temp = self.conv_bn_relu(x, (3, 3), (1, 1),
2*f, 'layer2_{}'.format(name))
bn = layers.BatchNormalization(momentum=0.99, name='layer3_bn_{}'.format(name))(self.conv(temp, (3, 3), (1, 1), f, 'layer3_{}'.format(
name)))
#bn = layers.add([bn,x])
bn = self.shortcut(x,bn)
act = layers.Activation('relu')(bn)
return bn, act
def Resnet50DomainAdaptation(X, Y, weights='imagenet', dataset_names=[]):
base_net = applications.resnet50.ResNet50(weights=weights)
inp_0 = base_net.input
base_net.layers.pop()
base_net.outputs = [base_net.layers[-1].output]
base_net.layers[-1].outbound_nodes = []
Z = base_net.get_layer('flatten_1').output
out, loss = [], []
# prediction loss
for i, y in enumerate(Y[:-1]):
# for i, y in enumerate(Y):
if dataset_names:
dataset_name = dataset_names[i]
else:
dataset_name = i
net = layers.Dense(y.shape[1], name="dense_{}".format(dataset_name))(Z)
out.append(net)
loss.append(mse)
# domain loss
# Flip the gradient when backpropagating through this operation
grl = GradientReversal(1.0, name='gradient_reversal')
feat = grl(Z)
dp_fc0 = layers.Dense(100,
activation='relu',
name='dense_domain_relu',
kernel_initializer='glorot_normal')(feat)
domain_logits = layers.Dense(len(Y) - 1,
activation='linear',
kernel_initializer='glorot_normal',
name='dense_domain_logit')(dp_fc0)
domain_softmax = layers.Activation('softmax')(domain_logits)
out.append(domain_softmax)
loss.append(K.categorical_crossentropy)
# initialize model
model = keras.models.Model(inp_0, out)
return model, loss
def optimizedNework(self):
self.model.add(
layers.Conv2D(filters=16,
kernel_size=(7, 7),
padding='same',
name='image_array',
input_shape=(SIZE_FACE, SIZE_FACE, 1)))
self.model.add(layers.BatchNormalization())
self.model.add(
layers.Convolution2D(filters=16,
kernel_size=(7, 7),
padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(layers.Activation('relu'))
self.model.add(
layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
self.model.add(layers.Dropout(.5))
self.model.add(
layers.Conv2D(filters=32, kernel_size=(5, 5), padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(
layers.Convolution2D(filters=32,
kernel_size=(5, 5),
padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(layers.Activation('relu'))
self.model.add(
layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
self.model.add(layers.Dropout(.5))
self.model.add(
layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(
layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(layers.Activation('relu'))
self.model.add(
layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
self.model.add(layers.Dropout(.5))
self.model.add(
layers.Conv2D(filters=128, kernel_size=(3, 3), padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(
layers.Convolution2D(filters=128,
kernel_size=(3, 3),
padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(layers.Activation('relu'))
self.model.add(
layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
self.model.add(layers.Dropout(.5))
self.model.add(
layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same'))
self.model.add(layers.BatchNormalization())
self.model.add(
layers.Conv2D(filters=3, kernel_size=(3, 3), padding='same'))
self.model.add(layers.GlobalAveragePooling2D())
self.model.add(layers.Activation('softmax', name='predictions'))
def bn_relu(self, data, name):
return layers.Activation('relu')(layers.BatchNormalization(momentum=0.99, name='bn_{}'.format(name))(data))
def UNet_PA(dropout_rate=0.0, batch_norm=True):
'''
UNet construction
convolution: 3*3 SAME padding
pooling: 2*2 VALID padding
upsampling: 3*3 VALID padding
final convolution: 1*1
:param dropout_rate: FLAG & RATE of dropout.
if < 0 dropout cancelled, if > 0 set as the rate
:param batch_norm: flag of if batch_norm used,
if True batch normalization
:return: UNet model for PACT recons
'''
# input data
# dimension of the image depth
inputs = layers.Input((INPUT_SIZE, INPUT_SIZE, INPUT_CHANNEL))
axis = 3
# Subsampling layers
# double layer 1, convolution + pooling
conv_128 = double_conv_layer(inputs, FILTER_SIZE, INPUT_SIZE, dropout_rate,
batch_norm)
pool_64 = layers.MaxPooling2D(pool_size=(2, 2))(conv_128)
# double layer 2
conv_64 = double_conv_layer(pool_64, 2 * FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
pool_32 = layers.MaxPooling2D(pool_size=(2, 2))(conv_64)
# double layer 3
conv_32 = double_conv_layer(pool_32, 4 * FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
pool_16 = layers.MaxPooling2D(pool_size=(2, 2))(conv_32)
# double layer 4
conv_16 = double_conv_layer(pool_16, 8 * FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
pool_8 = layers.MaxPooling2D(pool_size=(2, 2))(conv_16)
# double layer 5, convolution only
conv_8 = double_conv_layer(pool_8, 16 * FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
# Upsampling layers
# double layer 6, upsampling + concatenation + convolution
up_16 = layers.UpSampling2D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE),
data_format="channels_last")(conv_8)
up_16 = layers.concatenate([up_16, conv_16], axis=axis)
up_conv_16 = double_conv_layer(up_16, 8 * FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
# double layer 7
up_32 = layers.concatenate([
layers.UpSampling2D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE),
data_format="channels_last")(up_conv_16), conv_32
],
axis=axis)
up_conv_32 = double_conv_layer(up_32, 4 * FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
# double layer 8
up_64 = layers.concatenate([
layers.UpSampling2D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE),
data_format="channels_last")(up_conv_32), conv_64
],
axis=axis)
up_conv_64 = double_conv_layer(up_64, 2 * FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
# double layer 9
up_128 = layers.concatenate([
layers.UpSampling2D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE),
data_format="channels_last")(up_conv_64), conv_128
],
axis=axis)
up_conv_128 = double_conv_layer(up_128, FILTER_SIZE, INPUT_SIZE,
dropout_rate, batch_norm)
# 1*1 convolutional layers
# valid padding
# batch normalization
# sigmoid nonlinear activation
conv_final = layers.Conv2D(OUTPUT_MASK_CHANNEL,
kernel_size=(1, 1))(up_conv_128)
conv_final = layers.BatchNormalization(axis=axis)(conv_final)
conv_final = layers.Activation('sigmoid')(conv_final)
# Model integration
model = models.Model(inputs, conv_final, name="UNet")
return model
def create_network(**kwargs):
model_input = L.Input(shape=(17, 9, 9))
print model_input
convolution_path = L.Convolution2D(
input_shape=(),
filters=64,
kernel_size=3,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(model_input)
print convolution_path
convolution_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.Activation('relu')(convolution_path)
convolution_path = L.Convolution2D(
input_shape=(),
filters=128,
kernel_size=3,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.Activation('relu')(convolution_path)
print '------------- value -------------------'
# policy head
policy_path = L.Convolution2D(
input_shape=(),
filters=2,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print policy_path
policy_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(policy_path)
policy_path = L.Activation('relu')(policy_path)
print policy_path
policy_path = L.Flatten()(policy_path)
print policy_path
policy_path = L.Dense((9 * 9) + 1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(policy_path)
policy_output = L.Activation('softmax')(policy_path)
print 'policy_output', policy_output
print '------------- policy -------------------'
# value head
value_path = L.Convolution2D(
input_shape=(),
filters=1,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print value_path
value_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(value_path)
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Flatten()(value_path)
print value_path
value_path = L.Dense(256,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Dense(1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_output = L.Activation('tanh')(value_path)
print value_path
return M.Model(inputs=[model_input],
outputs=[policy_output, value_output])
sz_res_filters, nb_res_filters, nb_res_stages = (3,32,25)
img_input = layers.Input(shape=(32,32,3), name='cifar')
# Initial layers
x = layers.Conv2D(sz_ly0_filters, (nb_ly0_filters,nb_ly0_filters),
strides=(nb_ly0_stride, nb_ly0_stride), padding='same',
kernel_initializer='glorot_normal',
kernel_regularizer=regularizers.l2(1.e-4),
use_bias=False, name='conv0')(img_input)
x = layers.BatchNormalization(axis=-1, name='bn0')(x)
x = layers.Activation('relu', name='relu0')(x)
# Resnet layers
for stage in range(1, nb_res_stages+1):
x = residual_layer(x,
nb_in_filters=sz_ly0_filters,
nb_bottleneck_filters=nb_res_filters,
filter_sz=sz_res_filters,
stage=stage,
reg=0.0)
# Complete last resnet layer
x = layers.BatchNormalization(axis=-1, name='bnF')(x)
x = layers.Activation('relu', name='reluF')(x)
def create_network(**kwargs):
"""construct a convolutional neural network with Residual blocks.
Arguments are the same as with the default CNNPolicy network, except the default
number of layers is 20 plus a new n_skip parameter
Keword Arguments:
- input_dim: depth of features to be processed by first layer (default 17)
- board: width of the go board to be processed (default 19)
- filters_per_layer: number of filters used on every layer (default 256)
- layers: number of residual blocks (default 19)
- filter_width: width of filter
Must be odd.
"""
defaults = {
"input_dim": 17,
"board": 9,
"filters_per_layer": 64,
"layers": 9,
"filter_width": 3
}
# copy defaults, but override with anything in kwargs
params = defaults
params.update(kwargs)
# create the network using Keras' functional API,
model_input = L.Input(shape=(params["input_dim"], params["board"], params["board"]))
print model_input
# create first layer
convolution_path = L.Convolution2D(
input_shape=(),
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(model_input)
print convolution_path
convolution_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(convolution_path)
print convolution_path
convolution_path = L.Activation('relu')(convolution_path)
def add_resnet_unit(path, **params):
block_input = path
# add Conv2D
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
print path
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
print path
path = L.Activation('relu')(path)
print path
path = L.Convolution2D(
filters=params["filters_per_layer"],
kernel_size=params["filter_width"],
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(path)
print path
path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(path)
print path
path = L.Add()([block_input, path])
print path
path = L.Activation('relu')(path)
print path
return path
# create all other layers
for _ in range(params['layers']):
convolution_path = add_resnet_unit(convolution_path, **params)
print '------------- policy -------------------'
# policy head
policy_path = L.Convolution2D(
input_shape=(),
filters=2,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print policy_path
policy_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(policy_path)
policy_path = L.Activation('relu')(policy_path)
print policy_path
policy_path = L.Flatten()(policy_path)
print policy_path
policy_path = L.Dense(
params["board"]*params["board"]+1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(policy_path)
policy_output = L.Activation('softmax')(policy_path)
print 'policy_output', policy_output
print '-------------value -------------------'
# value head
value_path = L.Convolution2D(
input_shape=(),
filters=1,
kernel_size=1,
activation='linear',
padding='same',
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(convolution_path)
print value_path
value_path = L.BatchNormalization(
beta_regularizer=R.l2(.0001),
gamma_regularizer=R.l2(.0001))(value_path)
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Flatten()(value_path)
print value_path
value_path = L.Dense(
256,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_path = L.Activation('relu')(value_path)
print value_path
value_path = L.Dense(
1,
kernel_regularizer=R.l2(.0001),
bias_regularizer=R.l2(.0001))(value_path)
print value_path
value_output = L.Activation('tanh')(value_path)
print value_path
return M.Model(inputs=[model_input], outputs=[policy_output, value_output])
def build_model(self):
# Define input layers
input_states = layers.Input(shape=(self.state_size, ),
name='input_states')
input_actions = layers.Input(shape=(self.action_size, ),
name='input_actions')
#---------- copy from DDPG quadcopter ---------
# Add hidden layer(s) for state pathway
net_states = layers.Dense(units=400)(input_states)
# net_states = layers.BatchNormalization()(net_states)
net_states = layers.Activation("relu")(net_states)
net_states = layers.Dense(units=300)(net_states)
net_states = layers.Activation("relu")(net_states)
# Add hidden layer(s) for action pathway
net_actions = layers.Dense(units=300)(input_actions)
net_actions = layers.Activation("relu")(net_actions)
# net_actions = layers.Dense(units=250,kernel_regularizer=regularizers.l2(1e-7))(net_actions)
# net_actions = layers.BatchNormalization()(net_actions)
# net_actions = layers.Activation("relu")(net_actions)
# Combine state and action pathways
net = layers.Add()([net_states, net_actions])
net = layers.Activation('relu')(net)
net = layers.Dense(units=200,
kernel_initializer=initializers.RandomUniform(
minval=-0.5, maxval=0.5))(net)
net = layers.Activation('relu')(net)
# Add final output layer to prduce action values (Q values)
Q_values = layers.Dense(units=1, name='q_values')(net)
# ---------------- Hidden layers for states ----------------
# model_states = layers.Dense(units=32, activation=activations.sigmoid)(input_states)
# # model_states = layers.BatchNormalization()(model_states)
# model_states = layers.Dense(units=16, activation=activations.sigmoid)(model_states)
# # model_states = layers.BatchNormalization()(model_states)
# # model_states = layers.Dense(units=64)(model_states)
# # model_states = layers.BatchNormalization()(model_states)
# # ---------------- Hidden layers for actions ----------------
# model_actions = layers.Dense(units=16, activation=activations.sigmoid)(input_actions)
# # model_actions = layers.BatchNormalization()(model_actions)
# model_actions = layers.Dense(units=16, activation=activations.sigmoid)(model_actions)
# # model_actions = layers.BatchNormalization()(model_actions)
# # Both models merge here
# model = layers.add([model_states, model_actions])
# # Fully connected and batch normalization
# model = layers.Dense(units=8, activation=activations.sigmoid)(model)
# # model = layers.BatchNormalization()(model)
# # model = layers.Dense(units=64, activation=activations.relu)(model)
# # model = layers.BatchNormalization()(model)
# # Q values / output layer
# Q_values = layers.Dense(units=1, name='Q_s_a')(model)
# # model = layers.BatchNormalization()(model)
# Keras wrap the model
self.model = models.Model(inputs=[input_states, input_actions],
outputs=Q_values)
optimizer = optimizers.Adam(lr=0.0001)
self.model.compile(optimizer=optimizer, loss='mse')
action_gradients = K.gradients(Q_values, input_actions)
self.get_action_gradients = K.function(
inputs=[*self.model.input, K.learning_phase()],
outputs=action_gradients)
def _cnn_ctc_init(self):
self.input_data = layers.Input(name='the_input',
shape=(self.AUDIO_LENGTH,
self.AUDIO_FEATURE_LENGTH, 1))
layers_h1 = layers.Conv2D(filters=32,
kernel_size=(3, 3),
use_bias=False,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
self.input_data)
layers_h1 = layers.Dropout(rate=0.05)(layers_h1)
layers_h2 = layers.Conv2D(filters=32,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h1)
layers_h3 = layers.MaxPooling2D(pool_size=2,
strides=None,
padding='valid')(layers_h2)
layers_h3 = layers.Dropout(rate=0.05)(layers_h3)
layers_h4 = layers.Conv2D(filters=64,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h3)
layers_h4 = layers.Dropout(rate=0.1)(layers_h4)
layers_h5 = layers.Conv2D(filters=64,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h4)
layers_h6 = layers.MaxPooling2D(pool_size=2,
strides=None,
padding='valid')(layers_h5)
layers_h6 = layers.Dropout(rate=0.1)(layers_h6)
layers_h7 = layers.Conv2D(filters=128,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h6)
layers_h7 = layers.Dropout(rate=0.15)(layers_h7)
layers_h8 = layers.Conv2D(filters=128,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h7)
layers_h9 = layers.MaxPooling2D(pool_size=2,
strides=None,
padding='valid')(layers_h8)
layers_h9 = layers.Dropout(rate=0.15)(layers_h9)
layers_h10 = layers.Conv2D(filters=128,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h9)
layers_h10 = layers.Dropout(rate=0.2)(layers_h10)
layers_h11 = layers.Conv2D(filters=128,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h10)
layers_h12 = layers.MaxPooling2D(pool_size=1,
strides=None,
padding='valid')(layers_h11)
layers_h12 = layers.Dropout(rate=0.2)(layers_h12)
layers_h13 = layers.Conv2D(filters=128,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h12)
layers_h13 = layers.Dropout(rate=0.2)(layers_h13)
layers_h14 = layers.Conv2D(filters=128,
kernel_size=(3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layers_h13)
layers_h15 = layers.MaxPooling2D(pool_size=1,
strides=None,
padding='valid')(layers_h14)
layers_h16 = layers.Reshape(
(self.AUDIO_FEATURE_LENGTH, self.AUDIO_LENGTH * 2))(layers_h15)
layers_h16 = layers.Dropout(rate=0.3)(layers_h16)
layers_h17 = layers.Dense(units=128,
use_bias=True,
activation='relu',
kernel_initializer='he_normal')(layers_h16)
layers_h17 = layers.Dropout(rate=0.3)(layers_h17)
layers_h18 = layers.Dense(units=self.OUTPUT_SIZE,
use_bias=True,
kernel_initializer='he_normal')(layers_h17)
y_pred = layers.Activation('softmax', name='activation_0')(layers_h18)
self.cnn_model = models.Model(inputs=self.input_data, outputs=y_pred)
self.labels = layers.Input(name='the_label',
shape=[self.LABEL_SEQUENCE_LENGTH],
dtype='float32')
self.input_length = layers.Input(name='input_length',
shape=[1],
dtype='int64')
self.label_length = layers.Input(name='label_length',
shape=[1],
dtype='int64')
self.loss = layers.Lambda(function=self._ctc_lambda_func,
output_shape=(1, ),
name='ctc')([
y_pred, self.labels, self.input_length,
self.label_length
])
self.ctc_model = models.Model(inputs=[
self.input_data, self.labels, self.input_length, self.label_length
],
outputs=self.loss)
optimizer = optimizers.Adam(lr=0.0001,
beta_1=0.9,
beta_2=0.999,
decay=0.0,
epsilon=10e-8)
self.ctc_model.compile(optimizer=optimizer,
loss={
'ctc': lambda y_true, y_pred: y_pred
})
print('[*Info] Create Model Successful, Compiles Model Successful. ')
return self.cnn_model, self.ctc_model
