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