def _absDifference(self, input1, input2):
"""
Compute absolute value of difference of two tensor
Parameters:
- input1 -- 1-st operand
- input2 -- 2-nd operand
"""
_diff1 = layers.Subtract()([input1, input2])
_diff2 = layers.Subtract()([input2, input1])
#return layers.Maximum()([_diff1, _diff2])
return layers.Minimum()([_diff1, _diff2])
def build_model():
x1 = layers.Input(shape = (160, 160, 1))
x2 = layers.Input(shape = (160, 160, 1))
# share weights both inputs
inputs = layers.Input(shape = (160, 160, 1))
feature = layers.Conv2D(32, kernel_size = 3, padding = 'same', activation = 'relu')(inputs)
feature = layers.MaxPooling2D(pool_size = 2)(feature)
feature = layers.Conv2D(32, kernel_size = 3, padding = 'same', activation = 'relu')(feature)
feature = layers.MaxPooling2D(pool_size = 2)(feature)
feature_model = Model(inputs = inputs, outputs = feature)
# two feature models that sharing weights
x1_net = feature_model(x1)
x2_net = feature_model(x2)
# subtract features
net = layers.Subtract()([x1_net, x2_net])
net = layers.Conv2D(32, kernel_size = 3, padding = 'same', activation = 'relu')(net)
net = layers.MaxPooling2D(pool_size = 2)(net)
net = layers.Flatten()(net)
net = layers.Dense(64, activation = 'relu')(net)
net = layers.Dense(1, activation = 'sigmoid')(net)
model = Model(inputs = [x1, x2], outputs = net)
# compile
model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['acc'])
# show summary
model.summary()
return model
def _create_latent_space_loss(self, latent_space_1, latent_space_2):
subtract_out = layers.Subtract()([latent_space_1, latent_space_2])
power_out = layers.Lambda(lambda x: backend.pow(subtract_out, 2))(subtract_out)
sum_out = layers.Lambda(lambda x: backend.sum(power_out, axis=[1,2,3]))(power_out)
mean_out = layers.Lambda(lambda x: backend.mean(sum_out, axis=0))(sum_out)
reg_out = layers.Lambda(lambda x: x * self.Regularization.latent_space_lambda)(mean_out)
identity_out = layers.Lambda(lambda x: x, name="latent_space_loss")(reg_out)
return identity_out
def build_model(self):
# Conv layers.
conv_8 = keras.layers.Conv2D(filters=256,
kernel_size=[3, 3],
strides=(1, 1),
padding='valid',
activation='relu')
# Dense layers.
dense_1 = keras.layers.Dense(units=1024,
activation='relu',
use_bias=True)
dense_2 = keras.layers.Dense(units=1,
activation='sigmoid',
use_bias=True)
# Batch norm layers.
bn_8 = keras.layers.BatchNormalization()
bn_9 = keras.layers.BatchNormalization()
# Flatten layers.
flatten_1 = keras.layers.Flatten()
# All layers got. Define the forward propgation.
input_1 = layers.Input(shape=(self.img_width, self.img_height, 1),
name='image_input_1')
input_2 = layers.Input(shape=(self.img_width, self.img_height, 1),
name='image_input_2')
output_1 = self.feature_net(input_1)
output_2 = self.feature_net(input_2)
sub = layers.Subtract()([output_1, output_2])
# |== Layer 5 ==|
x = conv_8(sub)
x = bn_8(x)
# |== Layer 6 ==|
x = flatten_1(x)
x = dense_1(x)
x = bn_9(x)
out_res = dense_2(x)
model = Model(inputs=[input_1, input_2], outputs=out_res)
# show summary
print('Main Model Summary')
model.summary()
# compile
model.compile(loss='binary_crossentropy',
optimizer=optimizers.Adam(lr=1e-4),
metrics=['acc'])
return model
def build_siamese_net(encoder,
input_shape,
distance_metric='uniform_euclidean'):
assert distance_metric in ('uniform_euclidean', 'weighted_euclidean',
'uniform_l1', 'weighted_l1', 'dot_product',
'cosine_distance')
input_1 = layers.Input(input_shape)
input_2 = layers.Input(input_shape)
encoded_1 = encoder(input_1)
encoded_2 = encoder(input_2)
if distance_metric == 'weighted_l1':
# This is the distance metric used in the original one-shot paper
# https://www.cs.cmu.edu/~rsalakhu/papers/oneshot1.pdf
embedded_distance = layers.Subtract()([encoded_1, encoded_2])
embedded_distance = layers.Lambda(lambda x: K.abs(x))(
embedded_distance)
output = layers.Dense(1, activation='sigmoid')(embedded_distance)
elif distance_metric == 'uniform_euclidean':
# Simpler, no bells-and-whistles euclidean distance
# Still apply a sigmoid activation on the euclidean distance however
embedded_distance = layers.Subtract(name='subtract_embeddings')(
[encoded_1, encoded_2])
# Sqrt of sum of squares
embedded_distance = layers.Lambda(
lambda x: K.sqrt(K.sum(K.square(x), axis=-1, keepdims=True)),
name='euclidean_distance')(embedded_distance)
output = layers.Dense(1, activation='sigmoid')(embedded_distance)
elif distance_metric == 'cosine_distance':
raise NotImplementedError
# cosine_proximity = layers.Dot(axes=-1, normalize=True)([encoded_1, encoded_2])
# ones = layers.Input(tensor=K.ones_like(cosine_proximity))
# cosine_distance = layers.Subtract()([ones, cosine_proximity])
# output = layers.Dense(1, activation='sigmoid')(cosine_distance)
else:
raise NotImplementedError
siamese = Model(inputs=[input_1, input_2], outputs=output)
return siamese
def model():
input_1 = layers.Input(shape=target_size + (1, ))
input_2 = layers.Input(shape=target_size + (1, ))
subtract = layers.Subtract()([input_2, input_1])
#subtract = layers.Subtract()([subtract, input_1])
x = layers.MaxPooling3D(8)(subtract)
model = Model(inputs=[input_1, input_2], outputs=x)
return model
def get_edges(xi_xj):
"""
Get the edge features, derived from the central point and
the neighboring points.
Output shape: (bs, n_nodes, n_neighbors, 2*n_features)
"""
xi, xj = xi_xj
dif = layers.Subtract()([xi, xj])
x = layers.Concatenate(axis=-1)([xi, dif])
return x
def __init__(self, shared_dim, quality_dim, activation, **kwargs): super(ContrastiveLayer, self).__init__(**kwargs) self.dense_share = layers.Dense(shared_dim, activation=activation) self.dense_mean = layers.Dense(quality_dim) self.dense_logstd = layers.Dense(quality_dim) self.sub = layers.Subtract() self.clip = layers.Lambda(lambda x:K.clip(x, -20, 2)) self.exp = layers.Lambda(lambda x:K.exp(x))
def get_reflection_recovery_and_removal_block():
def get_conv_block(f=64, k=3, s=1):
model = keras.Sequential()
model.add(
layers.Conv2D(filters=f,
strides=s,
kernel_size=k,
padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
return model
def get_deconv_block(f=64, k=3, s=1):
model = keras.Sequential()
model.add(
layers.Conv2DTranspose(filters=f,
strides=s,
kernel_size=k,
padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
return model
inp = keras.Input(shape=(None, None, 3))
# 256 -> 128
conv1 = get_conv_block(f=32, s=2)(inp)
conv2 = get_conv_block(f=32, s=1)(conv1)
# 128 -> 64
conv3 = get_conv_block(f=64, s=2)(conv2)
conv4 = get_conv_block(f=64, s=1)(conv3)
# 64 -> 32
conv5 = get_conv_block(f=128, s=2)(conv4)
conv6 = get_conv_block(f=128, s=1)(conv5)
deconv6 = get_deconv_block(f=128, s=1)(conv6)
deconv5 = get_deconv_block(f=128, s=2)(deconv6)
concat1 = tf.concat([conv4, deconv5], axis=3)
deconv4 = get_deconv_block(f=64, s=1)(concat1)
deconv3 = get_deconv_block(f=64, s=2)(deconv4)
concat2 = tf.concat([conv2, deconv3], axis=3)
deconv2 = get_deconv_block(f=32, s=1)(concat2)
deconv1 = get_deconv_block(f=3, s=2)(deconv2)
r = layers.Subtract()([inp, deconv1])
return keras.Model(inp, r)
def get_dncnn(image_size: int = 32, image_chnls: int = 3, depth: int = 17, n_channels: int = 64) -> tf.keras.Model: """Constructs a DNCNN model. :param image_size: size of the images (int) :param image_chnls: number of channels in the inputs images (int) :param depth: depth of the network (int) :param n_channels: number of channels in the convolutional layers (int) :return: DNCNN model """ inputs = layers.Input((image_size, image_size, image_chnls)) outputs = run_dncnn(inputs, depth=depth, n_channels=n_channels) outputs = layers.Subtract()([inputs, outputs]) return tf.keras.Model(inputs, outputs)
def kernel_nn(data, nodes=16):
d1, d2 = data # get xi ("central" pixel) and xj ("neighborhood" pixels)
dif = layers.Subtract()([d1, d2])
x = layers.Concatenate(axis=-1)([d1, dif])
x = layers.Dense(nodes, use_bias=False, activation="relu")(x)
x = layers.BatchNormalization()(x)
x = layers.Dense(nodes, use_bias=False, activation="relu")(x)
x = layers.BatchNormalization()(x)
x = layers.Dense(nodes, use_bias=False, activation="relu")(x)
x = layers.BatchNormalization()(x)
return x
def SiameseNetwork(input_shape):
inp_1 = tf.keras.Input(shape=input_shape)
inp_2 = tf.keras.Input(shape=input_shape)
encoder1 = Encoder(input_shape = (5388, 20, 3), embedding_dimension = 128)
encoder2 = Encoder(input_shape = (5388, 20, 3), embedding_dimension = 128)
#Encode each branch
embeds1 = encoder1(inp_1)
embeds2 = encoder2(inp_2)
#Siamese network
embedded_distance = layers.Subtract(name='subtract_embeddings')([embeds1, embeds2])
embedded_distance1 = layers.Lambda(lambda x: tf.sqrt(tf.reduce_sum(tf.square(x), axis=-1, keepdims=True)), name='euclidean_distance')(embedded_distance)
siamese_out = layers.Dense(2, activation='sigmoid', name="OutputLayer")(embedded_distance1)
#Model
siamesemodel = tf.keras.Model(inputs=[inp_1,inp_2], outputs = siamese_out)
return (siamesemodel, encoder1, encoder2)
def model(embedding_size, field_vocab_size=[], hidden_units=[4,4,4], dropout=0.5):
F = len(field_vocab_size)
# prepare embeddings
inputs = []
embed_list = []
embed_one_list = []
for i, vocab_size in enumerate(field_vocab_size):
in_ = keras.Input(shape=(1,))
inputs.append(in_)
embed_list.append(layers.Embedding(vocab_size, embedding_size, input_length=1)(in_))
embed_one_list.append(layers.Embedding(vocab_size, 1, input_length=1)(in_))
embed_list = layers.concatenate(embed_list, axis=1) # none, F, K
fm_first_in = layers.concatenate(embed_one_list, axis=1) # None, F, 1
fm_first_in = layers.Lambda(lambda x: backend.squeeze(x, axis=2))(fm_first_in)
# dense layer
dropouts = [dropout] * len(hidden_units)
weight_init = keras.initializers.glorot_uniform()
deep_in = layers.Reshape((F*embedding_size,))(embed_list)
for i, (h, d) in enumerate(zip(hidden_units, dropouts)):
z = layers.Dense(units=h, kernel_initializer=weight_init)(deep_in)
z = layers.BatchNormalization(axis=-1)(z)
z = layers.Activation("relu")(z)
z = layers.Dropout(d,seed=d * i)(z) if d > 0 else z
deep_out = layers.Dense(units=1, activation=tf.nn.softmax, kernel_initializer=weight_init)(z)
# deep_out: None, 1
# fm layer
fm_first_order = layers.Lambda(lambda x: backend.sum(x, axis=1))(fm_first_in) #None, 1
emb_sum_squared = layers.Lambda(lambda x: backend.square(backend.sum(x, axis=1)))(embed_list) #none, K
emb_squared_sum = layers.Lambda(lambda x: backend.sum(backend.square(x), axis=1))(embed_list) #none, K
fm_second_order = layers.Subtract()([emb_sum_squared, emb_squared_sum])
fm_second_order = layers.Lambda(lambda x: backend.sum(x, axis=1))(fm_second_order) #none, 1
fm_out = layers.Add()([fm_first_order, fm_second_order])
out = layers.Add()([deep_out, fm_out])
out = layers.Activation(activation='sigmoid')(out)
model = keras.Model(inputs=inputs, outputs=out)
return model
def build_model(self):
input = keras.Input(shape=self.state_size)
x = layers.Conv2D(32, 8, strides=(4, 4), activation="relu")(input)
x = layers.Conv2D(64, 4, strides=(2, 2), activation="relu")(x)
#x = layers.Conv2D(64, 3, strides=(2,2), activation="relu")(x)
x = layers.Flatten()(x)
value_fc = layers.Dense(512, activation="relu")(x)
value = layers.Dense(1)(value_fc)
advantage_fc = layers.Dense(512, activation="relu")(x)
advantage = layers.Dense(NUM_ACTIONS)(advantage_fc)
advantage_norm = layers.Subtract()(
[advantage,
tf.reduce_mean(advantage, axis=1, keepdims=True)])
aggregation = layers.Add()([value, advantage_norm])
output = layers.Dense(NUM_ACTIONS)(aggregation)
model = keras.Model(input, output)
model.compile(optimizer=keras.optimizers.Adam(self.learning_rate),
loss=self.PER_loss())
return model
def build_model(self):
# shared_model = build_stacked_rnn_model(self)
shared_model = self.base_network_build_fn()
# shared_model = build_multi_attention_model(self)
t_status = shared_model.output
# 攻击动作，则采用基础标量 + 均值为0的向量策略
value = layers.Dense(1)(t_status)
# 这力可以直接广播，不需要拼接
# # value = concatenate([value] * self.action_num)
a = layers.Dense(self.action_num)(t_status)
mean = layers.Lambda(lambda x: K.mean(x, axis=1, keepdims=True))(a)
advantage = layers.Subtract()([a, mean])
q = layers.Add()([value, advantage])
model = Model(shared_model.input, q, name=self.model_type)
model.compile(optimizer=Adam(lr=self.lr), loss='mse')
return model
def build_q_network(n_actions: int, input_shape: Tuple[int]=(84, 84), history_length: int=4):
model_input = layers.Input(shape=(input_shape[0], input_shape[1], history_length))
x = layers.Lambda(lambda layer: layer / 255)(model_input) # normalize by 255
x = layers.Conv2D(32, (8, 8), strides=4, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
x = layers.Conv2D(64, (4, 4), strides=2, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
x = layers.Conv2D(64, (3, 3), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
x = layers.Conv2D(1024, (7, 7), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
# Split into value and advantage streams
val_stream, adv_stream = layers.Lambda(lambda w: tf.split(w, 2, 3))(x) # custom splitting layer
val_stream = layers.Flatten()(val_stream)
val = layers.Dense(1, kernel_initializer=VarianceScaling(scale=2.))(val_stream)
adv_stream = layers.Flatten()(adv_stream)
adv = layers.Dense(n_actions, kernel_initializer=VarianceScaling(scale=2.))(adv_stream)
# Combine streams into Q-Values
reduce_mean = layers.Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True)) # custom layer for reduce mean
q_vals = layers.Add()([val, layers.Subtract()([adv, reduce_mean(adv)])])
# Build model
model = Model(model_input, q_vals)
# model.compile(Adam(learning_rate), loss=tf.keras.losses.Huber())
return model
# # Read more about de dueling
# class DuelingDQN(Model):
# """
# This is a implementation of Dueling Network propose in https://arxiv.org/pdf/1511.06581.pdf
# """
# def __init__(self, n_action: int, input_shape: Tuple[int], history_length: int = 4) -> None:
# super(DuelingDQN, self).__init__()
# self._input_shape = input_shape
# self.history_length = history_length
# # Define convolutional layers
# self.convolution = Sequential([
# layers.Lambda(lambda inputs: inputs / 255.), # Normalize input
# layers.Conv2D(32, kernel_size=(8, 8), strides=4, activation='relu'),
# layers.Conv2D(64, kernel_size=(4, 4), strides=2, activation='relu'),
# layers.Conv2D(64, kernel_size=(3, 3), strides=1, activation='relu'),
# layers.Conv2D(1024, kernel_size=(7, 7), strides=1, activation='relu')
# ])
# # split between value_stream and advantage_stream
# self.split = layers.Lambda(lambda w: split(w, 2, 3))
# # Advantage stream forward
# self.advantage_stream = Sequential([
# layers.Flatten(),
# layers.Dense(n_action, kernel_initializer=VarianceScaling(scale=2.))
# ])
# # Value stream forward
# self.value_stream = Sequential([
# layers.Flatten(),
# layers.Dense(1, kernel_initializer=VarianceScaling(scale=2.))
# ])
# # Putting all together
# self.reduce_mean = layers.Lambda(lambda w: reduce_mean(w, axis=1, keepdims=True))
# self.subtract = layers.Subtract()
# self.outputs = layers.Add()
# def call(self, inputs: Tensor) -> Tensor:
# x = layers.Input(shape=(self._input_shape[0], self._input_shape[1], self.history_length))(inputs)
# x = self.convolution(x)
# value_stream, advantage_stream = self.split(x)
# value_stream = self.value_stream(value_stream)
# advantage_stream = self.advantage_stream(advantage_stream)
# subtracted = self.subtract([advantage_stream, self.reduce_mean(advantage_stream)])
# return self.outputs([value_stream, subtracted])
shape=(time_sound, nfreqs,
1)) # define input (rows, columns, channels (only one in my case))
model_l_conv1 = layers.Conv2D(32, (5, 5), activation='relu', padding='same')(
in1) # define first layer and input to the layer
model_l_conv1_mp = layers.MaxPooling2D(pool_size=(1, 2))(model_l_conv1)
model_l_conv1_mp_do = layers.Dropout(0.2)(model_l_conv1_mp)
# CNN 1 - right channel
in2 = layers.Input(shape=(time_sound, nfreqs, 1)) # define input
model_r_conv1 = layers.Conv2D(32, (5, 5), activation='relu', padding='same')(
in2) # define first layer and input to the layer
model_r_conv1_mp = layers.MaxPooling2D(pool_size=(1, 2))(model_r_conv1)
model_r_conv1_mp_do = layers.Dropout(0.2)(model_r_conv1_mp)
# CNN 2 - merged
model_final_merge = layers.Subtract()(
[model_l_conv1_mp_do, model_r_conv1_mp_do])
model_final_conv1 = layers.Conv2D(32, (5, 5),
activation='relu',
padding='same')(model_final_merge)
model_final_conv1_mp = layers.MaxPooling2D(pool_size=(2, 2))(model_final_conv1)
model_final_conv1_mp_do = layers.Dropout(0.2)(model_final_conv1_mp)
# CNN 3 - merged
model_final_conv2 = layers.Conv2D(64, (5, 5),
activation='relu',
padding='same')(model_final_conv1_mp_do)
model_final_conv2_mp = layers.MaxPooling2D(pool_size=(2, 2))(model_final_conv2)
model_final_conv2_mp_do = layers.Dropout(0.2)(model_final_conv2_mp)
# CNN 4 - merged
model_final_conv3 = layers.Conv2D(128, (5, 5),
dropout = 0.01
activation = "relu"
optimizer = 'Adam'
loss = 'categorical_crossentropy'
#metrics= ['acc']
metrics = ['categorical_accuracy']
class_mode = 'categorical'
batch_size = 200
epochs = 100
verbose = 2
lr = 0.0001
# Our input feature map is 150x150x3: 150x150 for the image pixels, and 3 for the three color channels: R, G, and B
img_input1 = layers.Input(shape=target_size + (1, ))
img_input2 = layers.Input(shape=target_size + (1, ))
img_input = layers.Subtract()([img_input2, img_input1])
net = layers.Conv3D(kernel_size,
conv_window,
activation=activation,
padding='valid',
strides=4)(img_input)
x = layers.MaxPooling3D(pooling_window)(net)
x = layers.Conv3D(2 * kernel_size,
conv_window,
activation=activation,
padding='same',
strides=1)(x)
x = layers.MaxPooling3D(pooling_window)(x)
x = layers.Conv3D(6 * kernel_size,
conv_window,
activation=activation,
def build(self, name: str, show_summary=False):
input_layer = layers.Input(shape=(*Constants.FRAME_SHAPE,
self.actions),
name='input_layer')
scaling_layer = layers.Lambda(lambda layer: layer / 255,
name="scale")(input_layer)
# Use the same model as the paper
# "The first convolutional layer has 32 8x8 filters with stride 4" and applies a rectifier nonlinearity
hidden_layer1 = layers.Conv2D(
filters=32,
kernel_size=(8, 8),
strides=4,
activation=tf.nn.relu,
kernel_initializer=keras.initializers.VarianceScaling(scale=2),
padding="valid",
use_bias=False,
name='hidden_layer1')(scaling_layer)
# "The second convolves 64 4×4 filters with stride 2" followed by a rectifier nonlinearity
hidden_layer2 = layers.Conv2D(
filters=64,
kernel_size=(4, 4),
strides=2,
activation=tf.nn.relu,
kernel_initializer=keras.initializers.VarianceScaling(scale=2),
padding="valid",
use_bias=False,
name='hidden_layer2')(hidden_layer1)
# "The third and final convolution layer consists 64 3x3 filters with stride 1" followed by a rectifier
hidden_layer3 = layers.Conv2D(
filters=64,
kernel_size=(3, 3),
strides=1,
activation=tf.nn.relu,
kernel_initializer=keras.initializers.VarianceScaling(scale=2),
padding="valid",
use_bias=False,
name='hidden_layer3')(hidden_layer2)
# It is recommended to use another convolution layer instead of 2 separate fully connected layers with 512 units
hidden_layer4 = layers.Conv2D(
filters=1024,
kernel_size=(7, 7),
strides=1,
activation=tf.nn.relu,
kernel_initializer=keras.initializers.VarianceScaling(scale=2),
padding="valid",
use_bias=False,
name='hidden_layer4')(hidden_layer3)
# Split into value and advantage streams
value_stream, advantage_stream = layers.Lambda(
lambda layer: tf.split(layer, 2, 3), name="split")(hidden_layer4)
# Flatten each stream
flattened_value_stream = layers.Flatten(
name="value_flattened")(value_stream)
flattened_advantage_stream = layers.Flatten(
name="advantage_flattened")(advantage_stream)
# Create value stream output layer: 1 output
value_output_layer = layers.Dense(
1,
kernel_initializer=keras.initializers.VarianceScaling(scale=2),
name="value_output")(flattened_value_stream)
# Create advantage stream output layer: output per action
advantage_output_layer = layers.Dense(
self.actions, name="advantage_output")(flattened_advantage_stream)
# Q value given an action and state =
# value output of state +
# (advantage output given an action and state - reduction mean of advantage output over all actions)
# reduction mean of advantage output over all actions
reduce_mean_layer = layers.Lambda(
lambda layer: tf.reduce_mean(layer, axis=1, keepdims=True),
name="reduce_mean")
# (advantage output given an action and state - reduction mean of advantage output over all actions)
subtract_layer = layers.Subtract(name="q_sub")([
advantage_output_layer,
reduce_mean_layer(advantage_output_layer)
])
# Q values given action and state
q_values = layers.Add(name="q_output")(
[value_output_layer, subtract_layer])
# Build model using Huber loss and Adam optimizer
model = tf.keras.models.Model(input_layer, q_values, name=name)
model.compile(optimizer=keras.optimizers.Adam(
learning_rate=HyperParams.LEARNING_RATE),
loss=tf.keras.losses.Huber())
if show_summary:
# Show Summary
model.summary()
return model
