def conv_layer_2conv(prev_layer, layer_depth, is_training=False):
conv_layer1 = tf.layers.conv2d(
prev_layer,
layer_depth, [3, 3],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
conv_layer1_bn = tf.layers.batch_normalization(conv_layer1,
training=is_training)
conv_layer1_out = tf.nn.relu(conv_layer1_bn)
conv_layer2 = tf.layers.conv2d(
conv_layer1_out,
layer_depth, [3, 3],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
conv_layer2_bn = tf.layers.batch_normalization(conv_layer2,
training=is_training)
conv_layer2_out = tf.nn.relu(conv_layer2_bn)
pool_layer2 = tf.layers.max_pooling2d(conv_layer2_out, [2, 2],
strides=2,
padding='same')
return pool_layer2, conv_layer2_out
def basic_block(x,
num_channel,
kernel_size,
stride,
is_training,
scope,
padding='same'):
# Shortcut connection
in_channel = x.get_shape().as_list()[-1]
with tf.variable_scope(scope):
if in_channel == num_channel:
if stride == 1:
shortcut = tf.identity(x)
else:
shortcut = tf.nn.max_pool(x, [stride, stride],
stride,
padding='same')
else:
# Considering maxpooling if stride > 1
shortcut = tf.layers.conv2d(x,
num_channel,
1,
strides=stride,
padding='same',
activation=None,
name='dimension_reduction',
use_bias=False,
kernel_initializer=he_normal())
# shortcut = tf.layers.batch_normalization(
# shortcut, momentum=0.9, training=is_training,
# name='shortcut_bn'
# )
x = conv_bn_relu(x,
num_channel,
kernel_size,
stride,
is_training=is_training,
scope='conv_bn_relu',
padding=padding)
x = tf.layers.conv2d(x,
num_channel, [kernel_size, kernel_size],
strides=1,
padding=padding,
name='conv2',
use_bias=False,
kernel_initializer=he_normal())
x = tf.layers.batch_normalization(x,
momentum=0.9,
training=is_training,
name='bn2')
# Considering add relu to x before addition
x = x + shortcut
x = tf.nn.relu(x)
return x
def _build_critic(self):
self.critic_dense = fully_connected(self.lstm_outputs,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.critic_state_value = fully_connected(
self.lstm_outputs,
1,
activation_fn=None,
weights_initializer=he_normal())
def shortcut_v1(inputs,
residual,
use_bias=True,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY),
bn_axis=-1,
momentum=BATCH_NORM_DECAY,
epsilon=BATCH_NORM_EPSILON,
name=None):
input_shape = inputs.get_shape().as_list()
residual_shape = residual.get_shape().as_list()
stride_width = int(round(input_shape[2] / residual_shape[2]))
stride_height = int(round(input_shape[1] / residual_shape[1]))
equal_channels = input_shape[3] == residual_shape[3]
# 1 X 1 conv if shape is different. Else identity.
if stride_width > 1 or stride_height > 1 or not equal_channels:
inputs = layers.Conv2D(filters=residual_shape[3],
kernel_size=(1, 1),
strides=(stride_width, stride_height),
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
name='res' + name)(inputs)
inputs = layers.BatchNormalization(axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name='bn' + name)(inputs)
return layers.add([inputs, residual])
def bn_relu_conv(inputs,
filters,
kernel_size,
strides=(1, 1),
padding='same',
use_bias=True,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY),
bn_axis=-1,
momentum=BATCH_NORM_DECAY,
epsilon=BATCH_NORM_EPSILON,
name=None):
x = bn_relu(inputs,
axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
bn_name='bn' + name)
x = layers.Conv2D(filters=filters,
kernel_size=kernel_size,
strides=strides,
padding=padding,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
name='res' + name)(x)
return x
def residual_block(inputs,
block_function,
filters,
repetitions,
stage,
use_bias=True,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY),
bn_axis=-1,
momentum=BATCH_NORM_DECAY,
epsilon=BATCH_NORM_EPSILON):
x = inputs
for i in range(repetitions):
init_strides = (1, 1)
if i == 0 and stage != 2:
init_strides = (2, 2)
x = block_function(x,
filters=filters,
stage=stage,
block='block_%d' % (i + 1),
use_bias=use_bias,
init_strides=init_strides,
is_first_block_of_first_layer=(stage == 2
and i == 0),
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bn_axis=bn_axis,
momentum=momentum,
epsilon=epsilon)
return x
def bottleneck_v2(inputs,
filters,
init_strides=(1, 1),
use_bias=True,
is_first_block_of_first_layer=False,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY)):
# TODO: not verified
if is_first_block_of_first_layer:
x = layers.Conv2D(filters=filters,
kernel_size=(1, 1),
strides=init_strides,
use_bias=use_bias,
padding='same',
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(inputs)
else:
x = bn_relu_conv(inputs,
filters=filters,
kernel_size=(1, 1),
strides=init_strides,
use_bias=use_bias)
x = bn_relu_conv(x, filters=filters, kernel_size=(3, 3), use_bias=use_bias)
x = bn_relu_conv(x,
filters=filters * 4,
kernel_size=(1, 1),
use_bias=use_bias)
return shortcut_v2(inputs, x, use_bias=use_bias)
def bottleneck_v1(inputs,
filters,
stage,
block,
use_bias=True,
init_strides=(1, 1),
is_first_block_of_first_layer=False,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY),
bn_axis=-1,
momentum=BATCH_NORM_DECAY,
epsilon=BATCH_NORM_EPSILON):
if isinstance(filters, int):
filter1, filter2, filter3 = filters, filters, 4 * filters
else:
filter1, filter2, filter3 = filters
base_name = str(stage) + block + '_branch'
x = conv_bn_relu(inputs,
filters=filter1,
kernel_size=(1, 1),
strides=init_strides,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bn_axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name=base_name + '2a')
x = conv_bn_relu(x,
filters=filter2,
kernel_size=(3, 3),
strides=(1, 1),
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bn_axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name=base_name + '2b')
x = conv_bn(x,
filters=filter3,
kernel_size=(1, 1),
strides=(1, 1),
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bn_axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name=base_name + '2c')
x = shortcut_v1(inputs,
x,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bn_axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name=base_name + '1')
return layers.ReLU()(x)
def vgg_block(inputs,
layer_num,
filters,
kernel_size=(3, 3),
strides=(1, 1),
pool_size=(2, 2),
pool_strides=(2, 2),
bn_type='dbn',
m=16,
affine=True,
iter=5,
weight_decay=1e-4):
conv = inputs
for i in range(layer_num):
if bn_type == 'dbn':
bn = layers.DecorrelatedBN(m_per_group=m, affine=affine)
elif bn_type == 'iter_norm':
bn = layers.IterativeNormalization(m_per_group=m,
affine=affine,
iter_num=iter)
else:
bn = keras.layers.BatchNormalization()
conv = conv_bn_relu(conv,
filters=filters,
kernel_size=kernel_size,
strides=strides,
bn=bn,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))
pose = keras.layers.MaxPool2D(pool_size=pool_size,
strides=pool_strides,
padding='same')(conv)
return pose
def ssd_multibox_layer(layer,
anchor_sizes,
anchor_ratios,
feat_shapes,
normalization=False):
#need to figure out why length of anchor_size + length of anchor_ratios
if normalization > 0:
layer = custom_layers.l2_normalization(layer, scaling=True)
num_anchors = len(anchor_sizes) + len(anchor_ratios)
num_loc_pred = num_anchors * 4
num_cls_pred = num_anchors * FLAGS.num_class
pred = tf.layers.conv2d(
layer,
num_loc_pred + num_cls_pred, [3, 3],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
loc_pred = tf.reshape(pred[..., 0:(4 * num_anchors)],
[-1, feat_shapes[0], feat_shapes[0], num_anchors, 4])
# cls_pred = tf.layers.conv2d(layer, num_cls_pred, [3,3], 1, 'same', use_bias=True,kernel_initializer=he_normal(seed=0.01),activation=None,kernel_regularizer=tf.contrib.layers.l2_regularizer(FLAGS.weight_decay))
cls_pred = tf.reshape(
pred[..., (4 * num_anchors)::],
[-1, feat_shapes[0], feat_shapes[0], num_anchors, FLAGS.num_class])
#channel to last and reshape didn't implement
return cls_pred, loc_pred
def _build_inputs(self):
self._build_measurements()
self._build_action_history()
concatlist = [self.in_action3, self.dense_m3]
self._build_conv()
self.latent_z = fully_connected(self.convout,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
concatlist.append(self.latent_z)
self.merged_input1 = tf.concat(concatlist, 1, name="InputMerge")
#self.merged_input2 = fully_connected(self.merged_input1,256,
# activation_fn=LeakyReLU(0.2),weights_initializer=he_normal())
#self.cell = tf.nn.rnn_cell.BasicLSTMCell(512)
self.cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(512)
rnn_in = tf.reshape(self.merged_input1, [-1, self.time_steps, 651])
self.c_in = tf.placeholder(shape=[None, self.cell.state_size.c],
dtype=tf.float32)
self.h_in = tf.placeholder(shape=[None, self.cell.state_size.h],
dtype=tf.float32)
state_in = tf.contrib.rnn.LSTMStateTuple(self.c_in, self.h_in)
self.lstm_outputs, self.lstm_state = tf.nn.dynamic_rnn(
self.cell, rnn_in, initial_state=state_in, dtype=tf.float32)
self.lstm_outputs = tf.reshape(self.lstm_outputs, [-1, 512])
def _build_actor(self):
p_layer = lambda size: fully_connected(self.lstm_outputs,
size,
activation_fn=tf.nn.softmax,
weights_initializer=he_normal())
probs = [p_layer(size) for size in self.a_size]
dist_layer = lambda p: tf.distributions.Categorical(probs=p,
dtype=tf.int32)
self.dists = [dist_layer(p) for p in probs]
sample_dist = lambda dist: tf.expand_dims(dist.sample(), -1)
sampled_actions = [sample_dist(dist) for dist in self.dists]
best_fn = lambda p: tf.expand_dims(tf.argmax(p, axis=1), -1)
best_actions = [best_fn(p) for p in probs]
self.sampled_action = tf.concat(sampled_actions, axis=-1)
self.best_action = tf.concat(best_actions, axis=-1)
#going to need this frozen for use as pi_thetaold(action)
self.sampled_action_prob = self.action_prob(self.sampled_action)
self.best_action_prob = self.action_prob(self.best_action)
self.feed_action = tf.placeholder(shape=[None, self.num_action_splits],
dtype=tf.float32)
self.feed_action_prob = self.action_prob(self.feed_action)
def _build_measurements(self):
with tf.variable_scope("measurements"):
self.measurements = tf.placeholder(
shape=[None, self.num_measurements[0]], dtype=tf.float32)
self.dense_m1 = fully_connected(flatten(self.measurements),
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_m2 = fully_connected(self.dense_m1,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_m3 = fully_connected(self.dense_m2,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
def conv_layer(input_layer, size_in, size_out, name="conv"):
"""
This function is to define convloution layer with
following default parmameters
Filter size: 5*5
Padding: SAME
Inititalization: HE Normal
Activation: LeakyRelu(Alpha=0.5)
"""
with tf.name_scope(name):
# Defining fliter weights
weights = tf.get_variable(name + "/" + "weights",
dtype=tf.float32,
shape=[5, 5, size_in, size_out],
initializer=he_normal(seed=8))
# Defining biases
biases = tf.get_variable(name + "/" + "biases",
dtype=tf.float32,
shape=[size_out],
initializer=tf.constant_initializer(0.01))
# Convolving the input with weights
conv = tf.nn.conv2d(input_layer,
weights,
strides=[1, 1, 1, 1],
padding="SAME")
# Applying leakey relu activation function
act = tf.nn.leaky_relu(conv + biases, alpha=0.5, name="leakyrelu")
# Adding historgrams to visualize in tensorboard
tf.summary.histogram("weights", weights)
tf.summary.histogram("biases", biases)
tf.summary.histogram("activations", act)
return act
def basic_block_v2(inputs,
filters,
stage,
block,
use_bias=True,
init_strides=(1, 1),
is_first_block_of_first_layer=False,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY),
bn_axis=-1,
momentum=BATCH_NORM_DECAY,
epsilon=BATCH_NORM_EPSILON):
if isinstance(filters, int):
filters1, filters2 = filters, filters
else:
filters1, filters2 = filters
base_name = str(stage) + block + '_branch'
if is_first_block_of_first_layer:
x = layers.Conv2D(filters=filters1,
kernel_size=(3, 3),
use_bias=use_bias,
strides=init_strides,
padding='same',
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
name=base_name + '2a')(inputs)
else:
x = bn_relu_conv(inputs,
filters=filters1,
kernel_size=(3, 3),
use_bias=use_bias,
strides=init_strides,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bn_axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name=base_name + '2a')
residual = bn_relu_conv(x,
filters=filters2,
kernel_size=(3, 3),
strides=(1, 1),
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
bn_axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name=base_name + '2b')
return shortcut_v2(inputs,
residual,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
name=base_name + '1')
def _build_conv(self):
#self.conv_training = tf.placeholder_with_default(True,shape=())
self.observation = tf.placeholder(
shape=[None, self.framedim[0], self.framedim[1], 3],
dtype=tf.float32)
self.conv1 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.observation,
num_outputs=16,
kernel_size=[3, 3],
stride=[3, 3],
padding='VALID')
#self.conv1 = tf.layers.batch_normalization(self.conv1,training=self.conv_training)
self.conv2 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.conv1,
num_outputs=32,
kernel_size=[2, 2],
stride=[2, 2],
padding='VALID')
#self.conv2 = tf.layers.batch_normalization(self.conv2,training=self.conv_training)
self.conv3 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.conv2,
num_outputs=64,
kernel_size=[2, 2],
stride=[2, 2],
padding='VALID')
#self.conv3 = tf.layers.batch_normalization(self.conv3,training=self.conv_training)
self.conv4 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.conv3,
num_outputs=128,
kernel_size=[2, 2],
stride=[1, 1],
padding='VALID')
#self.conv4 = tf.layers.batch_normalization(self.conv4,training=self.conv_training)
#self.conv5 = tf.layers.batch_normalization(self.conv5,training=self.conv_training)
self.convout = flatten(self.conv4)
def conv_bn_relu(inputs,
filters=64,
kernel_size=(7, 7),
strides=(2, 2),
bn=keras.layers.BatchNormalization(),
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY)):
x = keras.layers.Conv2D(filters=filters,
kernel_size=kernel_size,
strides=strides,
padding='same',
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(inputs)
return bn_relu(x, bn)
def bn_relu_conv(inputs,
filters,
kernel_size,
strides=(1, 1),
padding='same',
bn=keras.layers.BatchNormalization(),
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY)):
x = bn_relu(inputs, bn)
x = keras.layers.Conv2D(filters=filters,
kernel_size=kernel_size,
strides=strides,
padding=padding,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(x)
return x
def shortcut(inputs,
residual,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY)):
input_shape = inputs.get_shape().as_list()
residual_shape = residual.get_shape().as_list()
stride_width = int(round(input_shape[2] / residual_shape[2]))
stride_height = int(round(input_shape[1] / residual_shape[1]))
equal_channels = input_shape[3] == residual_shape[3]
# 1 X 1 conv if shape is different. Else identity.
if stride_width > 1 or stride_height > 1 or not equal_channels:
inputs = keras.layers.Conv2D(
filters=residual_shape[3],
kernel_size=(1, 1),
strides=(stride_width, stride_height),
padding='valid',
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(inputs)
return keras.layers.add([inputs, residual])
def basic_block(inputs,
filters,
init_strides=(1, 1),
is_first_block_of_first_layer=False,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY)):
if is_first_block_of_first_layer:
x = keras.layers.Conv2D(filters=filters,
kernel_size=(3, 3),
strides=init_strides,
padding='same',
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(inputs)
else:
x = bn_relu_conv(inputs,
filters=filters,
kernel_size=(3, 3),
strides=init_strides)
residual = bn_relu_conv(x, filters=filters, kernel_size=(3, 3))
return shortcut(inputs, residual)
def shortcut_v2(inputs,
residual,
use_bias=True,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY),
name=None):
input_shape = inputs.get_shape().as_list()
residual_shape = residual.get_shape().as_list()
stride_width = int(round(input_shape[2] / residual_shape[2]))
stride_height = int(round(input_shape[1] / residual_shape[1]))
equal_channels = input_shape[3] == residual_shape[3]
# 1 X 1 conv if shape is different. Else identity.
if stride_width > 1 or stride_height > 1 or not equal_channels:
inputs = layers.Conv2D(filters=residual_shape[3],
kernel_size=(1, 1),
strides=(stride_width, stride_height),
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
name='res' + name)(inputs)
return layers.add([inputs, residual])
def conv_bn_relu(x,
num_channel,
kernel_size,
stride,
is_training,
scope,
padding='same',
use_bias=False):
with tf.variable_scope(scope):
x = tf.layers.conv2d(x,
num_channel, [kernel_size, kernel_size],
strides=stride,
activation=None,
name='conv',
padding=padding,
use_bias=use_bias,
kernel_initializer=he_normal())
x = tf.layers.batch_normalization(x,
momentum=0.9,
training=is_training,
name='bn')
x = tf.nn.relu(x, name='relu')
return x
def conv_bn(inputs,
filters=64,
kernel_size=(3, 3),
strides=(1, 1),
use_bias=True,
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(WEIGHT_DECAY),
bn_axis=-1,
momentum=BATCH_NORM_DECAY,
epsilon=BATCH_NORM_EPSILON,
name=None):
x = layers.Conv2D(filters=filters,
kernel_size=kernel_size,
strides=strides,
padding='same',
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
name='res' + name)(inputs)
return layers.BatchNormalization(axis=bn_axis,
momentum=momentum,
epsilon=epsilon,
name='bn' + name)(x)
def initial_block(x,
is_training=True,
scope='initial_block',
padding='same',
use_bias=False):
with tf.variable_scope(scope):
x = tf.layers.conv2d(x,
64, [7, 7],
strides=2,
activation=None,
name='conv1',
padding=padding,
use_bias=use_bias,
kernel_initializer=he_normal())
x = tf.layers.batch_normalization(x,
momentum=0.9,
training=is_training,
name='bn1')
x = tf.nn.relu(x, name='relu')
x = tf.layers.max_pooling2d(x, [3, 3],
strides=2,
name='maxpool',
padding=padding)
return x
def linknet(inputs,
num_classes,
reuse=None,
is_training=True,
scope='linknet'):
filters = [64, 128, 256, 512]
filters_m = [64, 128, 256, 512][::-1]
filters_n = [64, 64, 128, 256][::-1]
with tf.variable_scope(scope, reuse=reuse):
# Encoder
eb0 = initial_block(inputs,
is_training=is_training,
scope='initial_block')
eb1 = encoder_block(eb0,
filters[0],
3,
1,
is_training,
scope='eb1',
padding='same')
ebi = eb1
ebs = [
eb1,
]
i = 2
for filter_i in filters[1:]:
ebi = encoder_block(ebi,
filter_i,
3,
2,
is_training,
scope='eb' + str(i),
padding='same')
ebs.append(ebi)
i = i + 1
net = ebi
# Decoder
dbi = decoder_block(net,
filters_m[0],
filters_n[0],
3,
2,
is_training=is_training,
scope='db4',
padding='same')
i = len(filters_m) - 1
for filters_i in zip(filters_m[1:-1], filters_n[1:-1]):
dbi = dbi + ebs[i - 1]
dbi = decoder_block(dbi,
filters_i[0],
filters_i[1],
3,
2,
is_training=is_training,
scope='db' + str(i),
padding='same')
i = i - 1
dbi = dbi + ebs[0]
dbi = decoder_block(dbi,
filters_m[-1],
filters_n[-1],
3,
1,
is_training=is_training,
scope='db1',
padding='same')
net = dbi
# Classification
with tf.variable_scope('classifier', reuse=reuse):
net = upconv_bn_relu(net,
32,
3,
2,
is_training=is_training,
scope='conv_transpose')
net = conv_bn_relu(net,
32,
3,
1,
is_training=is_training,
scope='conv')
# Last layer, no batch normalization or activation
logits = tf.layers.conv2d_transpose(net,
num_classes,
kernel_size=2,
strides=2,
padding='same',
name='conv_transpose',
kernel_initializer=he_normal())
if num_classes > 1:
prob = tf.nn.softmax(logits, name='prob')
else:
prob = tf.nn.sigmoid(logits, name='prob')
return prob, logits
def __init__(self, a_size, num_offsets, num_measurements, xdim, ydim):
#Inputs and visual encoding layers
#num_measurements[0] = num_observe_measurements
#num_measurements[1] = num_predict_measuremnets
self.observation = tf.placeholder(shape=[None, xdim, ydim, 6],
dtype=tf.float32)
self.conv1 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.observation,
num_outputs=32,
kernel_size=[8, 8],
stride=[4, 4],
padding='VALID')
self.conv2 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.conv1,
num_outputs=64,
kernel_size=[4, 4],
stride=[2, 2],
padding='VALID')
self.conv3 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.conv2,
num_outputs=128,
kernel_size=[3, 3],
stride=[1, 1],
padding='VALID')
self.convout = fully_connected(flatten(self.conv3),
1024,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.measurements = tf.placeholder(shape=[None, num_measurements[0]],
dtype=tf.float32)
self.dense_m1 = fully_connected(flatten(self.measurements),
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_m2 = fully_connected(self.dense_m1,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_m3 = fully_connected(self.dense_m2,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.goals = tf.placeholder(shape=[None, num_measurements[1]],
dtype=tf.float32)
self.dense_g1 = fully_connected(flatten(self.goals),
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_g2 = fully_connected(self.dense_g1,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_g3 = fully_connected(self.dense_g2,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.action_history = tf.placeholder(shape=[None, 27, 12],
dtype=tf.float32)
self.in_action1 = fully_connected(flatten(self.action_history),
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.in_action2 = fully_connected(self.in_action1,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.in_action3 = fully_connected(self.in_action2,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.merged_input1 = tf.concat(
[self.in_action3, self.dense_m3, self.convout, self.dense_g3],
1,
name="InputMerge")
self.merged_input2 = fully_connected(self.merged_input1,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.memcache_l1 = tf.placeholder(shape=[None, 5, 512],
dtype=tf.float32)
self.mem1_dense1 = fully_connected(flatten(self.memcache_l1),
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.memcache_l2 = tf.placeholder(shape=[None, 6, 256],
dtype=tf.float32)
self.mem2_dense1 = fully_connected(flatten(self.memcache_l2),
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.memcache_l3 = tf.placeholder(shape=[None, 6, 256],
dtype=tf.float32)
self.mem3_dense1 = fully_connected(flatten(self.memcache_l3),
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.memcache_l4 = tf.placeholder(shape=[None, 6, 256],
dtype=tf.float32)
self.mem4_dense1 = fully_connected(flatten(self.memcache_l4),
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.merged_with_mems = tf.concat([
self.merged_input2, self.mem1_dense1, self.mem2_dense1,
self.mem3_dense1, self.mem4_dense1
], 1)
self.exploring = tf.placeholder_with_default(False, shape=())
self.merged_dropout = dropout(self.merged_with_mems,
keep_prob=0.98,
is_training=self.exploring)
#We calculate separate expectation and advantage streams, then combine then later
#This technique is described in https://arxiv.org/pdf/1511.06581.pdf
outputdim = num_measurements[1] * num_offsets
outputdim_a1 = num_measurements[1] * num_offsets * a_size[0]
outputdim_a2 = num_measurements[1] * num_offsets * a_size[1]
outputdim_a3 = num_measurements[1] * num_offsets * a_size[2]
outputdim_a4 = num_measurements[1] * num_offsets * a_size[3]
#average expectation accross all actions
self.expectation1 = fully_connected(self.merged_dropout,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.expectation2 = fully_connected(self.expectation1,
outputdim,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
#split actions into functionally seperable groups
#e.g. the expectations of movements depend intimately on
#combinations of movements (e.g. forward left vs forward right)
#but the expectations of movements can be seperated from the outcome
#of switching weapons for example. This separation reduces the
# number of outputs of the model by an order of magnitude or more
#when the number of subactions is large while maintaining the ability
#to choose from a large number of actions.
self.a1_advantages1 = fully_connected(self.merged_dropout,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a1_advantages2 = fully_connected(self.a1_advantages1,
outputdim_a1,
activation_fn=None,
weights_initializer=he_normal())
self.a2_advantages1 = fully_connected(self.merged_dropout,
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a2_advantages2 = fully_connected(self.a2_advantages1,
outputdim_a2,
activation_fn=None,
weights_initializer=he_normal())
self.a3_advantages1 = fully_connected(self.merged_dropout,
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a3_advantages2 = fully_connected(self.a3_advantages1,
outputdim_a3,
activation_fn=None,
weights_initializer=he_normal())
self.a4_advantages1 = fully_connected(self.merged_dropout,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a4_advantages2 = fully_connected(self.a4_advantages1,
outputdim_a4,
activation_fn=None,
weights_initializer=he_normal())
self.expectation2 = tf.reshape(self.expectation2,
[-1, num_offsets, num_measurements[1]])
self.a1_advantages2 = tf.reshape(
self.a1_advantages2,
[-1, a_size[0], num_offsets, num_measurements[1]])
self.a2_advantages2 = tf.reshape(
self.a2_advantages2,
[-1, a_size[1], num_offsets, num_measurements[1]])
self.a3_advantages2 = tf.reshape(
self.a3_advantages2,
[-1, a_size[2], num_offsets, num_measurements[1]])
self.a4_advantages2 = tf.reshape(
self.a4_advantages2,
[-1, a_size[3], num_offsets, num_measurements[1]])
#batch normalize, expectation stream handles the average
self.a1_advantages2 = self.a1_advantages2 - tf.reduce_mean(
self.a1_advantages2, axis=1, keep_dims=True)
self.a2_advantages2 = self.a2_advantages2 - tf.reduce_mean(
self.a2_advantages2, axis=1, keep_dims=True)
self.a3_advantages2 = self.a3_advantages2 - tf.reduce_mean(
self.a3_advantages2, axis=1, keep_dims=True)
self.a4_advantages2 = self.a4_advantages2 - tf.reduce_mean(
self.a4_advantages2, axis=1, keep_dims=True)
#tensor of 0 and 1 which indicate whether the action was taken
#when we multiply each with the advantage stream and reduce_sum we get only the chosen actions
self.a1_chosen = tf.placeholder(
shape=[None, a_size[0], num_offsets, num_measurements[1]],
dtype=tf.float32)
self.a2_chosen = tf.placeholder(
shape=[None, a_size[1], num_offsets, num_measurements[1]],
dtype=tf.float32)
self.a3_chosen = tf.placeholder(
shape=[None, a_size[2], num_offsets, num_measurements[1]],
dtype=tf.float32)
self.a4_chosen = tf.placeholder(
shape=[None, a_size[3], num_offsets, num_measurements[1]],
dtype=tf.float32)
self.a1_pred = tf.reduce_sum(tf.multiply(self.a1_advantages2,
self.a1_chosen),
axis=1)
self.a2_pred = tf.reduce_sum(tf.multiply(self.a2_advantages2,
self.a2_chosen),
axis=1)
self.a3_pred = tf.reduce_sum(tf.multiply(self.a3_advantages2,
self.a3_chosen),
axis=1)
self.a4_pred = tf.reduce_sum(tf.multiply(self.a4_advantages2,
self.a4_chosen),
axis=1)
#sum up all contributions to the output prediction
self.prediction = tf.add_n([
self.expectation2, self.a1_pred, self.a2_pred, self.a3_pred,
self.a4_pred
])
#This is the actual
self.target = tf.placeholder(
shape=[None, num_offsets, num_measurements[1]], dtype=tf.float32)
#Loss function
self.loss = tf.reduce_sum(
tf.squared_difference(self.prediction, self.target))
self.episodes = tf.placeholder(shape=(), dtype=tf.int32)
starting_learning_rate = 3e-4
learning_rate = tf.train.exponential_decay(starting_learning_rate,
self.episodes, 9000, 0.5)
self.trainer = tf.train.AdamOptimizer(learning_rate=learning_rate,
beta1=0.95,
beta2=0.999,
epsilon=1e-4)
#Get & apply gradients from network
global_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)
self.gradients = tf.gradients(self.loss, global_vars)
self.var_norms = tf.global_norm(global_vars)
grads, self.grad_norms = tf.clip_by_global_norm(self.gradients, 5)
self.apply_grads = self.trainer.apply_gradients(
list(zip(grads, global_vars)))
def vgg16_backbone(layer, is_training):
end_points = {}
#conv1
layer, _ = conv_layer_2conv(layer, 64, is_training=is_training)
#conv2
layer, _ = conv_layer_2conv(layer, 128, is_training=is_training)
#conv3
layer, _ = conv_layer_3conv(layer, 256, is_training=is_training)
#conv4
layer, foot_stage1 = conv_layer_3conv(layer, 512, is_training=is_training)
end_points['block4'] = foot_stage1
#conv5
layer = tf.layers.conv2d(
layer,
512, [3, 3],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
layer = tf.layers.conv2d(
layer,
512, [3, 3],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.layers.max_pooling2d(layer, [3, 3], strides=1, padding='same')
layer = tf.nn.relu(layer)
#FC6
layer = slim.conv2d(layer, 1024, [3, 3], rate=6, scope='conv6')
#FC7
layer = tf.layers.conv2d(
layer,
1024, [1, 1],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
end_points['block7'] = layer
#conv8
layer = tf.layers.conv2d(
layer,
256, [1, 1],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
layer = tf.layers.conv2d(
layer,
512, [3, 3],
2,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
end_points['block8'] = layer
#conv9
layer = tf.layers.conv2d(
layer,
128, [1, 1],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
layer = tf.layers.conv2d(
layer,
256, [3, 3],
2,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
end_points['block9'] = layer
#conv10
layer = tf.layers.conv2d(
layer,
128, [1, 1],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
layer = tf.layers.conv2d(
layer,
256, [3, 3],
1,
'valid',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
end_points['block10'] = layer
#conv11
layer = tf.layers.conv2d(
layer,
128, [1, 1],
1,
'same',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
layer = tf.layers.conv2d(
layer,
256, [3, 3],
1,
'valid',
use_bias=True,
kernel_initializer=he_normal(seed=0.01),
activation=None,
kernel_regularizer=tf.contrib.layers.l2_regularizer(
FLAGS.weight_decay))
layer = tf.layers.batch_normalization(layer, training=is_training)
layer = tf.nn.relu(layer)
end_points['block11'] = layer
return end_points
def _create_pc_net(self):
#dim of deconv xdim ->(xdim-1)*xstride + xkernal
self.deconv_in_E = tf.reshape(self.merged_dropout, [-1, 8, 8, 4])
self.deconv_in_a1 = tf.tile(self.deconv_in_E,
[1, 1, 1, self.a_size[0]])
self.deconv_in_a2 = tf.tile(self.deconv_in_E,
[1, 1, 1, self.a_size[1]])
self.deconv_in_a3 = tf.tile(self.deconv_in_E,
[1, 1, 1, self.a_size[2]])
self.deconv_in_a4 = tf.tile(self.deconv_in_E,
[1, 1, 1, self.a_size[3]])
self.deconv_E = conv2d_transpose(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.deconv_in_E,
num_outputs=1,
kernel_size=[6, 6],
stride=[2, 2],
padding='VALID')
self.deconv_a1 = conv2d_transpose(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.deconv_in_a1,
num_outputs=self.a_size[0],
kernel_size=[6, 6],
stride=[2, 2],
padding='VALID')
self.deconv_a2 = conv2d_transpose(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.deconv_in_a2,
num_outputs=self.a_size[1],
kernel_size=[6, 6],
stride=[2, 2],
padding='VALID')
self.deconv_a3 = conv2d_transpose(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.deconv_in_a3,
num_outputs=self.a_size[2],
kernel_size=[6, 6],
stride=[2, 2],
padding='VALID')
self.deconv_a4 = conv2d_transpose(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.deconv_in_a4,
num_outputs=self.a_size[3],
kernel_size=[6, 6],
stride=[2, 2],
padding='VALID')
self.deconv_a1 = self.deconv_a1 - tf.reduce_mean(
self.deconv_a1, axis=3, keep_dims=True)
self.deconv_a2 = self.deconv_a2 - tf.reduce_mean(
self.deconv_a2, axis=3, keep_dims=True)
self.deconv_a3 = self.deconv_a3 - tf.reduce_mean(
self.deconv_a3, axis=3, keep_dims=True)
self.deconv_a4 = self.deconv_a4 - tf.reduce_mean(
self.deconv_a4, axis=3, keep_dims=True)
self.deconv_a1_chosen = tf.placeholder(
shape=[None, 20, 20, self.a_size[0]], dtype=tf.float32)
self.deconv_a2_chosen = tf.placeholder(
shape=[None, 20, 20, self.a_size[1]], dtype=tf.float32)
self.deconv_a3_chosen = tf.placeholder(
shape=[None, 20, 20, self.a_size[2]], dtype=tf.float32)
self.deconv_a4_chosen = tf.placeholder(
shape=[None, 20, 20, self.a_size[3]], dtype=tf.float32)
self.deconv_a1_pred = tf.reduce_sum(tf.multiply(
self.deconv_a1_chosen, self.deconv_a1),
axis=3)
self.deconv_a2_pred = tf.reduce_sum(tf.multiply(
self.deconv_a2_chosen, self.deconv_a2),
axis=3)
self.deconv_a3_pred = tf.reduce_sum(tf.multiply(
self.deconv_a3_chosen, self.deconv_a3),
axis=3)
self.deconv_a4_pred = tf.reduce_sum(tf.multiply(
self.deconv_a4_chosen, self.deconv_a4),
axis=3)
self.pc_prediction = tf.add_n([
tf.squeeze(self.deconv_E), self.deconv_a1_pred,
self.deconv_a2_pred, self.deconv_a3_pred, self.deconv_a4_pred
])
self.pc_target = tf.placeholder(shape=[None, 20, 20], dtype=tf.float32)
self.pc_loss = tf.losses.mean_squared_error(self.pc_target,
self.pc_prediction)
def _create_base_net(self):
#average expectation accross all actions
self.expectation1 = fully_connected(self.merged_dropout,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.expectation2 = fully_connected(self.expectation1,
self.outputdim,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a1_advantages1 = fully_connected(self.merged_dropout,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a1_advantages2 = fully_connected(self.a1_advantages1,
self.outputdim_a1,
activation_fn=None,
weights_initializer=he_normal())
self.a2_advantages1 = fully_connected(self.merged_dropout,
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a2_advantages2 = fully_connected(self.a2_advantages1,
self.outputdim_a2,
activation_fn=None,
weights_initializer=he_normal())
self.a3_advantages1 = fully_connected(self.merged_dropout,
256,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a3_advantages2 = fully_connected(self.a3_advantages1,
self.outputdim_a3,
activation_fn=None,
weights_initializer=he_normal())
self.a4_advantages1 = fully_connected(self.merged_dropout,
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.a4_advantages2 = fully_connected(self.a4_advantages1,
self.outputdim_a4,
activation_fn=None,
weights_initializer=he_normal())
self.expectation2 = tf.reshape(
self.expectation2,
[-1, self.num_offsets, self.num_measurements[1]])
self.a1_advantages2 = tf.reshape(
self.a1_advantages2,
[-1, self.a_size[0], self.num_offsets, self.num_measurements[1]])
self.a2_advantages2 = tf.reshape(
self.a2_advantages2,
[-1, self.a_size[1], self.num_offsets, self.num_measurements[1]])
self.a3_advantages2 = tf.reshape(
self.a3_advantages2,
[-1, self.a_size[2], self.num_offsets, self.num_measurements[1]])
self.a4_advantages2 = tf.reshape(
self.a4_advantages2,
[-1, self.a_size[3], self.num_offsets, self.num_measurements[1]])
#batch normalize, expectation stream handles the average
self.a1_advantages2 = self.a1_advantages2 - tf.reduce_mean(
self.a1_advantages2, axis=1, keep_dims=True)
self.a2_advantages2 = self.a2_advantages2 - tf.reduce_mean(
self.a2_advantages2, axis=1, keep_dims=True)
self.a3_advantages2 = self.a3_advantages2 - tf.reduce_mean(
self.a3_advantages2, axis=1, keep_dims=True)
self.a4_advantages2 = self.a4_advantages2 - tf.reduce_mean(
self.a4_advantages2, axis=1, keep_dims=True)
#tensor of 0 and 1 which indicate whether the action was taken
#when we multiply each with the advantage stream and reduce_sum we get only the chosen actions
self.a1_chosen = tf.placeholder(shape=[
None, self.a_size[0], self.num_offsets, self.num_measurements[1]
],
dtype=tf.float32)
self.a2_chosen = tf.placeholder(shape=[
None, self.a_size[1], self.num_offsets, self.num_measurements[1]
],
dtype=tf.float32)
self.a3_chosen = tf.placeholder(shape=[
None, self.a_size[2], self.num_offsets, self.num_measurements[1]
],
dtype=tf.float32)
self.a4_chosen = tf.placeholder(shape=[
None, self.a_size[3], self.num_offsets, self.num_measurements[1]
],
dtype=tf.float32)
self.a1_pred = tf.reduce_sum(tf.multiply(self.a1_advantages2,
self.a1_chosen),
axis=1)
self.a2_pred = tf.reduce_sum(tf.multiply(self.a2_advantages2,
self.a2_chosen),
axis=1)
self.a3_pred = tf.reduce_sum(tf.multiply(self.a3_advantages2,
self.a3_chosen),
axis=1)
self.a4_pred = tf.reduce_sum(tf.multiply(self.a4_advantages2,
self.a4_chosen),
axis=1)
#sum up all contributions to the output prediction
self.prediction = tf.add_n([
self.expectation2, self.a1_pred, self.a2_pred, self.a3_pred,
self.a4_pred
])
#This is the actual
self.target = tf.placeholder(
shape=[None, self.num_offsets, self.num_measurements[1]],
dtype=tf.float32)
#Loss function
self.loss_main = tf.losses.mean_squared_error(self.target,
self.prediction)
def _create_input_stream(self):
self.observation = tf.placeholder(
shape=[None, self.xdim, self.ydim, 3], dtype=tf.float32)
self.conv1 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.observation,
num_outputs=32,
kernel_size=[8, 8],
stride=[4, 4],
padding='VALID')
self.conv2 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.conv1,
num_outputs=64,
kernel_size=[4, 4],
stride=[2, 2],
padding='VALID')
self.conv3 = conv2d(activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal(),
inputs=self.conv2,
num_outputs=64,
kernel_size=[3, 3],
stride=[1, 1],
padding='VALID')
self.convout = fully_connected(flatten(self.conv3),
512,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.measurements = tf.placeholder(
shape=[None, self.num_measurements[0]], dtype=tf.float32)
self.dense_m1 = fully_connected(flatten(self.measurements),
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_m2 = fully_connected(self.dense_m1,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_m3 = fully_connected(self.dense_m2,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.goals = tf.placeholder(shape=[None, self.num_measurements[1]],
dtype=tf.float32)
self.dense_g1 = fully_connected(flatten(self.goals),
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_g2 = fully_connected(self.dense_g1,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.dense_g3 = fully_connected(self.dense_g2,
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.action_history = tf.placeholder(shape=[None, 12],
dtype=tf.float32)
self.dense_a1 = fully_connected(flatten(self.goals),
128,
activation_fn=LeakyReLU(0.2),
weights_initializer=he_normal())
self.merged_input1 = tf.concat(
[self.dense_a1, self.dense_m3, self.convout, self.dense_g3],
1,
name="InputMerge")
