def construct_DQN(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)
layer5 = tfkl.Dense(self.action_size * 2)(layer4)
layer5 = tfka.relu(layer5, alpha=0.01)
output = tfkl.Dense(self.action_size)(layer5)
self.model = tfk.Model(inputs=[input_layer], outputs=[output])
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=[output])
self.target_model.set_weights(self.model.get_weights())
return
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 build_encoder_cnn_16_32_32_norm_pool(frame):
inputs = Input(shape=frame.input_shape, name='encoder_input')
x = inputs
x = Conv2D(filters=16, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
x = Conv2D(filters=32, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
x = Conv2D(filters=32, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
frame.shape = K.int_shape(x)
x = Flatten()(x)
latent = Dense(frame.latent_dim, name='latent_vector')(x)
frame.encoder = Model(inputs, latent, name='encoder')
frame.inputs = inputs
def residual_block(in_shape, out_dim, kernel=5, reg=0.01):
"""Construct a residual block using convolutions and skip connections
Arguments:
in_shape -- shape of the input tensor
out_dim -- size of the channel dimension in the output (i.e. number of Conv1D filters)
kernel -- size of the kernel in the Conv1D layers (default 5)
reg -- regularization parameter (default 0.01)
"""
in_dim = in_shape[-1]
inpt = Input(in_shape)
skip = inpt
# If the number of output channels is different than input channels, we need to transform the
# input dim to the same size so that they can be added together in the skip connection.
if in_dim != out_dim:
skip = Conv1D(out_dim, activation=None, kernel_size=1, strides=1, use_bias=False,
kernel_regularizer=tf.keras.regularizers.l2(l=reg))(skip)
x = BatchNormalization()(inpt)
x = relu(x)
x = Conv1D(out_dim, activation=None, kernel_size=kernel, padding='same', use_bias=False,
kernel_regularizer=tf.keras.regularizers.l2(l=reg))(x)
x = BatchNormalization()(x)
x = relu(x)
x = Conv1D(out_dim, activation=None, kernel_size=kernel, padding='same',
kernel_regularizer=tf.keras.regularizers.l2(l=reg))(x)
x = x + skip
model = Model(inputs=inpt, outputs=x)
return model
def call(self, inputs):
# layer 1 with image input
c_1 = self.conv1(inputs['image'])
c_1 = BatchNormalization()(c_1)
c_1 = relu(c_1)
# layer 2
c_2 = self.conv2(c_1)
c_2 = BatchNormalization()(c_2)
c_2 = relu(c_2)
# layer 3
c_3 = self.conv3(c_2)
c_3 = BatchNormalization()(c_3)
c_3 = relu(c_3)
c_3 = Flatten()(c_3)
# connect layer 3 output to d4_image layer
d_4_image = self.dense4_image(c_3)
d_4_image = BatchNormalization()(d_4_image)
# connect state input to d4_image layer
d_4_state = self.dense4_state(inputs['robot_state'])
d_4_state = BatchNormalization()(d_4_state)
# add the outputs of two layers and activate
d_4 = tf.add(d_4_image, d_4_state)
d_4 = relu(d_4)
return d_4
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 inverted_res_block(inputs, expansion, stride, alpha, filters, block_id, skip_connection, rate=1):
in_channels = inputs.shape[-1]
pointwise_conv_filters = int(filters * alpha)
pointwise_filters = _make_divisible(pointwise_conv_filters, 8)
x = inputs
prefix = 'expanded_conv_{}_'.format(block_id)
if block_id:
# Expand
x = Conv2D(expansion * in_channels, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'expand')(x)
x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN')(x)
#x = Activation(tf.nn.relu6, name=prefix + 'expand_relu')(x)
x = Lambda(lambda x: relu(x, max_value=6.), name=prefix + 'expand_relu')(x)
else:
prefix = 'expanded_conv_'
# Depthwise
x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None,
use_bias=False, padding='same', dilation_rate=(rate, rate), name=prefix + 'depthwise')(x)
x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN')(x)
#x = Activation(tf.nn.relu6, name=prefix + 'depthwise_relu')(x)
x = Lambda(lambda x: relu(x, max_value=6.), name=prefix + 'depthwise_relu')(x)
# Project
x = Conv2D(pointwise_filters, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'project')(x)
x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x)
if skip_connection:
return Add(name=prefix + 'add')([inputs, x])
return x
def build_encoder_cnn_16_32_64_512(frame):
'''
scored 0.24 RMSE with descent loss history for reconstruction autoencoder
'''
inputs = Input(shape=frame.input_shape, name='encoder_input')
x = inputs
x = Conv2D(filters=16, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
#x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
x = Conv2D(filters=32, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
#x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
x = Conv2D(filters=64, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
frame.shape = K.int_shape(x)
x = Flatten()(x)
latent = Dense(frame.latent_dim, name='latent_vector')(x)
frame.encoder = Model(inputs, latent, name='encoder')
frame.inputs = inputs
def call(self, inputs, condition):
"""Computes a forward pass of the decoder
Args:
inputs (tf.Tensor): input data, shape=(batch size, sample length, 1)
condition (tf.Tensor): conditioning data from encoder,
should be shape (batch size, encoding length, encoding channels)
This tensor will be upsampled so that the second dimensions (lengths)
between the input and conditions match
"""
c = self.upsample(inputs, condition)
resid = self.causal_conv(inputs)
skip = self.skip_conv(resid)
for wavenet_layer in self.dilated_layers:
resid, s = wavenet_layer(resid, c)
skip += s
skip = relu(skip)
skip = self.final_conv(skip)
skip = skip + self.condition_conv(c)
skip = relu(skip)
out = self.class_conv(skip)
return out
def build_decoder_cnn_16_32_32_norm_pool(frame):
latent_inputs = Input(shape=(frame.latent_dim,), name='decoder_input')
x = Dense(frame.shape[1] * frame.shape[2] * frame.shape[3])(latent_inputs)
x = Reshape((frame.shape[1], frame.shape[2], frame.shape[3]))(x)
x = Conv2DTranspose(filters=32, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(filters=32, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(filters=16, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(filters=3, kernel_size=frame.kernel_size, padding='same')(x)
outputs = Activation('sigmoid', name='decoder_output')(x)
frame.decoder = Model(latent_inputs, outputs, name='decoder')
def build_encoder_cnn_16_32_16(frame):
'''best autoencoder performance for RMSE or Binary
'''
inputs = Input(shape=frame.input_shape, name='encoder_input')
x = inputs
x = Conv2D(filters=16, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
x = Conv2D(filters=32, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
x = Conv2D(filters=16, kernel_size=frame.kernel_size, strides=1, padding='same')(x)
x = BatchNormalization(trainable=False)(x)
x = relu(x)
x = MaxPooling2D(pool_size = (2, 2), padding='same')(x)
# Shape info needed to build Decoder Model
frame.shape = K.int_shape(x)
# Generate the latent vector
x = Flatten()(x)
latent = Dense(frame.latent_dim, name='latent_vector')(x)
# Instantiate Encoder Model
frame.encoder = Model(inputs, latent, name='encoder')
frame.inputs = inputs
def identity_block(input_tensor, kernel_size, filters, stage, block,
width_increment):
"""The identity block is the block that has no conv layer at shortcut.
This block has grouped convolution implementation.
# Arguments
input_tensor: input tensor
kernel_size: default 3, the kernel size of
middle conv layer at main path
filters: list of integers, the filters of 3 conv layer at main path
stage: integer, current stage label, used for generating layer names
block: 'a','b'..., current block label, used for generating layer names
# Returns
Output tensor for the block.
"""
filters1, filters2, filters3 = filters
if backend.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
grouped_convolution = []
for i in range(CARDINALITY):
x = layers.BatchNormalization(axis=bn_axis,
name=bn_name_base + '2a' +
f'_{i}')(input_tensor)
x = activations.relu(x)
x = layers.Conv2D(int(round(filters1 / CARDINALITY)) * 2, (1, 1),
kernel_initializer='he_normal',
name=conv_name_base + '2a' + f'_{i}')(x)
x = layers.BatchNormalization(axis=bn_axis,
name=bn_name_base + '2b' + f'_{i}')(x)
x = activations.relu(x)
x = layers.Conv2D(int(round(filters1 / CARDINALITY)) * 2,
kernel_size,
padding='same',
kernel_initializer='he_normal',
name=conv_name_base + '2b' + f'_{i}')(x)
grouped_convolution.append(x)
x = layers.concatenate(grouped_convolution, axis=-1)
x = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x)
x = activations.relu(x)
x = layers.Conv2D(filters3, (1, 1),
kernel_initializer='he_normal',
name=conv_name_base + '2c')(x)
# Split Input tensor to its residual and dense components
residual_input = layers.Lambda(lambda x: x[:, :, :, :filters3])(
input_tensor)
dense_input = layers.Lambda(lambda x: x[:, :, :, filters3:])(input_tensor)
# Extract the grwoth increment from the last convolution
dense_increment = layers.Lambda(lambda x: x[:, :, :, :width_increment])(x)
x = layers.add([residual_input, x])
x = layers.concatenate([x, dense_input, dense_increment], axis=bn_axis)
return x
def call(self, inputs):
x = inputs
x = relu(x)
x = self.dilated_conv(x)
x = relu(x) # default will be using the ReLU activation, but can change if necessary
x = self.conv_1x1(x)
return inputs + x
def call(self, x, training=False):
inputs = x
x = relu(self.bn1(self.conv1(x), training=training))
x = self.bn2(self.conv2(x), training=training)
x = x + inputs #: skip connection
x = relu(x)
return x
def get_xception():
"""Returns a Xception pretrained neural net.
The function returns a partially pretrained Xception neural net.
Returns:
A modified Xception semi-pre-trained NN instance
"""
model = Xception(include_top=False)
model.trainable = False
core_output = model.layers[45].output
# Weighting Xception output via channel and spatial Attention
channel_attention_map = channel_attention(core_output)
channel_weighted = core_output * channel_attention_map
spatial_attention_map = spatial_attention(channel_weighted)
core_output = channel_weighted * spatial_attention_map
for _ in range(5):
output = relu(core_output)
output = SeparableConvolution2D(728, (3, 3),
padding='same',
depthwise_regularizer=L2(0.2),
pointwise_regularizer=L2(0.03))(output)
output = BatchNormalization()(output)
output = Dropout(0.3)(output)
output = relu(output)
output = SeparableConvolution2D(728, (3, 3),
padding='same',
depthwise_regularizer=L2(0.2),
pointwise_regularizer=L2(0.03))(output)
output = BatchNormalization()(output)
output = Dropout(0.3)(output)
core_output = Add()[output, core_output]
# Output Weighting via Attention
channel_attention_map = channel_attention(core_output)
channel_weighted = core_output * channel_attention_map
spatial_attention_map = spatial_attention(channel_weighted)
core_output = channel_weighted * spatial_attention_map
model_output = GlobalAvgPool2D()(core_output)
model_output = Dense(1, activation='sigmoid')(model_output)
model = Model(inputs=model.input, outputs=model_output)
return model
def call(self, inputs, training=False):
""" Implements the feed forward part of the network """
x = inputs
for layer in self.layers_[:-1]:
x = layer(x)
x = relu(x, alpha=self.leaky_alpha)
x = self.dropout(x, training)
x = self.layers_[-1](x)
x = relu(x, alpha=self.leaky_alpha)
return tf.reshape(x, [-1, self.ps, self.ps, self.shape_out])
def v1(self):
out1 = Conv2D(kernel_size=(1, 1), filters=256)(self.features1)
out1 = relu(BatchNormalization()(out1))
# output 2
out2 = Conv2D(kernel_size=(1, 1), filters=512)(self.features2)
out2 = relu(BatchNormalization()(out2))
out2 = UpSampling2D(size=(2, 2))(out2)
# output
out = tf.concat([out1, out2], -1)
return out
def call(self, inputs, states):
# h(t) = activation(
# Wh x(t) + Uh h(t-1) + bh)
h = states[-1]
hh = K.dot(inputs, self.Wh) + K.dot(h, self.Uh)
hh = activations.relu(K.bias_add(hh, self.bh))
# y(t) = activate(Wy h(t) + by)
y = K.dot(hh, self.Wy)
y = K.bias_add(y, self.by)
return activations.relu(y), [hh]
def call(self, x, inter=None):
# Encoding
if self.in_channels == 3:
x1 = relu(self.bne1(self.conv1(x)))
else:
x1 = relu(self.bne1(self.conv1_clean(x)))
x2 = relu(self.bne2(self.conv2(x1)))
x3 = relu(self.bne3(self.conv3(x2)))
x3 = self.flatten(x3)
x4 = relu(self.bne4(self.fce1(x3)))
x5 = self.fce2(x4)
means = self.mean_params(x5)
stddev = tf.math.exp(0.5 * self.stddev_params(x5))
eps = random_normal(tf.shape(stddev))
# Decoding
z = means + eps * stddev
if inter is not None:
z = tf.keras.layers.add([z, inter])
x6 = relu(self.bnd1(self.fcd1(z)))
x7 = relu(self.bnd2(self.fcd2(x6)))
x7 = self.reshape(x7)
x8 = relu(self.bnd3(self.deconv1(x7)))
x9 = relu(self.bnd4(self.deconv2(x8)))
if self.out_channels == 3:
x10 = self.deconv3(x9)
else:
x10 = self.deconv3_clean(x9)
return x10, means, stddev, z
def call(self, inputs):
"""
:param inputs: [batch_size, 256, 256, 3]
:return: probabilities of shape [batch_size, num_classes]
"""
output1 = self.pool1(relu(self.batch_norm1(self.conv1(inputs))))
output2 = self.pool2(relu(self.batch_norm2(self.conv2(output1))))
output3 = self.pool3(relu(self.batch_norm3(self.conv3(output2))))
output3 = self.flatten(output3)
return self.dense2(self.dense1(output3))
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 dist(self, x):
"""
Get distribution for atoms
"""
feature = self.feature_layer(x)
adv_hid = relu(self.advantage_hidden_layer(feature))
val_hid = relu(self.value_hidden_layer(feature))
advantage = tf.reshape(self.advantage_layer(adv_hid), [-1, self.out_dim, self.atom_size])
value = tf.reshape(self.value_layer(val_hid), [-1, 1, self.atom_size])
q_atoms = value + advantage - tf.math.reduce_mean(advantage, axis=1, keepdims=True)
dist = softmax(q_atoms, axis=-1)
return tf.clip_by_value(dist, clip_value_min=1e-3, clip_value_max=float('inf')) # for avoiding NaNs
def forward(self):
# encoder
encoder_outs = []
for i in range(self.config["model"]["scales"]):
if i == 0:
conv_out = Conv2D(kernel_size=(3, 3),
strides=(2, 2),
filters=256,
padding='same')(self.features)
elif i == self.config["model"]["scales"] - 1:
conv_out = Conv2D(kernel_size=(3, 3),
strides=(2, 2),
filters=256)(encoder_outs[i - 1])
else:
conv_out = Conv2D(kernel_size=(3, 3),
strides=(2, 2),
filters=256,
padding='same')(encoder_outs[i - 1])
encoder_outs.append(relu(BatchNormalization()(conv_out)))
# decoder
decoder_outs = []
bs_outs = []
for i in range(self.config["model"]["scales"] + 1):
if i == 0:
dec_out = Conv2D(kernel_size=(1, 1),
strides=(1, 1),
filters=128)(encoder_outs[-1])
decoder_outs.append(relu(BatchNormalization()(dec_out)))
bs_outs.append(
bilinear_upsampler(encoder_outs[-1],
encoder_outs[-2].shape[1:3]))
else:
conv_out = Conv2D(kernel_size=(3, 3),
strides=(1, 1),
filters=256)(bs_outs[i - 1])
conv_out = relu(BatchNormalization()(conv_out))
if i != (self.config["model"]["scales"]):
bs_out = encoder_outs[-i - 1] + bilinear_upsampler(
conv_out, encoder_outs[-i - 1].shape[1:3])
else:
bs_out = self.features + bilinear_upsampler(
conv_out, self.features.shape[1:3])
dec_out = Conv2D(kernel_size=(1, 1),
strides=(1, 1),
filters=128)(bs_out)
decoder_outs.append(relu(BatchNormalization()(dec_out)))
bs_outs.append(bs_out)
return decoder_outs
"""
def call(self, hidden_states, training=False):
x1 = relu(self.bn_p(self.conv_p(hidden_states), training=training))
x1 = self.flat_p(x1)
logits_policy = self.logits_policy(x1)
policy = tf.nn.softmax(logits_policy)
x2 = relu(self.bn_v(self.conv_v(hidden_states), training=training))
x2 = self.flat_v(x2)
logits_value = self.logits_value(x2)
categorical_values = tf.nn.softmax(logits_value)
return policy, categorical_values
def call(self, x):
x = self.conv1(x)
x = self.batchnorm1(x)
x = activations.relu(x, alpha=0.01)
x = self.pool1(x)
x = self.conv2(x)
x = self.batchnorm2(x)
x = activations.relu(x, alpha=0.01)
x = self.pool2(x)
x = self.flatten(x)
x = self.dense1(x)
x = self.batchnorm3(x)
x = activations.relu(x, alpha=0.01)
return self.dense2(x)
def call(self, x, inter=None):
# Encoding
x = relu(self.bne1(self.conv1(x)))
x = relu(self.bne2(self.conv2(x)))
if self.res == 64:
x = relu(self.bne3(self.conv3(x)))
x = self.flatten(x)
x = relu(self.bne4(self.fce1(x)))
x = self.fce2(x)
means = self.mean_params(x)
stddev = tf.math.exp(0.5 * self.stddev_params(x))
eps = random_normal(tf.shape(stddev))
# Decoding
z = means + eps * stddev
if inter is not None:
z = tf.keras.layers.add([z, inter])
x = relu(self.bnd1(self.fcd1(z)))
x = relu(self.bnd2(self.fcd2(x)))
x = self.reshape(x)
if self.res == 64:
x = relu(self.bnd3(self.deconv1(x)))
x = relu(self.bnd4(self.deconv2(x)))
x = self.deconv3(x)
return x, means, stddev, z
def call(self, x, dropout=True):
x = self.conv1(x)
x = self.batchnorm1(x)
x = activations.relu(x, alpha=0.01)
x = self.pool1(x)
x = self.conv2(x)
x = self.batchnorm2(x)
x = activations.relu(x, alpha=0.01)
x = self.pool2(x)
x = self.flatten(x)
x = self.dense1(x)
x = self.batchnorm3(x)
x = self.dropout1(x, training=dropout)
x = activations.relu(x, alpha=0.01)
return self.dense2(x)
def call(self, x, sample_action=True):
if self.conv:
# [96, 96] --> [24, 24]
x = self.conv1(x)
x = activations.relu(x)
# [24, 24] --> [12, 12]
x = self.conv2(x)
x = activations.relu(x)
x = self.flatten(x)
if self.dense_hidden_units > 0:
x = self.dense(x)
x = activations.relu(x)
return x
def __init__(
self: tf_Conv,
in_channels: int,
out_channels: int, # filters
kernel_size: int = 1,
strides: int = 1,
padding: Optional[int] = None,
groups: int = 1,
activate: bool = True,
module: Optional[nn.Module] = None
) -> None:
super().__init__()
assert module is not None
# TF v2.2 Conv2D does not support 'groups' argument"
assert groups == 1
# Convolute multi kernels are not allowed
assert isinstance(kernel_size, int)
# Convolution
# TensorFlow convolution padding is inconsistent
# with PyTorch (e.g. k=3 s=2 'SAME' padding)
# see https://stackoverflow.com/questions/52975843
# /comparing-conv2d-with-padding-between-tensorflow-and-pytorch
if strides == 1:
padding_tf = 'SAME'
else:
padding_tf = 'VALID'
kernel_initializer = Constant(
module.conv.weight.permute(2, 3, 1, 0).numpy()
)
conv = Conv2D(
filters=out_channels,
kernel_size=kernel_size,
strides=strides,
padding=padding_tf,
use_bias=False,
kernel_initializer=kernel_initializer
)
if strides == 1:
self.conv = conv
else:
self.conv = Sequential([
tf_Pad(autopad(kernel_size, padding)),
conv
])
# batch normalization
if hasattr(module, 'bn'):
self.bn = tf_BN(module=module.bn)
else:
self.bn = tf.indentity
# activation
if not activate:
self.act = tf.identity
elif isinstance(module.act, nn.LeakyReLU):
self.act = (lambda x: relu(x, alpha=0.1))
elif isinstance(module.act, nn.Hardswish):
self.act = (lambda x: x * tf.nn.relu6(x + 3) * 0.166666667)
elif isinstance(module.act, nn.SiLU):
# self.act = (lambda x: x * keras.activations.sigmoid(x))
self.act = (lambda x: swish(x))
return
def single_input_model():
# activation function: leaky ReLU
leakyrelu = lambda x: relu(x, alpha=0.01, max_value=None, threshold=0)
# creation du réseau de neurones
model = Sequential([
# hidden layer
Dense(units=105, activation=leakyrelu, input_shape=(105, )),
Dropout(rate=0.2),
Dense(units=210, activation=leakyrelu),
Dense(units=400, activation=leakyrelu),
Dropout(rate=0.2),
Dense(units=210, activation=leakyrelu),
Dense(units=100, activation=leakyrelu),
Dense(units=75, activation=leakyrelu),
Dense(units=53, activation=leakyrelu),
# final layer
Dense(units=22, activation=softmax)
])
model.compile(optimizer=Adam(),
loss=sparse_categorical_crossentropy,
metrics=['accuracy'])
# Restoring
single_input_checkpoint_path = join(
path, "models/Single input model/checkpoints/checkpoint.ckpt")
single_input_checkpoint_dir = dirname(single_input_checkpoint_path)
single_input_latest = latest_checkpoint(single_input_checkpoint_dir)
model.load_weights(single_input_latest)
return model
def call(self, inputs):
X, Z = inputs
X_layer = kl.Dense(16, activation='linear')(X)
Z_dense = kl.Dense(16, activation='linear')
combined = list()
for i in range(Z.shape[0]):
z = Z_dense(Z[:,i])
l = X_layer + z
l = K.expand_dims(l, axis=1)
combined.append(l)
combined = kl.concatenate(combined, axis=1)
# combined is now shape (batch_size, z_size, 16)
l = ka.relu(combined)
l = kl.Dense(16, activation='relu')(l)
l = kl.Dense(16, activation='relu')(l)
l = kl.Dense(16, activation='linear')(l)
return l
