def encoder(inputs, z_dim):
# encoder ()
# 10 x 32 x 32 x 32 x 1 -> 10 x 16 x 16 x 16 x 32
# 10 x 16 x 16 x 16 x 32 -> 10 x 8 x 8 x 8 x 16
# 10 x 8 x 8 x 8 x 16 -> 10 x 4 x 4 x 4 x 8
# 10 x 4 x 4 x 4 x 8 -> z dim
net = lays.conv3d(inputs,
32, [4, 4, 4],
stride=2,
padding='SAME',
trainable=True) #[16,16,16,32]
net = lays.batch_norm(net, decay=0.999)
net = lays.conv3d(net,
16, [4, 4, 4],
stride=2,
padding='SAME',
trainable=True) #[8,8,8,16]
net = lays.batch_norm(net, decay=0.999)
net = lays.conv3d(net,
8, [4, 4, 4],
stride=2,
padding='SAME',
trainable=True) #[4,4,4,8]
net = lays.batch_norm(net, decay=0.999)
net = lays.flatten(net)
net = tf.layers.dense(net, units=z_dim, activation=tf.nn.relu)
#net = tf.layers.dense(net, 4, activation=tf.nn.relu)
#net = tf.reshape(net, [512])
print("this is net", net)
print("this is shape", tf.shape(net))
return net
def get_q_values_op(self, state, scope, reuse=False):
"""
Returns Q values for all actions
Args:
state: (tf tensor)
shape = (batch_size, img height, img width, nchannels)
scope: (string) scope name, that specifies if target network or not
reuse: (bool) reuse of variables in the scope
Returns:
out: (tf tensor) of shape = (batch_size, num_actions)
"""
num_actions = self.env.action_space.n
out = state
# compress the student network
size1, size2, size3, size4 = (16, 16, 16, 128) if self.student else (32, 64, 64, 512)
with tf.variable_scope(scope, reuse=reuse):
conv1 = layers.conv3d(inputs=out, num_outputs=size1, kernel_size=[8,8], stride=4) #20
conv2 = layers.conv3d(inputs=conv1, num_outputs=size2, kernel_size=[4,4], stride=2) #10
conv3 = layers.conv3d(inputs=conv2, num_outputs=size3, kernel_size=[3,3], stride=1) #10
hidden = layers.fully_connected(layers.flatten(conv3), size4)
out = layers.fully_connected(hidden, num_actions, activation_fn=None)
return out
def _3d_dnn_level_60(self, inputs):
with tf.variable_scope('Volume60', reuse=self._reuse):
conv = layers.conv3d(inputs, 64, 3, scope='conv1', **self._reg)
conv = layers.conv3d(conv,
64,
3,
activation_fn=None,
scope='conv2',
**self._reg)
shortcut = layers.conv3d(inputs,
64,
1,
activation_fn=None,
scope='shortcut1',
**self._reg)
res1 = tf.nn.relu(conv + shortcut)
conv = layers.conv3d(res1, 64, 3, scope='conv3', **self._reg)
conv = layers.conv3d(conv,
64,
3,
activation_fn=None,
scope='conv4',
**self._reg)
res2 = tf.nn.relu(conv + res1)
conv = layers.conv3d(res2,
64,
3,
rate=2,
scope='conv5',
**self._reg)
conv = layers.conv3d(conv,
64,
3,
activation_fn=None,
rate=2,
scope='conv6',
**self._reg)
res3 = tf.nn.relu(conv + res2)
conv = layers.conv3d(res3,
64,
3,
rate=2,
scope='conv7',
**self._reg)
conv = layers.conv3d(conv,
64,
3,
activation_fn=None,
rate=2,
scope='conv8',
**self._reg)
res4 = tf.nn.relu(conv + res3)
concat = tf.concat([res1, res2, res3, res4],
axis=-1,
name='concat')
return tf.nn.relu(concat)
def _3d_dnn(self, inputs):
with tf.variable_scope('DownSample3D', reuse=self._reuse):
feat_3d = layers.conv3d(inputs,
64,
2,
stride=2,
activation_fn=None,
**self._reg)
with tf.variable_scope('ExtraReception', reuse=self._reuse):
feat_3d = layers.conv3d(feat_3d, 128, 3, **self._reg)
feat_3d = self._3d_dnn_level_30(feat_3d)
return self._3d_rdnn_level_60(feat_3d)
def resid_unit(inputs,
depth,
depth_bottleneck,
stride,
rate=1,
outputs_collections=None,
scope=None):
"""Residual unit with BN after convolutions.
This is the original residual unit proposed in [1]. See Fig. 1(a) of [2] for
its definition.
When putting together two consecutive ResNet blocks that use this unit, one
should use stride = 2 in the last unit of the first block.
Args:
inputs: A tensor of size [batch, height, width, channels].
depth: The depth of the ResNet unit output.
depth_bottleneck: The depth of the bottleneck layers.
stride: The ResNet unit's stride. Determines the amount of downsampling of
the units output compared to its input.
rate: An integer, rate for atrous convolution.
outputs_collections: Collection to add the ResNet unit output.
scope: Optional variable_scope.
Returns:
The ResNet unit's output.
"""
with variable_scope.variable_scope(scope, 'resid_v1', [inputs]) as sc:
# print (inputs.shape)
depth_in = utils.last_dimension(inputs.get_shape(), min_rank=5)
if depth == depth_in:
shortcut = resnet_3d_utils.subsample(inputs, stride, 'shortcut')
else:
shortcut = layers.conv3d(inputs,
depth, [1, 1, 1],
stride=stride,
activation_fn=None,
scope='shortcut')
residual = resnet_3d_utils.conv3d_same(inputs,
depth_bottleneck,
3,
stride=1,
scope='conv1')
residual = layers.conv3d(residual,
depth_bottleneck,
3,
stride,
scope='conv2')
output = nn_ops.relu(shortcut + residual)
return utils.collect_named_outputs(outputs_collections, sc.name,
output)
def conv3d(input,
filters=16,
kernel_size=3,
padding="same",
stride=1,
activation_fn=relu,
reuse=None,
name=None,
data_format='NDHWC',
weights_initializer=None,
biases_initializer=tf.zeros_initializer(),
weights_regularizer=None,
biases_regularizer=None,
normalizer_fn=None,
normalizer_params=None):
return contrib_layers.conv3d(input,
num_outputs=filters,
kernel_size=kernel_size,
padding=padding,
stride=stride,
scope=name,
activation_fn=activation_fn,
reuse=reuse,
weights_initializer=weights_initializer,
data_format=data_format,
biases_initializer=biases_initializer,
weights_regularizer=weights_regularizer,
biases_regularizer=biases_regularizer,
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params)
def _3d_dnn_level_60(self, inputs):
with tf.variable_scope('Volume60', reuse=self._reuse):
conv = layers.conv3d(inputs, 64, 3, scope='conv1', **self._reg)
conv = layers.conv3d(conv,
64,
3,
activation_fn=None,
scope='conv2',
**self._reg)
shortcut = layers.conv3d(inputs,
64,
1,
activation_fn=None,
scope='shortcut',
**self._reg)
res = tf.nn.relu(conv + shortcut)
return layers.max_pool3d(res, 2, scope='pool')
def _3d_dnn_level_240(self, inputs):
with tf.variable_scope('Volume240', reuse=self._reuse):
return layers.conv3d(inputs,
16,
7,
stride=2,
scope='conv',
**self._reg)
def conv3d(input, filters=16, kernel_size=3, padding="same", stride=1, activation_fn=relu, reuse=None, name=None, data_format='NDHWC',
weights_initializer=None, biases_initializer=tf.zeros_initializer(), weights_regularizer=None, biases_regularizer=None,
normalizer_fn=None, normalizer_params=None):
return contrib_layers.conv3d(input, num_outputs=filters, kernel_size=kernel_size, padding=padding, stride=stride, scope=name,
activation_fn=activation_fn, reuse=reuse, weights_initializer=weights_initializer, data_format=data_format,
biases_initializer=biases_initializer, weights_regularizer=weights_regularizer, biases_regularizer=biases_regularizer,
normalizer_fn=normalizer_fn, normalizer_params = normalizer_params)
def _prediction_reduce(self, inputs, conv_reg_dict):
with tf.variable_scope('PredictReduction', reuse=self._reuse):
conv = layers.conv3d(inputs,
128,
1,
scope='conv4_1',
**conv_reg_dict)
conv = layers.conv3d(conv,
128,
1,
scope='conv4_2',
**conv_reg_dict)
fc12 = layers.conv3d(conv,
12,
1,
activation_fn=None,
scope='fc12',
**conv_reg_dict)
return fc12
def autoencoder(inputs):
# encoder
# 32 x 32 x 32 x 1 -> 16 x 16 x 16 x 32
# 16 x 16 x 16 x 32 -> 8 x 8 x 8 x 16
# 8 x 8 x 8 x 16 -> 2 x 2 x 2 x 8
net = lays.conv3d(inputs, 32, [5, 5, 5], stride=2, padding='SAME')
net = lays.conv3d(net, 16, [5, 5, 5], stride=2, padding='SAME')
print(tf.shape(net))
net = lays.conv3d(net, 8, [5, 5, 5], stride=4, padding='SAME')
#net = lays.fully_connected(net,1)
latent_space = net
# decoder
# 2 x 2 x 2 x 8 -> 8 x 8 x 8 x 16
# 8 x 8 x 8 x 16 -> 16 x 16 x 16 x 32
# 16 x 16 x 16 x 32 -> 32 x 32 x 32 x 1
net = lays.conv3d_transpose(net, 16, [5, 5, 5], stride=4, padding='SAME')
net = lays.conv3d_transpose(net, 32, [5, 5, 5], stride=2, padding='SAME')
net = lays.conv3d_transpose(net, 1, [5, 5, 5], stride=2, padding='SAME', activation_fn=tf.nn.tanh)
return latent_space, net
def encoder(inputs):
# encoder
# 32 x 32 x 32 x 1 -> 16 x 16 x 16 x 32
# 16 x 16 x 16 x 32 -> 8 x 8 x 8 x 16
# 8 x 8 x 8 x 16 -> 2 x 2 x 2 x 8
print("input type and shape", type(inputs), inputs.shape)
net = lays.batch_norm(lays.conv3d(inputs,
32, [5, 5, 5],
stride=2,
padding='SAME',
trainable=True),
decay=0.9)
net = lays.batch_norm(lays.conv3d(net,
16, [5, 5, 5],
stride=2,
padding='SAME',
trainable=True),
decay=0.9)
net = lays.batch_norm(lays.conv3d(net,
8, [5, 5, 5],
stride=4,
padding='SAME',
trainable=True),
decay=0.9)
net = lays.batch_norm(lays.flatten(net), decay=0.9)
z_mean = lays.fully_connected(net, z_dims)
z_stdev = 0.5 * tf.nn.softplus(lays.fully_connected(net, z_dims))
# Reparameterization trick for Variational Autoencoder
samples = tf.random_normal([tf.shape(z_mean)[0], z_dims],
mean=0,
stddev=1,
dtype=tf.float32)
print("rank and shape of samples", tf.rank(samples))
guessed_z = z_mean + tf.multiply(samples, z_stdev)
print("rank and shape of guessed z", tf.rank(guessed_z))
l_space = guessed_z
return z_mean, z_stdev, l_space
def resnet_v1(inputs,
blocks,
num_classes=None,
is_training=True,
global_pool=True,
output_stride=None,
include_root_block=True,
reuse=None,
scope=None):
"""Generator for v1 ResNet models.
Args:
inputs: A tensor of size [batch, height_in, width_in, channels].
blocks: A list of length equal to the number of ResNet blocks. Each element
is a resnet_utils.Block object describing the units in the block.
num_classes: Number of predicted classes for classification tasks. If None
we return the features before the logit layer.
is_training: whether batch_norm layers are in training mode.
global_pool: If True, we perform global average pooling before computing the
logits. Set to True for image classification, False for dense prediction.
output_stride: If None, then the output will be computed at the nominal
network stride. If output_stride is not None, it specifies the requested
ratio of input to output spatial resolution.
include_root_block: If True, include the initial convolution followed by
max-pooling, if False excludes it.
reuse: whether or not the network and its variables should be reused. To be
able to reuse 'scope' must be given.
scope: Optional variable_scope.
Returns:
net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
If global_pool is False, then height_out and width_out are reduced by a
factor of output_stride compared to the respective height_in and width_in,
else both height_out and width_out equal one. If num_classes is None, then
net is the output of the last ResNet block, potentially after global
average pooling. If num_classes is not None, net contains the pre-softmax
activations.
end_points: A dictionary from components of the network to the corresponding
activation.
Raises:
ValueError: If the target output_stride is not valid.
"""
with variable_scope.variable_scope(scope,
'resnet_v1', [inputs],
reuse=reuse) as sc:
end_points_collection = sc.original_name_scope + '_end_points'
with arg_scope(
[layers.conv3d, bottleneck, resnet_3d_utils.stack_blocks_dense],
outputs_collections=end_points_collection):
with arg_scope([layers.batch_norm], is_training=is_training):
net = inputs
# if include_root_block:
# if output_stride is not None:
# if output_stride % 4 != 0:
# raise ValueError('The output_stride needs to be a multiple of 4.')
# output_stride /= 4
# net = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope='conv1')
# net = layers_lib.max_pool2d(net, [3, 3], stride=2, scope='pool1')
net = resnet_3d_utils.stack_blocks_dense(
net, blocks, output_stride)
if global_pool:
net = math_ops.reduce_mean(net, [1, 2, 3],
name='pool5',
keepdims=True)
if num_classes is not None:
net = layers.conv3d(net,
num_classes, [1, 1, 1],
activation_fn=None,
normalizer_fn=None,
scope='logits')
# Convert end_points_collection into a dictionary of end_points.
end_points = utils.convert_collection_to_dict(
end_points_collection)
if num_classes is not None and num_classes != 1:
end_points['predictions'] = layers_lib.softmax(
net, scope='predictions')
net = tf.squeeze(net)
elif num_classes == 1:
net = tf.squeeze(net)
end_points['probs'] = tf.nn.sigmoid(net)
return net, end_points
def bottleneck(inputs,
depth_out,
depth_bottleneck,
stride,
rate=1,
outputs_collections=None,
scope=None):
with variable_scope.variable_scope(scope, 'resid_v1', [inputs]) as sc:
# print (inputs.shape)
depth_in = utils.last_dimension(inputs.get_shape(), min_rank=5)
if depth_out == depth_in:
shortcut = resnet_3d_utils.subsample(inputs, stride, 'shortcut')
else:
shortcut = layers.conv3d(inputs,
depth_out, [1, 1, 1],
stride=stride,
activation_fn=None,
scope='shortcut')
residual = layers.conv3d(inputs,
depth_bottleneck,
1,
stride=1,
scope='conv1')
residual1 = resnet_3d_utils.conv3d_same(residual,
depth_bottleneck,
3,
stride,
scope='conv2')
#residual1 = layers.conv3d(residual1, depth_out, 1, stride=1, scope='conv3')
with tf.variable_scope(scope, 'Amul', [inputs]):
amul = amul_module.amul
#
# residual2 = inputs
residual2 = tf.pad(residual,
[[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]],
"CONSTANT")
Amul_weight = tf.contrib.slim.model_variable('Amul_weight',
shape=[27, 27])
residual2 = amul(residual2, Amul_weight)
residual2 = layers.conv3d(residual2,
depth_bottleneck, [3, 3, 3],
padding='SAME',
stride=[x * stride for x in [3, 3, 3]],
scope='conv_amul')
# #residual2 = resnet_3d_utils.conv3d_same(residual2, depth, 3, stride=3, scope='conv1_amul')
#tf.summary.histogram('Amul_weight_1',Amul_weight_1)
#
residual_concat = tf.concat([residual1, residual2], 4)
residual_concat = layers.conv3d(residual_concat,
depth_out, [1, 1, 1],
stride=1,
scope='conv_concat',
activation_fn=None)
output = nn_ops.relu(shortcut + residual_concat)
return utils.collect_named_outputs(outputs_collections, sc.name,
output)
def _3d_dnn(self, inputs):
with tf.variable_scope('ExtraReception', reuse=self._reuse):
feat_3d = layers.conv3d(inputs, 128, 3, **self._reg)
feat_3d = self._3d_dnn_level_30(feat_3d)
return self._3d_rdnn_level_60(feat_3d)
def resnet_conv3d(inputs,
num_filters=64,
upsample_fn=cyclegan_upsample,
kernel_size=3,
num_outputs=3,
tanh_linear_slope=0.0,
use_decoder=True):
end_points = {}
with tf.contrib.framework.arg_scope(cyclegan_arg_scope()):
###########
# Encoder #
###########
with tf.variable_scope('input'):
# 7x7 input stage
net = tf_layers.conv3d(inputs,
num_filters,
kernel_size=[1, 7, 7],
stride=1,
padding='SAME')
end_points['encoder_0'] = net
with tf.variable_scope('encoder'):
with tf.contrib.framework.arg_scope([tf_layers.conv3d],
kernel_size=kernel_size,
stride=2,
activation_fn=tf.nn.relu,
padding='SAME'):
net = tf_layers.conv3d(net, num_filters * 2)
end_points['encoder_1'] = net
net = tf_layers.conv3d(net, num_filters * 4)
end_points['encoder_2'] = net
###################
# Residual Blocks #
###################
with tf.variable_scope('residual_blocks'):
with tf.contrib.framework.arg_scope([tf_layers.conv3d],
kernel_size=kernel_size,
stride=1,
activation_fn=tf.nn.relu,
padding='SAME'):
for block_id in range(6):
with tf.variable_scope('block_{}'.format(block_id)):
res_net = tf_layers.conv3d(net, num_filters * 4)
res_net = tf_layers.conv3d(res_net,
num_filters * 4,
activation_fn=None)
net += res_net
end_points['resnet_block_%d' % block_id] = net
hidden_state = tf.nn.tanh(net)
hidden_state = tf.squeeze(hidden_state, axis=1)
end_points['hidden_state'] = hidden_state
###########
# Decoder #
###########
with tf.variable_scope('decoder'):
with tf.contrib.framework.arg_scope([tf_layers.conv2d],
kernel_size=kernel_size,
stride=1,
activation_fn=tf.nn.relu):
with tf.variable_scope('decoder1'):
net = upsample_fn(hidden_state,
num_outputs=num_filters * 2,
stride=[2, 2])
end_points['decoder1'] = net
with tf.variable_scope('decoder2'):
net = upsample_fn(net,
num_outputs=num_filters,
stride=[2, 2])
end_points['decoder2'] = net
with tf.variable_scope('output'):
logits = tf_layers.conv2d(net,
num_outputs, [7, 7],
activation_fn=None,
normalizer_fn=None,
padding='SAME')
end_points['logits'] = logits
end_points['predictions'] = tf.tanh(
logits) + logits * tanh_linear_slope
print('Decoder output = {}'.format(logits))
return end_points['predictions'], end_points['hidden_state'], end_points
class CostCalculatorTest(parameterized.TestCase, tf.test.TestCase):
def _batch_norm_scope(self):
params = {
'trainable': True,
'normalizer_fn': layers.batch_norm,
'normalizer_params': {
'scale': True
}
}
with arg_scope([layers.conv2d], **params) as sc:
return sc
def testImageIsNotZerothOutputOfOp(self):
# Throughout the framework, we assume that the 0th output of each op is the
# only one of interest. One exception that often happens is when the input
# image comes from a queue or from a staging op. Then the image is one of
# the outputs of the dequeue (or staging) op, not necessarily the 0th one.
# Here we test that the BilinearNetworkRegularizer deals correctly with this
# case.
# Create an input op where the image is output number 1, not 0.
# TODO(g1) Move this mechanism to add_concat_model_stub, possibly using
# tf.split to produce an op where the image is not the 0th output image
# (instead of FIFOQueue).
image = add_concat_model_stub.image_stub()
non_image_tensor = tf.zeros(shape=(41, ))
queue = tf.FIFOQueue(capacity=1,
dtypes=(tf.float32, ) * 2,
shapes=(non_image_tensor.shape, image.shape))
# Pass the image (output[1]) to the network.
with arg_scope(self._batch_norm_scope()):
output_op = add_concat_model_stub.build_model(queue.dequeue()[1])
# Create OpHandler dict for test.
op_handler_dict = collections.defaultdict(
grouping_op_handler.GroupingOpHandler)
op_handler_dict.update({
'FusedBatchNormV3':
batch_norm_source_op_handler.BatchNormSourceOpHandler(0.1),
'Conv2D':
output_non_passthrough_op_handler.OutputNonPassthroughOpHandler(),
'ConcatV2':
concat_op_handler.ConcatOpHandler(),
})
# Create OpRegularizerManager and NetworkRegularizer for test.
manager = orm.OpRegularizerManager([output_op], op_handler_dict)
calculator = cc.CostCalculator(manager,
resource_function.flop_function)
# Calculate expected FLOP cost.
expected_alive_conv1 = sum(
add_concat_model_stub.expected_alive()['conv1'])
conv1_op = tf.get_default_graph().get_operation_by_name('conv1/Conv2D')
conv1_coeff = resource_function.flop_coeff(conv1_op)
num_channels = 3
expected_cost = conv1_coeff * num_channels * expected_alive_conv1
with self.session():
tf.global_variables_initializer().run()
# Set gamma values to replicate aliveness in add_concat_model_stub.
name_to_var = {v.op.name: v for v in tf.global_variables()}
gamma1 = name_to_var['conv1/BatchNorm/gamma']
gamma1.assign([0, 1, 1, 0, 1, 0, 1]).eval()
gamma4 = name_to_var['conv4/BatchNorm/gamma']
gamma4.assign([0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0]).eval()
queue.enqueue((non_image_tensor, image)).run()
self.assertEqual(expected_cost,
calculator.get_cost([conv1_op]).eval())
# for 0/1 assigments cost and reg_term are equal:
self.assertEqual(
expected_cost,
calculator.get_regularization_term([conv1_op]).eval())
@parameterized.named_parameters(
('_conv2d', 4, lambda x: layers.conv2d(x, 16, 3), 'Conv2D'),
('_convt', 4, lambda x: layers.conv2d_transpose(x, 16, 3),
'conv2d_transpose'),
('_conv2s', 4, lambda x: layers.separable_conv2d(x, None, 3),
'depthwise'),
('_conv3d', 5, lambda x: layers.conv3d(x, 16, 3), 'Conv3D'))
def test_get_input_activation2(self, rank, fn, op_name):
g = tf.get_default_graph()
inputs = tf.zeros([6] * rank)
with arg_scope([
layers.conv2d, layers.conv2d_transpose,
layers.separable_conv2d, layers.conv3d
],
scope='test_layer'):
_ = fn(inputs)
for op in g.get_operations():
print(op.name)
self.assertEqual(
inputs,
cc.get_input_activation(
g.get_operation_by_name('test_layer/' + op_name)))
def _build_net(self, inputs):
w_init = layers.variance_scaling_initializer()
conv1 = layers.conv3d(inputs=inputs,
padding="SAME",
num_outputs=64,
kernel_size=[5, 5, 5],
stride=2,
data_format="NDHWC",
weights_initializer=w_init,
activation_fn=tf.nn.relu)
conv2 = layers.conv3d(inputs=conv1,
padding="SAME",
num_outputs=128,
kernel_size=[3, 3, 3],
stride=1,
data_format="NDHWC",
weights_initializer=w_init,
activation_fn=tf.nn.relu)
conv3 = layers.conv3d(inputs=conv2,
padding="SAME",
num_outputs=256,
kernel_size=[3, 3, 3],
stride=2,
data_format="NDHWC",
weights_initializer=w_init,
activation_fn=None)
res = layers.conv3d(inputs=inputs,
padding="VALID",
num_outputs=256,
kernel_size=[4, 2, 4],
stride=3,
data_format="NDHWC",
weights_initializer=w_init,
activation_fn=None)
conv4_in = tf.nn.relu(conv3 + res)
conv4 = layers.conv3d(inputs=conv4_in,
padding="SAME",
num_outputs=256,
kernel_size=[2, 1, 2],
stride=2,
data_format="NDHWC",
weights_initializer=w_init,
activation_fn=tf.nn.relu)
conv5 = layers.conv3d(inputs=conv4,
padding="VALID",
num_outputs=512,
kernel_size=[2, 1, 2],
stride=1,
data_format="NDHWC",
weights_initializer=w_init,
activation_fn=None)
res2 = layers.conv3d(inputs=conv4_in,
padding="VALID",
num_outputs=512,
kernel_size=[3, 2, 3],
stride=1,
data_format="NDHWC",
weights_initializer=w_init,
activation_fn=None)
flat = tf.nn.relu(layers.flatten(conv5 + res2))
h1 = layers.fully_connected(inputs=flat, num_outputs=512)
h2 = layers.fully_connected(inputs=h1,
num_outputs=512,
activation_fn=None)
h3 = tf.nn.relu(h2 + flat)
#Recurrent network for temporal dependencies
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(512, state_is_tuple=True)
c_init = np.zeros((1, lstm_cell.state_size.c), np.float32)
h_init = np.zeros((1, lstm_cell.state_size.h), np.float32)
state_init = [c_init, h_init]
c_in = tf.placeholder(tf.float32, [1, lstm_cell.state_size.c])
h_in = tf.placeholder(tf.float32, [1, lstm_cell.state_size.h])
state_in = (c_in, h_in)
rnn_in = tf.expand_dims(h3, [0])
step_size = tf.shape(inputs)[:1]
state_in = tf.nn.rnn_cell.LSTMStateTuple(c_in, h_in)
lstm_outputs, lstm_state = tf.nn.dynamic_rnn(lstm_cell,
rnn_in,
initial_state=state_in,
sequence_length=step_size,
time_major=False)
lstm_c, lstm_h = lstm_state
state_out = (lstm_c[:1, :], lstm_h[:1, :])
rnn_out = tf.reshape(lstm_outputs, [-1, 512])
policy_layer = layers.fully_connected(
inputs=rnn_out,
num_outputs=a_size,
weights_initializer=normalized_columns_initializer(1. /
float(a_size)),
biases_initializer=None,
activation_fn=None)
policy = tf.nn.softmax(policy_layer)
policy_sig = tf.sigmoid(policy_layer)
value = layers.fully_connected(
inputs=rnn_out,
num_outputs=1,
weights_initializer=normalized_columns_initializer(1.0),
biases_initializer=None,
activation_fn=None)
has_block = layers.fully_connected(
inputs=rnn_out,
num_outputs=1,
weights_initializer=normalized_columns_initializer(1.0),
biases_initializer=None,
activation_fn=tf.sigmoid)
is_built = layers.fully_connected(
inputs=rnn_out,
num_outputs=1,
weights_initializer=normalized_columns_initializer(1.0),
biases_initializer=None,
activation_fn=tf.sigmoid)
return policy, value, state_out, state_in, state_init, has_block, policy_sig, is_built
def conv3d_same(inputs, num_outputs, kernel_size, stride, rate=1, scope=None, outputs_collections=None):
"""Strided 3-D convolution with 'SAME' padding.
When stride > 1, then we do explicit zero-padding, followed by conv2d with
'VALID' padding.
Note that
net = conv2d_same(inputs, num_outputs, 3, stride=stride)
is equivalent to
net = tf.contrib.layers.conv2d(inputs, num_outputs, 3, stride=1,
padding='SAME')
net = subsample(net, factor=stride)
whereas
net = tf.contrib.layers.conv2d(inputs, num_outputs, 3, stride=stride,
padding='SAME')
is different when the input's height or width is even, which is why we add the
current function. For more details, see ResnetUtilsTest.testConv2DSameEven().
Args:
inputs: A 4-D tensor of size [batch, height_in, width_in, channels].
num_outputs: An integer, the number of output filters.
kernel_size: An int with the kernel_size of the filters.
stride: An integer, the output stride.
rate: An integer, rate for atrous convolution.
scope: Scope.
Returns:
output: A 4-D tensor of size [batch, height_out, width_out, channels] with
the convolution output.
"""
if stride == 1:
return layers_lib.conv3d(
inputs,
num_outputs,
kernel_size,
stride=1,
rate=rate,
padding='SAME',
scope=scope,
outputs_collections=None)
else:
if type(kernel_size)==list:
kernel = np.array(kernel_size)
pad_total = kernel - 1
pad_beg = pad_total // 2
pad_end = pad_total - pad_beg
inputs = array_ops.pad(inputs, [[0, 0], [pad_beg[0], pad_end[0]], [pad_beg[1], pad_end[1]], [pad_beg[2], pad_end[2]], [0, 0]])
else:
kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
pad_total = kernel_size_effective - 1
pad_beg = pad_total // 2
pad_end = pad_total - pad_beg
inputs = array_ops.pad(inputs, [[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]])
return layers_lib.conv3d(
inputs,
num_outputs,
kernel_size,
stride=stride,
rate=rate,
padding='VALID',
scope=scope,
outputs_collections=None)
