def get_transformer_model(sample_length, step_ahead=3):
# TODO make it as class
def transformer_regression(units, x):
query = Dense(8)(x)
value = Dense(8)(x)
key = Dense(8)(x)
query, value, key = [
tf.expand_dims(x, axis=1) for x in [query, value, key]
]
x = Attention()([query, value, key])
x = LayerNormalization()(x)
x = GlobalAveragePooling1D(data_format='channels_last')(x)
x = Dense(units)(x)
return x
in_seq = Input(shape=(sample_length, 3))
timeof = doubleDense(sample_length, in_seq[:, :, 2])
timeof2 = doubleDense(sample_length, in_seq[:, :, 2])
river = transformer_regression(step_ahead,
subtract([in_seq[:, :, 0], timeof]))
rain = transformer_regression(step_ahead,
subtract([in_seq[:, :, 1], timeof2]))
out = add([rain, river])
return Model(inputs=in_seq, outputs=out)
def create_model(img_width=IMAGE_WIDTH, img_height=IMAGE_HEIGHT, resnet_weights="imagenet"):
input_1 = Input(shape=(img_height, img_width, 3,))
input_2 = Input(shape=(img_height, img_width, 3,))
input_3 = Input(shape=(img_height, img_width, 3,))
res_net = ResNet50(include_top=False,
pooling='avg',
weights=resnet_weights,
input_shape=(img_height, img_width, 3))
for layer in res_net.layers:
layer.trainable = False
tower_1 = Model(inputs=res_net.input, outputs=res_net.layers[-1].output, name='resnet50_1')(input_1)
tower_2 = Model(inputs=res_net.input, outputs=res_net.layers[-1].output, name='resnet50_2')(input_2)
tower_3 = Model(inputs=res_net.input, outputs=res_net.layers[-1].output, name='resnet50_3')(input_3)
#tower_1.trainable = False
#tower_2.trainable = False
#tower_3.trainable = False
#tower_1 = ResNet50(include_top=False,
# pooling='avg',
# weights=resnet_weights) \
# (input_1)
#tower_1 = MaxPooling2D((1, 9), strides=(1, 1), padding='same')(tower_1)
#tower_2 = ResNet50(include_top=False,
# pooling='avg',
# weights=resnet_weights) \
# (input_2)
##tower_2 = MaxPooling2D((1, 9), strides=(1, 1), padding='same')(tower_2)
#tower_2.trainable = False
#tower_3 = ResNet50(include_top=False,
# pooling='avg',
# weights=resnet_weights) \
# (input_3)
##tower_3 = MaxPooling2D((1, 6), strides=(1, 1), padding='same')(tower_3)
#tower_3.trainable = False
difference_1 = subtract([tower_2, tower_1])
difference_2 = subtract([tower_3, tower_1])
#merged = concatenate([tower_1, tower_2, tower_3], axis=1)
merged = concatenate([difference_1, difference_2], axis=1)
merged = Flatten()(merged)
merged = Dropout(0.2)(merged)
out = Dense(20, activation='relu')(merged)
#out1 = Dropout(0.2)(out1)
#out2 = Dense(20, activation='relu')(out2)
out = Dense(2, activation='softmax')(out)
#model = Model(input_shape, out)
model = Model(inputs=[input_1, input_2, input_3], outputs=[out])
return model
def createModel(inputSize):
inputs = keras.Input(shape=(inputSize,
NeuralAI.NbOperators, NeuralAI.OpeStateSize + 3),
name="img") # shape (H, W, C)
norm = tf.keras.layers.LayerNormalization()(inputs)
x = tf.keras.layers.Conv2D(128, kernel_size=3, padding='same', kernel_initializer="random_normal")(norm)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation('relu')(x)
block_1_output = tf.keras.layers.MaxPool2D(pool_size=3, padding='same')(x)
block_2_output = ResnetBlock(128, 1, first_block=True)(block_1_output)
# block_3_output = ResnetBlock(256, 2)(block_2_output)
dense_input = layers.GlobalAveragePooling2D()(block_2_output) # block_3_output
dense_1 = layers.Dense(256, activation="relu")(dense_input)
x = layers.Dropout(0.5)(dense_1)
dense_2 = layers.Dense(NeuralAI.MaxDepth + 1)(x)
main_output = layers.Activation("softmax", name="main_output")(dense_2)
# reverse network
x = layers.Dense(256, activation="relu")(dense_2)
output_0 = layers.subtract([x, dense_1], name="output_0")
x = layers.Dropout(0.5)(x)
x = layers.Dense(128, activation="relu")(x)
output_1 = layers.subtract([x, dense_input], name="output_1")
x = tf.keras.layers.Reshape((1, 1, 128))(x)
x = tf.keras.layers.UpSampling2D((16, 5))(x)
"""x = DeResnetBlock(64, 2)(x)
output_2 = layers.subtract([x, block_2_output], name="output_2")"""
# x = tf.keras.layers.MaxPool2D((2, 2), strides=2)(x)
x = DeResnetBlock(128, 1)(x)
output_2 = layers.subtract([x, block_1_output], name="output_2")
x = tf.keras.layers.UpSampling2D((3, 3))(x)
x = tf.keras.layers.MaxPool2D(3, strides=1)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Conv2DTranspose(NeuralAI.OpeStateSize + 3, kernel_size=(2, 3),
kernel_initializer="random_normal")(x)
output_3 = layers.subtract([x, norm], name="output_3")
"""model = keras.Model(inputs, outputs, name="deepai")
opt = keras.optimizers.Adam(learning_rate=5 * 10 ** (-5))
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])"""
trainModel = keras.Model(inputs, [main_output, output_0, output_1, output_2, output_3], name="deepai_train")
"""opt = keras.optimizers.Adam(learning_rate=1 * 10 ** (-5))
trainModel.compile(loss=['categorical_crossentropy', 'mse'], loss_weights=[10, 10], optimizer=opt,
metrics=['accuracy'])"""
# trainModel.summary()
# model = extractTestModel(trainModel)
return trainModel
def construct_q_network(self):
input_layer = tfk.Input(shape = (self.observation_size * self.num_frames,), name="input_obs")
lay1 = tfkl.Dense(self.observation_size * 2, name="fc_1")(input_layer)
lay1 = tfka.relu(lay1, alpha=0.01) #leaky_relu
lay2 = tfkl.Dense(self.observation_size, name="fc_2")(lay1)
lay2 = tfka.relu(lay2, alpha=0.01) #leaky_relu
lay3 = tfkl.Dense(self.action_size * 3, name="fc_3")(lay2)
lay3 = tfka.relu(lay3, alpha=0.01) #leaky_relu
advantage = tfkl.Dense(self.action_size * 2, name="fc_adv")(lay3)
advantage = tfkl.Dense(self.action_size, name="adv")(advantage)
value = tfkl.Dense(self.action_size * 2, name="fc_val")(lay3)
value = tfkl.Dense(1, name="val")(value)
advantage_mean = tf.math.reduce_mean(advantage, axis=1, keepdims=True, name="adv_mean")
advantage = tfkl.subtract([advantage, advantage_mean], name="adv_subtract")
Q = tf.math.add(value, advantage, name="Qout")
self.model = tfk.Model(inputs=[input_layer], outputs=[Q],
name=self.__class__.__name__)
# Backwards pass
self.schedule = tfko.schedules.InverseTimeDecay(self.lr, self.lr_decay_steps, self.lr_decay_rate)
self.optimizer = tfko.Adam(learning_rate=self.schedule)
def ls(yt, yp):
f = dot([self.y2, self.x2], axes=-1, normalize=True)
fg = dot([self.g2, self.x2], axes=-1, normalize=True)
r = maximum(0.0, 0.3 + subtract([fg, f]))
r = sum(r, axis=-1)
return mean(r) # batch
def construct_q_network(self):
"""
It uses the architecture defined in the `nn_archi` attributes.
"""
self._model = Sequential()
input_layer = Input(shape=(self._nn_archi.observation_size, ),
name="observation")
lay = input_layer
for lay_num, (size, act) in enumerate(
zip(self._nn_archi.sizes, self._nn_archi.activs)):
lay = Dense(size, name="layer_{}".format(lay_num))(
lay) # put at self.action_size
lay = Activation(act)(lay)
fc1 = Dense(self._action_size)(lay)
advantage = Dense(self._action_size, name="advantage")(fc1)
fc2 = Dense(self._action_size)(lay)
value = Dense(1, name="value")(fc2)
meaner = Lambda(lambda x: K.mean(x, axis=1))
mn_ = meaner(advantage)
tmp = subtract([advantage, mn_])
policy = add([tmp, value], name="policy")
self._model = Model(inputs=[input_layer], outputs=[policy])
self._schedule_model, self._optimizer_model = self.make_optimiser()
self._model.compile(loss='mse', optimizer=self._optimizer_model)
self._target_model = Model(inputs=[input_layer], outputs=[policy])
def construct_q_network(self):
input_layer = tfk.Input(shape=(self.observation_size *
self.num_frames, ))
lay1 = tfkl.Dense(self.observation_size * self.num_frames)(input_layer)
lay2 = tfkl.Dense(512)(lay1)
lay2 = tfka.relu(lay2, alpha=0.01) #leaky_relu
lay3 = tfkl.Dense(256)(lay2)
lay3 = tfka.relu(lay3, alpha=0.01) #leaky_relu
lay4 = tfkl.Dense(128)(lay3)
lay4 = tfka.relu(lay4, alpha=0.01) #leaky_relu
advantage = tfkl.Dense(64)(lay4)
advantage = tfka.relu(advantage, alpha=0.01) #leaky_relu
advantage = tfkl.Dense(self.action_size)(advantage)
value = tfkl.Dense(64)(lay4)
value = tfka.relu(value, alpha=0.01) #leaky_relu
value = tfkl.Dense(1)(value)
advantage_mean = tf.math.reduce_mean(advantage, axis=1, keepdims=True)
advantage = tfkl.subtract([advantage, advantage_mean])
Q = tf.math.add(value, advantage)
self.model = tfk.Model(inputs=[input_layer], outputs=[Q])
self.model.compile(loss='mse', optimizer=tfko.Adam(lr=self.lr))
def DownProj(h_in, num_filters, kernel_size=12):
l0 = Conv2D(num_filters, kernel_size=kernel_size, strides=(scale_ratio,scale_ratio), padding='same',
kernel_initializer=test_initializer,
kernel_regularizer=l2(reg_scale))(h_in)
#l0 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(l0)
l0 = LeakyReLU(alpha=0.01)(l0)
h0 = Conv2DTranspose(num_filters, kernel_size=kernel_size, strides=(scale_ratio, scale_ratio), padding='same',
kernel_initializer=test_initializer,
kernel_regularizer=l2(reg_scale))(l0)
#h0 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(h0)
h0 = LeakyReLU(alpha=0.01)(h0)
e0 = subtract([h0, h_in])
l1 = Conv2D(num_filters, kernel_size=kernel_size, strides=(scale_ratio,scale_ratio), padding='same',
kernel_initializer=test_initializer,
kernel_regularizer=l2(reg_scale))(e0)
#l1 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(l1)
l1 = LeakyReLU(alpha=0.01)(l1)
out = add([l1, l0])
return out
def DenseDownProj(x_in, num_filters, kernel_size=12):
h_in = Conv2D(num_filters, kernel_size=1, strides=1, padding='same',
kernel_initializer=test_initializer,
kernel_regularizer=l2(reg_scale))(x_in)
h_in = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(h_in)
l0 = Conv2D(num_filters, kernel_size=kernel_size, strides=(8,8), padding='same',
kernel_initializer=test_initializer,
kernel_regularizer=l2(reg_scale))(h_in)
l0 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(l0)
h0 = Conv2DTranspose(num_filters, kernel_size=kernel_size, strides=(8, 8), padding='same',
kernel_initializer=test_initializer,
kernel_regularizer=l2(reg_scale))(l0)
h0 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(h0)
e0 = subtract([h0, h_in])
l1 = Conv2D(num_filters, kernel_size=kernel_size, strides=(8,8), padding='same',
kernel_initializer=test_initializer,
kernel_regularizer=l2(reg_scale))(e0)
l1 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(l1)
out = add([l1, l0])
return out
def construct_q_network(self):
# Uses the network architecture found in DeepMind paper
# The inputs and outputs size have changed, as well as replacing the convolution by dense layers.
self.model = Sequential()
input_layer = Input(shape=(self.observation_size *
self.training_param.NUM_FRAMES, ))
lay1 = Dense(self.observation_size *
self.training_param.NUM_FRAMES)(input_layer)
lay1 = Activation('relu')(lay1)
lay2 = Dense(self.observation_size)(lay1)
lay2 = Activation('relu')(lay2)
lay3 = Dense(2 * self.action_size)(lay2)
lay3 = Activation('relu')(lay3)
fc1 = Dense(self.action_size)(lay3)
advantage = Dense(self.action_size)(fc1)
fc2 = Dense(self.action_size)(lay3)
value = Dense(1)(fc2)
meaner = Lambda(lambda x: K.mean(x, axis=1))
mn_ = meaner(advantage)
tmp = subtract([advantage, mn_])
policy = add([tmp, value])
self.model = Model(inputs=[input_layer], outputs=[policy])
self.model.compile(loss='mse', optimizer=Adam(lr=self.lr_))
self.target_model = Model(inputs=[input_layer], outputs=[policy])
self.target_model.compile(loss='mse', optimizer=Adam(lr=self.lr_))
print("Successfully constructed networks.")
def build_optical_synthesis_generator(img_size=256, noise_dim=4):
"""
build the generator model that use the conventional reflection synthetic model.
the generator with the optical synthesis prior will only accept a noise-map from the encoder and convert it to
an (1) alpha blending mask for fusing the transmission layer T and reflection layer R. (2) convolution kernel
that blurs the reflection layer
:param img_size: image size for reflection image R, transmission layer T
:param noise_dim: noise_dim to concat with the input image (T, R)
:return: tf.keras.Model object. The generator model accepts three 4-D tensors: (1) T. (2) R. (3) noise layer.
The generator model will output two tensors:
(1) [alpha_blending_mask] with (256, 256, 3) for mixing two layers.
(2) [conv-kernel] used for blurring the reflection layer.
"""
in_layer = tf.keras.layers.Input(shape=(img_size, img_size, 3 + 3 + noise_dim))
# noise_in = tf.keras.layers.Input(shape=(img_size, img_size, noise_dim))
# T_in = tf.keras.layers.Input(shape=(img_size, img_size, 3))
# R_in = tf.keras.layers.Input(shape=(img_size, img_size, 3))
# split the input tensor
T_in, R_in, noise_in = tf.split(in_layer, [3, 3, noise_dim], axis=3)
ds1 = Component.get_conv_block(noise_dim, 32, norm=False)(noise_in)
ds2 = Component.get_conv_block(32, 64)(ds1)
ds3 = Component.get_conv_block(64, 128)(ds2) # d3: (32, 32)
ds4 = Component.get_conv_block(128, 256)(ds3)
ds5 = Component.get_conv_block(256, 256)(ds4)
ds6 = Component.get_conv_block(256, 256)(ds5)
us1 = Component.get_deconv_block(256, 256)(ds6)
us2 = Component.get_deconv_block(512, 256)(tf.concat([us1, ds5], axis=3))
us3 = Component.get_deconv_block(512, 128)(tf.concat([us2, ds4], axis=3))
us4 = Component.get_deconv_block(256, 64)(tf.concat([us3, ds3], axis=3)) # us4: (64, 64, 64)
us5 = Component.get_deconv_block(128, 32)(tf.concat([us4, ds2], axis=3)) # us5: (128, 128, 32)
# let us handle the conv kernel first
# us5 ---conv--- (32, 32, 16) ---reshape---> (32, 32, 3, 3)
# (1, 128, 128, 32) -> (1, 64, 64, 16)
down1 = Component.get_conv_block(32, 16)(us5)
# (1, 64, 64, 16) -> (1, 32, 32, 9)
down2 = Component.get_conv_block(16, 9)(down1)
kernel = tf.reshape(down2, [32, 32, 3, 3])
# the alpha blending mask
alpha_mask = Component.get_deconv_block(64, 3, norm=False, non_linear='leaky_relu')(
tf.concat([us5, ds1], axis=3))
alpha_mask_sub = layers.subtract([tf.ones_like(alpha_mask), alpha_mask])
# alpha_mask_sub = Component.get_deconv_block(64, 3, norm=False, non_linear='leaky_relu')(
# tf.concat([us5, ds1], axis=3))
# the blurring kernel
blurred_R = tf.nn.conv2d(R_in, kernel, strides=[1, 1, 1, 1], padding='SAME')
# transmission
t_layer = layers.multiply([T_in, alpha_mask])
r_layer = layers.multiply([blurred_R, alpha_mask_sub])
out = layers.add([t_layer, r_layer])
return tf.keras.Model(in_layer, out)
def get_tcn_model(sample_length, step_ahead=3, inner_encoding=8):
# TODO make it as class
def TCN_layer(units, x):
x = tf.expand_dims(x, axis=-1)
x = TCN(inner_encoding, kernel_size=2, dilations=[1, 2, 4], use_skip_connections=True)(x)
x = LayerNormalization()(x)
x = Dense(units)(x)
return x
in_seq = Input(shape=(sample_length, 3))
timeof = doubleDense(sample_length, in_seq[:, :, 2])
timeof2 = doubleDense(sample_length, in_seq[:, :, 2])
river = TCN_layer(step_ahead, subtract([in_seq[:, :, 0], timeof]))
rain = TCN_layer(step_ahead, subtract([in_seq[:, :, 1], timeof2]))
out = add([rain, river])
return Model(inputs=in_seq, outputs=out)
def DownBlock(x, num_filter, kernel_size=8, stride=4, padding=2, activation=LeakyReLU):
down_conv1 = Conv2D(filters=num_filter, kernel_size=kernel_size, strides=stride, padding=padding)
down_conv2 = Conv2DTranspose(filters=num_filter, kernel_size=kernel_size, strides=stride, padding=padding)
down_conv3 = Conv2D(filters=num_filter, kernel_size=kernel_size, strides=stride, padding=padding)
l0 = activation()(down_conv1(x))
h0 = activation()(down_conv2(l0))
l1 = activation()(down_conv3(subtract([h0, x])))
return add([l1, l0])
def UpBlock(x, num_filter, kernel_size=8, stride=4, padding='same', activation=LeakyReLU):
up_conv1 = Conv2DTranspose(filters=num_filter, kernel_size=kernel_size, strides=stride, padding=padding)
up_conv2 = Conv2D(filters=num_filter, kernel_size=kernel_size, strides=stride, padding=padding)
up_conv3 = Conv2DTranspose(filters=num_filter, kernel_size=kernel_size, strides=stride, padding=padding)
h0 = activation()(up_conv1(x))
l0 = activation()(up_conv2(h0))
h1 = activation()(up_conv3(subtract([l0, x])))
return add([h1, h0])
def get_lstm_model(sample_length, step_ahead=3, memory_units=8):
# TODO make it as class
def LSTM_layer_wrapper(units, x):
x = tf.expand_dims(x, axis=-1)
x = LSTM(units=memory_units)(x)
x = LayerNormalization()(x)
x = Dense(units)(x)
return x
in_seq = Input(shape=(sample_length, 3))
timeof = doubleDense(sample_length, in_seq[:, :, 2])
timeof2 = doubleDense(sample_length, in_seq[:, :, 2])
river = LSTM_layer_wrapper(step_ahead, subtract([in_seq[:, :, 0], timeof]))
rain = LSTM_layer_wrapper(step_ahead, subtract([in_seq[:, :, 1], timeof2]))
out = add([river, rain])
return Model(inputs=[in_seq], outputs=out)
def get_feed_forward_model(sample_length=128, step_ahead=3, inner_dimension=8):
# TODO make it as class
def encoding(units, x):
x = Dense(inner_dimension)(x)
x = LayerNormalization()(x)
x = Dense(units)(x)
x = LayerNormalization()(x)
return x
in_seq = Input(shape=(sample_length, 3))
timeof = doubleDense(sample_length, in_seq[:, :, 2])
timeof2 = doubleDense(sample_length, in_seq[:, :, 2])
river = encoding(step_ahead, subtract([in_seq[:, :, 0], timeof]))
rain = encoding(step_ahead, subtract([in_seq[:, :, 1], timeof2]))
out = add([rain, river])
return Model(inputs=in_seq, outputs=out)
def get_model(self):
"""
用于构建完整模型，即build_feature + Dense
:return:
model
"""
input_category = Input(shape=(self.category_count, ))
input_query1 = Input(shape=(self.query_len, ))
input_query2 = Input(shape=(self.query_len, ))
# Layer1: 特征抽取层
if self.shared:
# 调用了1次Model，是双塔共享模式
model = self.build_feature()
query_1 = model(input_query1)
query_2 = model(input_query2)
else:
# 调用了2次Model,是双塔非共享模型
query_1 = self.build_feature()(input_query1)
query_2 = self.build_feature()(input_query2)
if self.add_feature:
# |q1-q2| 两特征之差的绝对值
sub = subtract([query_1, query_2])
sub = tf.abs(sub)
# q1*q2 两特征按元素相乘
mul = multiply([query_1, query_2])
# max(q1,q2)^2 两特征取最大元素的平方
max_square = multiply(
[maximum([query_1, query_2]),
maximum([query_1, query_2])])
merge_layers = Concatenate()(
[query_1, query_2, sub, mul, max_square, input_category])
else:
merge_layers = Concatenate()([query_1, query_2, input_category])
# Layer2：全连接层
fc = None
for i in range(len(self.dense_units)):
if i == 0:
fc = Dense(self.dense_units[i],
activation="relu")(merge_layers)
elif i == len(self.dense_units) - 1:
fc = Dense(1, activation='sigmoid')(fc)
else:
fc = Dense(self.dense_units[i], activation="relu")(fc)
model = Model(inputs=[input_category, input_query1, input_query2],
outputs=[fc])
model.summary()
return model
def construct_q_network(self):
# Defines input tensors and scalars
self.trace_length = tf.Variable(1, dtype=tf.int32)
self.dropout_rate = tf.Variable(0.0, dtype=tf.float32, trainable=False)
input_mem_state = tfk.Input(dtype=tf.float32,
shape=(self.h_size),
name='input_mem_state')
input_carry_state = tfk.Input(dtype=tf.float32,
shape=(self.h_size),
name='input_carry_state')
input_layer = tfk.Input(dtype=tf.float32,
shape=(None, self.observation_size),
name='input_obs')
# Forward pass
lay1 = tfkl.Dense(512)(input_layer)
# Bayesian NN simulate
lay1 = tfkl.Dropout(self.dropout_rate)(lay1)
lay2 = tfkl.Dense(256)(lay1)
lay2 = tfka.relu(lay2, alpha=0.01) #leaky_relu
lay3 = tfkl.Dense(128)(lay2)
lay3 = tfka.relu(lay3, alpha=0.01) #leaky_relu
lay4 = tfkl.Dense(self.h_size)(lay3)
# Recurring part
lstm_layer = tfkl.LSTM(self.h_size, return_state=True)
lstm_input = lay4
lstm_state = [input_mem_state, input_carry_state]
lay5, mem_s, carry_s = lstm_layer(lstm_input, initial_state=lstm_state)
lstm_output = lay5
# Advantage and Value streams
advantage = tfkl.Dense(64)(lstm_output)
advantage = tfka.relu(advantage, alpha=0.01) #leaky_relu
advantage = tfkl.Dense(self.action_size)(advantage)
value = tfkl.Dense(64)(lstm_output)
value = tfka.relu(value, alpha=0.01) #leaky_relu
value = tfkl.Dense(1)(value)
advantage_mean = tf.math.reduce_mean(advantage, axis=1, keepdims=True)
advantage = tfkl.subtract([advantage, advantage_mean])
Q = tf.math.add(value, advantage)
# Backwards pass
self.model = tfk.Model(
inputs=[input_mem_state, input_carry_state, input_layer],
outputs=[Q, mem_s, carry_s])
losses = ['mse', self.no_loss, self.no_loss]
self.model.compile(loss=losses, optimizer=tfko.Adam(lr=self.lr))
self.model.summary()
def __init__(self, model_params):
super(SiameseModel, self).__init__()
max_len = model_params['max_len']
embedding_matrix = model_params['embedding_matrix']
num_unique_words = model_params['num_unique_words']
embedding_dim = model_params['embedding_dim']
self.sentence_1 = Input(shape=(None, ))
self.sentence_2 = Input(shape=(None, ))
self.sentence_1_embedding = Embedding(num_unique_words,embedding_dim,\
embeddings_initializer=keras.initializers.Constant(embedding_matrix),\
trainable=False)(self.sentence_1)
self.sentence_2_embedding = Embedding(num_unique_words,embedding_dim,\
embeddings_initializer=keras.initializers.Constant(embedding_matrix),\
trainable=False)(self.sentence_2)
self.len_sent_1 = Input(shape=(None, 1), dtype='int32')
self.len_sent_2 = Input(shape=(None, 1), dtype='int32')
#self.squared_diff = Multiply([tf_sum(self.difference),tf_sum(self.difference)])
self.shared_lstm = LSTM(1000)
self.question_1_encoding = self.shared_lstm(self.sentence_1_embedding)
self.question_2_encoding = self.shared_lstm(self.sentence_2_embedding)
self.Hadamard = Multiply()(
[self.question_1_encoding, self.question_2_encoding])
self.difference = subtract(
[self.question_1_encoding, self.question_2_encoding])
self.squared_euclidean_distance = tf_sum(
Multiply()([self.difference, self.difference]), axis=1)
self.squared_euclidean_distance = k.expand_dims(
self.squared_euclidean_distance, axis=-1)
self.features = concatenate([self.question_1_encoding, self.question_2_encoding,\
self.Hadamard, self.squared_euclidean_distance],)
self.h1 = Dense(800, activation='relu')(self.features)
self.dropout1 = keras.layers.Dropout(0.7)(self.h1)
self.h2 = Dense(800, activation='relu')(self.dropout1)
self.dropout2 = keras.layers.Dropout(0.7)(self.h2)
self.out = Dense(2, activation='softmax')(self.dropout2)
initial_learning_rate = model_params['lr']
decay_rate = model_params['lr_decay_rate']
learning_rate = keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate,
decay_steps=10000,
decay_rate=decay_rate,
staircase=True)
optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
self.model = Model(inputs=[
self.sentence_1, self.sentence_2, self.len_sent_1, self.len_sent_2
],
outputs=[self.out])
self.model.compile(loss="binary_crossentropy",
optimizer=optimizer,
metrics=['binary_accuracy', f1_m])
def create_stack(self,
input_tensor: Input,
stack_ix: int = 0,
stack_weights: str = 'none') -> Model:
output_weights = self.create_output_weights(stack_weights)
model = self.create_basic_block(input_tensor, 0, stack_ix)
backcasts = [model.outputs[0]]
forecasts = [model.outputs[1]]
for i in range(1, self.block_length):
input_tensor = subtract([model.input, model.outputs[0]])
model = self.create_basic_block(input_tensor, i, stack_ix)
backcasts.append(model.outputs[0])
forecasts.append(model.outputs[1])
return Model(input=input_tensor, output=add(forecasts))
def get_model(self):
# 加载预训练模型
bert = build_bert_model(
config_path=self.config_path, checkpoint_path=self.checkpoint_path,
with_pool=True, return_keras_model=False, model="albert")
# query1 = bert.model()([q1_token_in, q1_seg_in])
# query2 = bert.model()([q2_token_in, q2_seg_in])
q1_x_in = Input(shape=(None, ), name='Input-Token-q1')
q2_x_in = Input(shape=(None,), name='Input-Token-q2')
q1_s_in = Input(shape=(None,), name='Input-Segment-q1')
q2_s_in = Input(shape=(None,), name='Input-Segment-q2')
input_layer = bert.model.input
input_layer.extend(bert.model.input)
query1 = Dropout(rate=0.1)(bert.model.output)
query2 = Dropout(rate=0.1)(bert.model.output)
# |q1-q2| 两特征之差的绝对值
sub = tf.abs(subtract([query1, query2]))
# q1*q2 两特征按元素相乘
mul = multiply([query1, query2])
# max(q1,q2)^2 两特征取最大元素的平方
max_square = multiply([maximum([query1, query2]), maximum([query1, query2])])
merge_layers = Concatenate()([query1, query2, sub, mul, max_square])
merge_layers = Dropout(rate=0.1)(merge_layers)
fc = None
for i in range(len(self.dense_units)):
if i == 0:
fc = Dense(self.dense_units[i], activation="relu", kernel_initializer=bert.initializer)(merge_layers)
elif i == len(self.dense_units) - 1:
fc = Dense(units=2, activation='softmax', kernel_initializer=bert.initializer)(fc)
else:
fc = Dense(self.dense_units[i], activation="relu", kernel_initializer=bert.initializer)(fc)
model = Model(input_layer, fc)
model.summary()
return model
def forward_streams(self, hidden, q_len, name):
# Advantage stream
advantage = tfkl.Dense(64, name=name+"_fcadv")(hidden)
advantage = tf.nn.leaky_relu(advantage, alpha=0.01, name=name+"_leakyadv")
advantage = tfkl.Dense(q_len, name=name+"_adv")(advantage)
advantage_mean = tf.math.reduce_mean(advantage, axis=1,
keepdims=True,
name=name+"_adv_mean")
advantage = tfkl.subtract([advantage, advantage_mean],
name= name+"_adv_sub")
# Value stream
value = tfkl.Dense(64, name=name+"_fcval")(hidden)
value = tf.nn.leaky_relu(value, alpha=0.01, name=name+"_leakyval")
value = tfkl.Dense(1, name=name+"_val")(value)
# Q values = val + adv
slice_q = tf.math.add(value, advantage, name=name+"_sliceq")
return slice_q
def construct_q_network(self):
"""
First the :attr:`l2rpn_baselines.BaseDeepQ.nn_archi` parameters are used to create a neural network
to 'encode' the data. Then the leaps occur.
Afterward the model is split into value an advantage, and treated as usually in any D3QN.
"""
# Uses the network architecture found in DeepMind paper
# The inputs and outputs size have changed, as well as replacing the convolution by dense layers.
self._model = Sequential()
input_x = Input(shape=(self._nn_archi.x_dim, ), name="x")
inputs_tau = [
Input(shape=(el, ), name="tau_{}".format(nm_)) for el, nm_ in zip(
self._nn_archi.tau_dims, self._nn_archi.list_attr_obs_tau)
]
lay = input_x
for (size, act) in zip(self._nn_archi.sizes, self._nn_archi.activs):
lay = Dense(size)(lay) # put at self.action_size
lay = Activation(act)(lay)
# TODO multiple taus
l_tau = lay
for el, nm_ in zip(inputs_tau, self._nn_archi.list_attr_obs_tau):
l_tau = l_tau + LtauBis(name="leap_{}".format(nm_))([lay, el])
advantage = Dense(self._action_size)(l_tau)
value = Dense(1, name="value")(l_tau)
meaner = Lambda(lambda x: K.mean(x, axis=1))
mn_ = meaner(advantage)
tmp = subtract([advantage, mn_])
policy = add([tmp, value], name="policy")
self._model = Model(inputs=[input_x, *inputs_tau], outputs=[policy])
self._schedule_model, self._optimizer_model = self.make_optimiser()
self._model.compile(loss='mse', optimizer=self._optimizer_model)
self._target_model = Model(inputs=[input_x, *inputs_tau],
outputs=[policy])
def construct_D3QN(self):
input_layer = tfkl.Input(shape=(self.observation_size *
self.num_frames, ))
layer1 = tfkl.Dense(self.observation_size *
self.num_frames)(input_layer)
layer1 = tfka.relu(layer1, alpha=0.01) #Leaky ReLU
layer2 = tfkl.Dense(self.observation_size * 2)(layer1)
layer2 = tfka.relu(layer2, alpha=0.01)
layer3 = tfkl.Dense(self.observation_size)(layer2)
layer3 = tfka.relu(layer3, alpha=0.01)
layer4 = tfkl.Dense(self.action_size * 3)(layer3)
layer4 = tfka.relu(layer4, alpha=0.01)
value_stream = tfkl.Dense(self.action_size * 2)(layer4)
value_stream = tfka.relu(value_stream, alpha=0.01)
V = tfkl.Dense(1)(value_stream)
advantage_stream = tfkl.Dense(self.action_size * 2)(layer4)
advantage_stream = tfka.relu(advantage_stream, alpha=0.01)
advantage = tfkl.Dense(self.action_size)(advantage_stream)
advantage_mean = tf.math.reduce_mean(advantage, axis=1, keepdims=True)
A = tfkl.subtract([advantage, advantage_mean])
Q = tf.math.add(V, A)
self.model = tfk.Model(inputs=[input_layer], outputs=[Q])
self.schedule = tfko.schedules.InverseTimeDecay(
self.lr, self.lr_decay_steps, self.lr_decay_rate)
self.optimizer = tfko.Adam(learning_rate=self.schedule)
self.target_model = tfk.Model(inputs=[input_layer], outputs=[Q])
self.target_model.set_weights(self.model.get_weights())
return
def construct_q_network(self):
# Uses the network architecture found in DeepMind paper
# The inputs and outputs size have changed, as well as replacing the convolution by dense layers.
self.model = Sequential()
input_x = Input(shape=(self.observation_size -
(self.tau_dim_end - self.tau_dim_start), ),
name="x")
input_tau = Input(shape=(self.tau_dim_end - self.tau_dim_start, ),
name="tau")
lay1 = Dense(self.observation_size)(input_x)
lay1 = Activation('relu')(lay1)
lay2 = Dense(self.observation_size)(lay1)
lay2 = Activation('relu')(lay2)
lay3 = Dense(2 * self.action_size)(lay2) # put at self.action_size
lay3 = Activation('relu')(lay3)
l_tau = Ltau()((lay3, input_tau))
fc1 = Dense(self.action_size)(l_tau)
advantage = Dense(self.action_size)(fc1)
fc2 = Dense(self.action_size)(lay3)
value = Dense(1)(fc2)
meaner = Lambda(lambda x: K.mean(x, axis=1))
mn_ = meaner(advantage)
tmp = subtract([advantage, mn_])
policy = add([tmp, value], name="policy")
self.model = Model(inputs=[input_x, input_tau], outputs=[policy])
self.schedule_model, self.optimizer_model = self.make_optimiser()
self.model.compile(loss='mse', optimizer=self.optimizer_model)
self.target_model = Model(inputs=[input_x, input_tau],
outputs=[policy])
print("Successfully constructed networks.")
def construct_q_network(self):
# Defines input tensors and scalars
self.trace_length = tf.Variable(1, dtype=tf.int32, name="trace_length")
self.dropout_rate = tf.Variable(0.0,
dtype=tf.float32,
trainable=False,
name="dropout_rate")
input_mem_state = tfk.Input(dtype=tf.float32,
shape=(self.h_size),
name='input_mem_state')
input_carry_state = tfk.Input(dtype=tf.float32,
shape=(self.h_size),
name='input_carry_state')
input_layer = tfk.Input(dtype=tf.float32,
shape=(None, self.observation_size),
name='input_obs')
# Get shapes from input_layer
batch_size = tf.shape(input_layer)[0]
trace_len = tf.shape(input_layer)[1]
data_size = tf.shape(input_layer)[-1]
# Reshape for dense processing
input_format = tf.reshape(input_layer, (-1, input_layer.shape[-1]),
name="dense_reshape")
# Bayesian NN simulate
lay1 = tfkl.Dropout(self.dropout_rate,
name="bnn_dropout")(input_format)
# Forward pass
lay1 = tfkl.Dense(512, name="fc_1")(lay1)
lay1 = tf.nn.leaky_relu(lay1, alpha=0.01, name="leak_fc_1")
lay2 = tfkl.Dense(256, name="fc_2")(lay1)
lay2 = tf.nn.leaky_relu(lay2, alpha=0.01, name="leak_fc_2")
lay3 = tfkl.Dense(128, name="fc_3")(lay2)
lay3 = tf.nn.leaky_relu(lay3, alpha=0.01, name="leak_fc_3")
lay4 = tfkl.Dense(self.h_size, name="fc_4")(lay3)
# Reshape to (batch_size, trace_len, data_size) for rnn
rnn_format = tf.reshape(lay4, (batch_size, trace_len, self.h_size),
name="rnn_reshape")
# Recurring part
lstm_layer = tfkl.LSTM(self.h_size, return_state=True, name="lstm")
lstm_state = [input_mem_state, input_carry_state]
lstm_output, mem_s, carry_s = lstm_layer(rnn_format,
initial_state=lstm_state)
# Advantage and Value streams
advantage = tfkl.Dense(64, name="fc_adv")(lstm_output)
advantage = tf.nn.leaky_relu(advantage, alpha=0.01, name="leak_adv")
advantage = tfkl.Dense(self.action_size, name="adv")(advantage)
advantage_mean = tf.math.reduce_mean(advantage,
axis=1,
keepdims=True,
name="adv_mean")
advantage = tfkl.subtract([advantage, advantage_mean], name="adv_sub")
value = tfkl.Dense(64, name="fc_val")(lstm_output)
value = tf.nn.leaky_relu(value, alpha=0.01, name="leak_val")
value = tfkl.Dense(1, name="val")(value)
Q = tf.math.add(value, advantage, name="Qout")
# Backwards pass
model_inputs = [input_mem_state, input_carry_state, input_layer]
model_outputs = [Q, mem_s, carry_s]
self.model = tfk.Model(inputs=model_inputs,
outputs=model_outputs,
name=self.__class__.__name__)
losses = [self._mse_loss, self._no_loss, self._no_loss]
self.optimizer = tfko.Adam(lr=self.lr, clipnorm=1.0)
self.model.compile(loss=losses, optimizer=self.optimizer)
embedding = Embedding(corpus_length, vector_dim, input_length=1)
reshape = Reshape((vector_dim, 1))
input_main = Input((1, ))
input_search_words = Input((1, ))
main_embedding = reshape(embedding(input_main))
search_words_embedding = reshape(embedding(input_search_words))
similarity = Reshape((1, ))(dot([main_embedding, search_words_embedding],
axes=1,
normalize=True))
output = Dense(1, activation='sigmoid')(similarity)
# output2 = dot([main_embedding, search_words_embedding], axes=0)
subtract_layer = subtract([main_embedding, search_words_embedding])
eucledian_output = multiply([subtract_layer, subtract_layer])
# eucledian_output = dot([main_embedding, search_words_embedding], axes=1, normalize = True)
model = Model(inputs=[input_main, input_search_words], outputs=output)
model.compile(loss='binary_crossentropy', optimizer='adam')
Euclid_Model = Model(inputs=[input_main, input_search_words],
outputs=eucledian_output)
Embeddings = Model(inputs=[input_main], outputs=main_embedding)
#The creation of the model has been refernced from the following link - https://adventuresinmachinelearning.com/word2vec-keras-tutorial/
def sum_values(pred):
def createModel():
#5.1 Set input shape which is 1 channel of 42x42 2D image
inputShape = (20, 16, 1)
inputs = Input(shape=inputShape)
inputs2 = Conv2D(16, (2, 2),
padding="same",
strides=(1, 1),
kernel_initializer='he_normal',
activation='relu')(inputs)
inputs2 = Conv2D(32, (2, 2),
padding="same",
strides=(1, 1),
kernel_initializer='he_normal',
activation='relu')(inputs2)
#5.2 Auto encoder
#This is to process the input so the neccessary feature that can be used for image reconstruction can be gathered.
#5.2.1 First hidden layer. 64 neurons, downsize the image to (21,21). Conv2D is chosen over maxPooling as it allow the filter kernel to be trained.
'''
x = Conv2D(64, (8,1), padding="same",strides=(1,2),kernel_initializer='he_normal', activation='relu')(inputs)
encoded = Conv2D(40, (4,1), padding="same",strides=(1,2),kernel_initializer='he_normal', activation='relu')(x)
x = UpSampling2D(size=(1, 2))(encoded)
x = Conv2D(40, (4,1), padding="same",kernel_initializer='he_normal', activation='relu')(x)
x = UpSampling2D(size=(1, 2))(x)
x = Conv2D(64, (8,1), padding="same",kernel_initializer='he_normal', activation='relu')(x)
x = Dense(1, name="horizontal")(x)
'''
'''
#horizontal
x = AveragePooling2D(pool_size=(1, 8), strides=(1,8))(inputs)
x = Lambda(lambda x: x - 0.375)(x)
x = Activation("relu")(x)
x = Lambda(lambda x: x *1024)(x)
x = Activation("tanh")(x)
x = UpSampling2D(size=(1, 8))(x)
#vertical
x2 = AveragePooling2D(pool_size=(5, 1), strides=(5,1))(inputs)
x2 = Lambda(lambda x2: x2 - 0.33)(x2)
x2 = Activation("relu")(x2)
x2 = Lambda(lambda x2: x2 *1024)(x2)
x2 = Activation("tanh")(x2)
x2 = UpSampling2D(size=(5, 1))(x2)
#heat trap
x3 = AveragePooling2D(pool_size=(4, 4), strides=(4,4))(inputs)
x3 = Lambda(lambda x3: x3 - 0.25)(x3)
x3 = Activation("relu")(x3)
x3 = Lambda(lambda x3: x3 *1024)(x3)
x3 = Activation("tanh")(x3)
x3 = UpSampling2D(size=(4, 4))(x3)
'''
#heat trap
#x3 = AveragePooling2D(pool_size=(4, 4), strides=(4,4))(inputs2)
x3 = inputs2
x3 = Conv2D(32, (4, 4),
padding="same",
strides=(4, 4),
kernel_initializer='he_normal',
activation='relu')(x3)
x3_2 = Lambda(lambda x3: x3 - 0.2)(x3)
x3_2 = Activation("relu")(x3_2)
x3_2 = Lambda(lambda x3_2: x3_2 + 0.2)(x3_2)
x3_2 = Lambda(lambda x3_2: x3_2 * 8)(x3_2)
x3 = multiply([x3, x3_2])
#x3 = Activation("tanh")(x3)
x3 = UpSampling2D(size=(4, 4))(x3)
#x3 = multiply([x3,inputs])
x3 = Lambda(lambda x3: x3 * 0.5)(x3)
#x3a = AveragePooling2D(pool_size=(2, 2), strides=(2,2))(inputs2)
x3a = inputs2
x3a = Conv2D(32, (2, 2),
padding="same",
strides=(2, 2),
kernel_initializer='he_normal',
activation='relu')(x3a)
x3a_2 = Lambda(lambda x3a: x3a - 0.2)(x3a)
x3a_2 = Activation("relu")(x3a_2)
x3a_2 = Lambda(lambda x3a_2: x3a_2 + 0.2)(x3a_2)
x3a_2 = Lambda(lambda x3a_2: x3a_2 * 8)(x3a_2)
x3a = multiply([x3a, x3a_2])
#x3a = Activation("tanh")(x3a)
x3a = UpSampling2D(size=(2, 2))(x3a)
#x3a = multiply([x3a,inputs])
x3a = Lambda(lambda x3a: x3a * 0.5)(x3a)
x3 = add([x3, x3a], name="cluster")
#vertical
#x2 = subtract([inputs,x3])
x2 = inputs2
#x2 = AveragePooling2D(pool_size=(5, 1), strides=(5,1))(x2)
x2 = Conv2D(32, (5, 1),
padding="same",
strides=(5, 1),
kernel_initializer='he_normal',
activation='relu')(x2)
x2_2 = Lambda(lambda x2: x2 - 0.2)(x2)
x2_2 = Activation("relu")(x2_2)
x2_2 = Lambda(lambda x2_2: x2_2 + 0.2)(x2_2)
x2_2 = Lambda(lambda x2_2: x2_2 * 8)(x2_2)
x2 = multiply([x2, x2_2])
#x2 = Activation("tanh")(x2)
x2 = UpSampling2D(size=(5, 1), name='vertical')(x2)
#x2= multiply([x2,inputs], name='vertical')
#x2 = add([x2,x2a])
#horizontal
#x = subtract([inputs,x3])
#x = subtract([x,x2])
x = inputs2
#x = AveragePooling2D(pool_size=(1, 8), strides=(1,8))(x)
x = Conv2D(32, (1, 8),
padding="same",
strides=(1, 8),
kernel_initializer='he_normal',
activation='relu')(x)
#x = Lambda(lambda x: x *8)(x)
x_2 = Lambda(lambda x: x - 0.2)(x)
x_2 = Activation("relu")(x_2)
x_2 = Lambda(lambda x_2: x_2 + 0.2)(x_2)
x_2 = Lambda(lambda x_2: x_2 * 8)(x_2)
x = multiply([x, x_2])
#x = Activation("relu")(x)
x = UpSampling2D(size=(1, 8), name="horizontal")(x)
#x = multiply([x,inputs])
#x = add([x,xa])
y = subtract([inputs2, x])
y = subtract([y, x2])
y = subtract([y, x3])
#y = Lambda(lambda y: y * 8)(y)
#y = Lambda(lambda y: y - 0.125)(y)
y = Activation("relu", name="pepper")(y)
#y = Lambda(lambda y: y *1024)(y)
#y = Activation("tanh")(y)
#y = multiply([y,inputs])
#=======================================================
'''
x = Conv2D(32, (1,8), padding="same",strides=(1,8),kernel_initializer='he_normal', activation='relu')(x)
x = Lambda(lambda x: x - 0.1)(x)
x = Activation("relu")(x)
x = Lambda(lambda x: x * 1.5)(x)
#x = Lambda(lambda x: x * 8)(x)
x_code = Conv2D(16, (2,1), padding="same",strides=(1,1),kernel_initializer='he_normal', activation='relu')(x)
x = UpSampling2D(size=(1,8), name="horizontal" )(x_code)
#x2 = Dense(1)(x2)
x2 = Conv2D(32, (5,1), padding="same",strides=(5,1),kernel_initializer='he_normal', activation='relu')(x2)
x2 = Lambda(lambda x2: x2 - 0.1)(x2)
x2 = Activation("relu")(x2)
x2 = Lambda(lambda x2: x2 * 1.5)(x2)
#x2 = Lambda(lambda x2: x2 * 8)(x2)
x2_code = Conv2D(16, (2,1), padding="same",strides=(1,1),kernel_initializer='he_normal', activation='relu')(x2)
x2 = UpSampling2D(size=(5, 1), name="vertical" )(x2_code)
#x2 = Dense(1)(x2)
x3 = Conv2D(32, (4,4), padding="same",strides=(4,4),kernel_initializer='he_normal', activation='relu')(x3)
x3 = Lambda(lambda x3: x3 - 0.1)(x3)
x3 = Activation("relu")(x3)
x3_code = Lambda(lambda x3: x3 * 1.5)(x3)
#x3_code = Lambda(lambda x3: x3 * 16)(x3)
#x3 = Dropout(0.3)(x3)
x3 = UpSampling2D(size=(4, 4) )(x3_code)
x3 = Dense(1)(x3)
x3b = Conv2D(32, (6,6), padding="same",strides=(4,4),kernel_initializer='he_normal', activation='relu')(x3)
x3b = Lambda(lambda x3b: x3b - 0.1)(x3b)
x3b = Activation("relu")(x3b)
x3b_code = Lambda(lambda x3b: x3b * 1.5)(x3b)
#x3b_code = Lambda(lambda x3b: x3b * 16)(x3b)
#x3b = Dropout(0.3)(x3b)
x3b = UpSampling2D(size=(4, 4) )(x3b_code)
x3b = Dense(1)(x3b)
x3c = Conv2D(32, (2,2), padding="same",strides=(2,2),kernel_initializer='he_normal', activation='relu')(x3)
x3c = Lambda(lambda x3c: x3c - 0.1)(x3c)
x3c = Activation("relu")(x3c)
x3c_code = Lambda(lambda x3c: x3c * 1.5)(x3c)
#x3c_code = Lambda(lambda x3c: x3c * 4)(x3c)
#x3c = Dropout(0.3)(x3c)
x3c = UpSampling2D(size=(2, 2) )(x3c_code)
x3c = Dense(1)(x3c)
x3 = add([x3,x3b,x3c])
x3 = Lambda(lambda x3: x3 /3, name="cluster")(x3)
y = Conv2D(32, (2,2), padding="same",strides=(1,1),kernel_initializer='he_normal', activation='relu')(y)
y = Conv2D(16, (2,2), padding="same",strides=(1,1),kernel_initializer='he_normal', activation='relu', name="pepper")(y)
#y = Dropout(0.3)(y)
#y = Conv2D(1, (1,1), padding="same",strides=(1,1),kernel_initializer='he_normal', activation='relu')(y)
#y = Dense(1)(y)
#y = Lambda(lambda y: y - 0.1)(y)
#y = Activation("relu")(y)
#y = Lambda(lambda y: y *1024)(y)
#y = Activation("tanh")(y)
#y = multiply([y,inputs])
#y = subtract([y,x], name="pepper")
'''
#outputs = add([x,x2,x3,y])
#outputs = Lambda(lambda outputs: outputs /4)(outputs)
outputs = concatenate([x, x2, x3])
outputs = Conv2D(16, (2, 2),
padding="same",
strides=(1, 1),
kernel_initializer='he_normal',
activation='relu')(outputs)
outputs = Conv2D(8, (2, 2),
padding="same",
strides=(1, 1),
kernel_initializer='he_normal',
activation='relu')(outputs)
#outputs = Conv2D(1, (2,2), padding="same",strides=(1,1),kernel_initializer='he_normal', activation='relu')(outputs)
'''
xx=Flatten()(x_code)
xx2=Flatten()(x2_code)
xx3a=Flatten()(x3_code)
xx3b=Flatten()(x3b_code)
xx3c=Flatten()(x3c_code)
classifier=concatenate([xx,xx2,xx3a,xx3b,xx3c])
classifier=Dense(64,kernel_initializer='he_normal', activation='relu')(classifier)
classifier=Dense(8,kernel_initializer='he_normal', activation='softmax')(classifier)
'''
model = Model(inputs=inputs, outputs=outputs)
model.compile(loss='mean_squared_error',
optimizer=optimizers.RMSprop(),
metrics=['accuracy'])
model2 = Model(inputs=inputs, outputs=outputs)
model2.compile(loss='mean_squared_error',
optimizer=optimizers.RMSprop(),
metrics=['accuracy'])
#model2 = Model(inputs=inputs,outputs=classifier)
#model2.compile(loss='categorical_crossentropy', optimizer=optimizers.Adam() , metrics=['accuracy'])
return model, model2
max2_2 = MaxPooling2D((2, 2), strides=(2, 2))(batch2_2)
conv2_3 = Convolution2D(256, (3, 3), activation='selu')(max2_2)
batch2_3 = BatchNormalization()(conv2_3)
max2_3 = MaxPooling2D((2, 2), strides=(2, 2))(batch2_3)
conv2_4 = Convolution2D(256, (3, 3), activation='selu')(max2_3)
batch2_4 = BatchNormalization()(conv2_4)
fcl2 = Flatten()(batch2_4)
dense2_1 = Dense(4096, activation='selu')(fcl2)
dense2_2 = Dense(1024, activation='selu')(dense2_1)
X2 = Input(shape=(HEIGHT, WIDTH, 3))
# flatten and dense twice
fcl3 = Flatten()(batch3_4)
dense3_1 = Dense(4096, activation='selu')(fcl3)
dense3_2 = Dense(1024, activation='selu')(dense3_1)
dense_layer = backend.abs(subtract([dense_2, dense2_2]))
#dense to 1 output
out = Dense(1,
activation='sigmoid',
kernel_regularizer=regularizers.l1(1e-3))(dense_layer)
#hyper
siamese_net = Model(inputs=[X, X1], outputs=out)
print(siamese_net.summary())
siamese_net.compile(loss='binary_crossentropy',
optimizer=keras.optimizers.Adam(learning_rate=5e-6,
beta_1=0.9,
beta_2=0.999),
metrics=['accuracy'])
siamese_net.fit([x_right, x_pos],
y1,
def subNode(self, inputNode1, inputNode2, name=""):
if inputNode1.shape() != inputNode2.shape():
self.logger("dimensionality error with " + str(inputNode1) +
" and " + str(inputNode2) + " in pytorch")
return None
return layers.subtract([inputNode1, inputNode2], name=name)
