def model_fn(x, target, mode, params):
"""Model function for Estimator."""
y_ = tf.cast(target, tf.float32)
x_image = tf.reshape(x, [-1, 28, 28, 1])
# first convolutional layer
h_conv1 = layers.convolution2d(x_image, 32, [5,5])
h_pool1 = layers.max_pool2d(h_conv1, [2,2])
# second convolutional layer
h_conv2 = layers.convolution2d(h_pool1, 64, [5,5])
h_pool2 = layers.max_pool2d(h_conv2, [2,2])
# densely connected layer
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = layers.fully_connected(h_pool2_flat, 1024)
h_fc1_drop = layers.dropout(
h_fc1, keep_prob=params["dropout"],
is_training=(mode == ModeKeys.TRAIN))
# readout layer
y_conv = layers.fully_connected(h_fc1_drop, 10, activation_fn=None)
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(y_conv, y_))
train_op = tf.contrib.layers.optimize_loss(
loss=cross_entropy,
global_step=tf.contrib.framework.get_global_step(),
learning_rate=params["learning_rate"],
optimizer="Adam")
predictions = tf.argmax(y_conv, 1)
return predictions, cross_entropy, train_op
def model(img_in, num_actions, scope, noisy=False, reuse=False,
concat_softmax=False):
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out, num_outputs=32, kernel_size=8,
stride=4, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=4,
stride=2, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=3,
stride=1, activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("action_value"):
if noisy:
# Apply noisy network on fully connected layers
# ref: https://arxiv.org/abs/1706.10295
out = noisy_dense(out, name='noisy_fc1', size=512,
activation_fn=tf.nn.relu)
out = noisy_dense(out, name='noisy_fc2', size=num_actions)
else:
out = layers.fully_connected(out, num_outputs=512,
activation_fn=tf.nn.relu)
out = layers.fully_connected(out, num_outputs=num_actions,
activation_fn=None)
# V: Softmax - inspired by deep-rl-attack #
if concat_softmax:
out = tf.nn.softmax(out)
return out
def dueling_model(img_in, num_actions, scope, reuse=False, layer_norm=False):
"""As described in https://arxiv.org/abs/1511.06581"""
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out, num_outputs=32, kernel_size=8, stride=4, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=4, stride=2, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu)
conv_out = layers.flatten(out)
with tf.variable_scope("state_value"):
state_hidden = layers.fully_connected(conv_out, num_outputs=512, activation_fn=None)
if layer_norm:
state_hidden = layer_norm_fn(state_hidden, relu=True)
else:
state_hidden = tf.nn.relu(state_hidden)
state_score = layers.fully_connected(state_hidden, num_outputs=1, activation_fn=None)
with tf.variable_scope("action_value"):
actions_hidden = layers.fully_connected(conv_out, num_outputs=512, activation_fn=None)
if layer_norm:
actions_hidden = layer_norm_fn(actions_hidden, relu=True)
else:
actions_hidden = tf.nn.relu(actions_hidden)
action_scores = layers.fully_connected(actions_hidden, num_outputs=num_actions, activation_fn=None)
action_scores_mean = tf.reduce_mean(action_scores, 1)
action_scores = action_scores - tf.expand_dims(action_scores_mean, 1)
return state_score + action_scores
def dueling_model(img_in, num_actions, scope, noisy=False, reuse=False,
concat_softmax=False):
"""As described in https://arxiv.org/abs/1511.06581"""
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out, num_outputs=32, kernel_size=8,
stride=4, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=4,
stride=2, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=3,
stride=1, activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("state_value"):
if noisy:
# Apply noisy network on fully connected layers
# ref: https://arxiv.org/abs/1706.10295
state_hidden = noisy_dense(out, name='noisy_fc1', size=512,
activation_fn=tf.nn.relu)
state_score = noisy_dense(state_hidden, name='noisy_fc2',
size=1)
else:
state_hidden = layers.fully_connected(
out,
num_outputs=512,
activation_fn=tf.nn.relu
)
state_score = layers.fully_connected(state_hidden,
num_outputs=1,
activation_fn=None)
with tf.variable_scope("action_value"):
if noisy:
# Apply noisy network on fully connected layers
# ref: https://arxiv.org/abs/1706.10295
actions_hidden = noisy_dense(out, name='noisy_fc1', size=512,
activation_fn=tf.nn.relu)
action_scores = noisy_dense(actions_hidden, name='noisy_fc2',
size=num_actions)
else:
actions_hidden = layers.fully_connected(
out,
num_outputs=512,
activation_fn=tf.nn.relu
)
action_scores = layers.fully_connected(
actions_hidden,
num_outputs=num_actions,
activation_fn=None
)
action_scores_mean = tf.reduce_mean(action_scores, 1)
action_scores = action_scores - tf.expand_dims(
action_scores_mean,
1
)
return state_score + action_scores
def create_network(self, scope):
with tf.variable_scope(scope, reuse=False):
state_input = tf.placeholder('float', [None, 84, 84, 4])
out = layers.convolution2d(state_input, num_outputs=32, kernel_size=8, stride=1, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=4, stride=2, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu)
conv_out = layers.flatten(out)
value_out = layers.fully_connected(conv_out, num_outputs=256, activation_fn=tf.nn.relu)
q_value = layers.fully_connected(value_out, num_outputs=self.action_dim, activation_fn=None)
return state_input, q_value
def atari_model(img_in, num_actions, scope, reuse=False):
# as described in https://storage.googleapis.com/deepmind-data/assets/papers/DeepMindNature14236Paper.pdf
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out, num_outputs=32, kernel_size=8, stride=4, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=4, stride=2, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("action_value"):
out = layers.fully_connected(out, num_outputs=512, activation_fn=tf.nn.relu)
out = layers.fully_connected(out, num_outputs=num_actions, activation_fn=None)
return out
def _cnn_to_mlp(convs, hiddens, dueling, inpt, num_actions, scope, reuse=False, layer_norm=False):
with tf.variable_scope(scope, reuse=reuse):
out = inpt
with tf.variable_scope("convnet"):
for num_outputs, kernel_size, stride in convs:
out = layers.convolution2d(out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
activation_fn=tf.nn.relu)
conv_out = layers.flatten(out)
with tf.variable_scope("action_value"):
action_out = conv_out
for hidden in hiddens:
action_out = layers.fully_connected(action_out, num_outputs=hidden, activation_fn=None)
if layer_norm:
action_out = layers.layer_norm(action_out, center=True, scale=True)
action_out = tf.nn.relu(action_out)
action_scores = layers.fully_connected(action_out, num_outputs=num_actions, activation_fn=None)
if dueling:
with tf.variable_scope("state_value"):
state_out = conv_out
for hidden in hiddens:
state_out = layers.fully_connected(state_out, num_outputs=hidden, activation_fn=None)
if layer_norm:
state_out = layers.layer_norm(state_out, center=True, scale=True)
state_out = tf.nn.relu(state_out)
state_score = layers.fully_connected(state_out, num_outputs=1, activation_fn=None)
action_scores_mean = tf.reduce_mean(action_scores, 1)
action_scores_centered = action_scores - tf.expand_dims(action_scores_mean, 1)
q_out = state_score + action_scores_centered
else:
q_out = action_scores
return q_out
def terra_module(self, variable_scope, input_tensor, convolution_output_depth, kernel_size=3, dropout_on=False,
normalization_function=default_normalization, activation_function=default_activation,
strided_max_pool_on=False):
"""
A basic square 2D convolution layer followed by optional batch norm and dropout.
:param variable_scope: What to name the module scope in the graph.
:type variable_scope: str
:param input_tensor: The input tensor to work on.
:type input_tensor: tf.Tensor
:param convolution_output_depth: The output depth of the convolution.
:type convolution_output_depth: int
:param kernel_size: The size of the square convolutional kernel.
:type kernel_size: int
:param dropout_on: A boolean to choose whether or not dropout should be applied.
:type dropout_on: bool
:param normalization_function: A normalization to be applied before activations. Defaults to batch_norm.
:type normalization_function: tf.Tensor -> tf.Tensor
:param activation_function: The activation function to be applied.
:type activation_function: tf.Tensor -> tf.Tensor\
:param strided_max_pool_on: Whether to include a strided max pool at the end of the module.
:type strided_max_pool_on: bool
:return: The output activation tensor.
:rtype: tf.Tensor
"""
with tf.variable_scope(variable_scope):
output_tensor = convolution2d(input_tensor, convolution_output_depth, [kernel_size, kernel_size],
activation_fn=activation_function, normalizer_fn=normalization_function,
padding='same')
output_tensor = self.general_module_end_operations(output_tensor, dropout_on, strided_max_pool_on)
return output_tensor
def mercury_module(self, variable_scope, input_tensor, aisle_convolution_depth, spatial_convolution_depth,
max_pool_depth, dropout_on=False, normalization_function=default_normalization,
activation_function=default_activation, strided_max_pool_on=False):
"""
This module has 4 parts. A simple 1x1 dimensionality shift (the aisle convolution), a 1x3 convolution, a 3x1
convolution, and a 2x2 max pooling with dimensionality shift. All have stride of 1. The outputs of each part are
concatenated to form an output tensor.
:param variable_scope: What to name the module scope in the graph.
:type variable_scope: str
:param input_tensor: The input tensor to work on.
:type input_tensor: tf.Tensor
:param aisle_convolution_depth: The output depth of the 1x1 convolution.
:type aisle_convolution_depth: int
:param spatial_convolution_depth: The output depth of the 1x3 and 3x1 convolutions (each).
:type spatial_convolution_depth: int
:param max_pool_depth: The output depth of the (dimensional shifted) max pool.
:type max_pool_depth: int
:param dropout_on: A boolean to choose whether or not dropout should be applied.
:type dropout_on: bool
:param normalization_function: A normalization to be applied before activations. Defaults to batch_norm.
:type normalization_function: tf.Tensor -> tf.Tensor
:param activation_function: The activation function to be applied.
:type activation_function: tf.Tensor -> tf.Tensor
:param strided_max_pool_on: Whether to include a strided max pool at the end of the module.
:type strided_max_pool_on: bool
:return: The output activation tensor.
:rtype: tf.Tensor
"""
with tf.variable_scope(variable_scope):
part1 = convolution2d(input_tensor, aisle_convolution_depth, [1, 1], activation_fn=activation_function,
normalizer_fn=normalization_function)
part2 = convolution2d(input_tensor, spatial_convolution_depth, [3, 1], activation_fn=activation_function,
normalizer_fn=normalization_function)
part3 = convolution2d(input_tensor, spatial_convolution_depth, [1, 3], activation_fn=activation_function,
normalizer_fn=normalization_function)
max_pool_output = max_pool2d(input_tensor, kernel_size=2, stride=1, padding='SAME')
part4 = convolution2d(max_pool_output, max_pool_depth, [1, 1], activation_fn=activation_function,
normalizer_fn=normalization_function)
output_tensor = tf.concat(axis=3, values=[part1, part2, part3, part4])
output_tensor = self.general_module_end_operations(output_tensor, dropout_on, strided_max_pool_on)
return output_tensor
def conv2d(tensor_in,
n_filters,
filter_shape,
strides=None,
padding="SAME",
bias=True,
activation=None,
batch_norm=False):
"""Creates 2D convolutional subgraph with bank of filters.
This is deprecated. Please use contrib.layers.convolution2d.
Uses tf.nn.conv2d under the hood.
Creates a filter bank:
[filter_shape[0], filter_shape[1], tensor_in[3], n_filters]
and applies it to the input tensor.
Args:
tensor_in: input Tensor, 4D shape:
[batch, in_height, in_width, in_depth].
n_filters: number of filters in the bank.
filter_shape: Shape of filters, a list of ints, 1-D of length 2.
strides: A list of ints, 1-D of length 4. The stride of the sliding
window for each dimension of input.
padding: A string: 'SAME' or 'VALID'. The type of padding algorthim to use.
See the [comment here]
(https://www.tensorflow.org/api_docs/python/nn.html#convolution)
bias: Boolean, if to add bias.
activation: Activation Op, optional. If provided applied on the output.
batch_norm: Whether to apply batch normalization.
Returns:
A Tensor with resulting convolution.
"""
if batch_norm:
logging.warn("batch_norm will not work with learn.ops.conv2d, "
"use tf.contrib.layers.conv2d.")
if bias:
bias_init = init_ops.zeros_initializer
if strides is None:
strides = [1, 1]
else:
strides = strides[1:3] # only take height and width
logging.warn("strides may not be passed correctly. Please instead "
"use and see documentation for contrib.layers.convolution2d.")
return convolution2d(
tensor_in,
num_outputs=n_filters,
kernel_size=list(filter_shape),
stride=strides,
padding=padding,
biases_initializer=bias_init,
activation_fn=activation)
def make_convs(inpt, convs, padding, scope='convnet', reuse=None):
out = inpt
with tf.variable_scope(scope, reuse=reuse):
for num_outputs, kernel_size, stride in convs:
out = layers.convolution2d(
out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
padding=padding,
activation_fn=tf.nn.elu
)
return out
def dqn_model(X, S, s_dim, a_dim, k, skip=False):
print "DQN model"
S = tf.cast(S, dtype=tf.float32)
state = tf.concat([X, S], axis=3)
ch_h = 16
# store Q(s,a) value
q_a = tf.Variable(0, dtype=tf.float32, name="q_a", trainable=False)
# original architecture
out = layers.convolution2d(state,
num_outputs=32,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
out = layers.fully_connected(out, num_outputs=64, activation_fn=tf.nn.relu)
out = layers.fully_connected(out, num_outputs=a_dim, activation_fn=None)
q_a += out
# pi mapping from q to action
pi = layers.fully_connected(q_a, num_outputs=16, activation_fn=None)
pi_logits = layers.fully_connected(pi,
num_outputs=a_dim,
activation_fn=None)
pi_action = tf.nn.softmax(pi_logits, name="pi_action")
return pi_logits, pi_action
def q_network(X_state, scope):
prev_layer = X_state
conv_layers = []
with tf.variable_scope(scope) as scope:
for n_maps, kernel_size, stride, padding, activation in zip(
conv_n_maps, conv_kernel_sizes, conv_strides,
conv_paddings, conv_activation):
prev_layer = convolution2d(
prev_layer, num_outputs=n_maps, kernel_size=kernel_size,
stride=stride, padding=padding, activation_fn=activation,
weights_initializer=initializer)
conv_layers.append(prev_layer)
last_conv_layer_flat = tf.reshape(prev_layer, shape=[-1, n_hidden_in])
hidden = fully_connected(
last_conv_layer_flat, n_hidden, activation_fn=hidden_activation,
weights_initializer=initializer)
outputs = fully_connected(
hidden, n_outputs, activation_fn=None,
weights_initializer=initializer)
trainable_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=scope.name)
trainable_vars_by_name = {var.name[len(scope.name):]: var
for var in trainable_vars}
return outputs, trainable_vars_by_name
X_state = tf.placeholder(tf.float32, shape=[None, input_height, input_width, input_channels])
actor_q_values, actor_vars = q_network(X_state, scope="q_networks/actor")
critic_q_values, critic_vars = q_network(X_state, scope="q_networks/critic")
copy_ops = [actor_var.assign(critic_vars[var_name]) for var_name, actor_var in actor_vars.items()]
copy_critic_to_actor = tf.group(*copy_ops)
X_action = tf.placeholder(tf.int32, shape=[None])
q_value = tf.reduce_sum(critic_q_values * tf.one_hot(X_action, n_outputs), axis=1, keep_dims=True)
y = tf.placeholder(tf.float32, shape=[None, 1])
cost = tf.reduce_mean(tf.square(y - q_value))
global_step = tf.Variable(0, trainable=False, name='global_step')
optimizer = tf.train.AdamOptimizer(learning_rate)
training_op = optimizer.minimize(cost, global_step=global_step)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
def sample_memories(batch_size):
indices = rnd.permutation(len(replay_memory))[:batch_size]
cols = [[], [], [], [], []] # state, action, reward, next_state, continue
for idx in indices:
memory = replay_memory[idx]
for col, value in zip(cols, memory):
col.append(value)
cols = [np.array(col) for col in cols]
return (cols[0], cols[1], cols[2].reshape(-1, 1), cols[3], cols[4].reshape(-1, 1))
def _cnn_to_mlp(convs,
hiddens,
dueling,
inpt,
num_actions,
scope,
reuse=False,
layer_norm=False):
with tf.variable_scope(scope, reuse=reuse):
out = inpt
with tf.variable_scope("convnet"):
for num_outputs, kernel_size, stride in convs:
out = layers.convolution2d(
out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
activation_fn=tf.nn.relu)
conv_out = layers.flatten(out)
with tf.variable_scope("action_value"):
action_out = conv_out
for hidden in hiddens:
action_out = layers.fully_connected(
action_out, num_outputs=hidden, activation_fn=None)
if layer_norm:
action_out = layers.layer_norm(
action_out, center=True, scale=True)
action_out = tf.nn.relu(action_out)
action_scores = layers.fully_connected(
action_out, num_outputs=num_actions, activation_fn=None)
if dueling:
with tf.variable_scope("state_value"):
state_out = conv_out
for hidden in hiddens:
state_out = layers.fully_connected(
state_out, num_outputs=hidden, activation_fn=None)
if layer_norm:
state_out = layers.layer_norm(
state_out, center=True, scale=True)
state_out = tf.nn.relu(state_out)
state_score = layers.fully_connected(
state_out, num_outputs=1, activation_fn=None)
action_scores_mean = tf.reduce_mean(action_scores, 1)
action_scores_centered = action_scores - tf.expand_dims(
action_scores_mean, 1)
q_out = state_score + action_scores_centered
else:
q_out = action_scores
return q_out
def atari_model(img_in,
num_actions,
scope,
reuse=False,
dropout=False,
keep_prob=1.0):
# as described in https://storage.googleapis.com/deepmind-data/assets/papers/DeepMindNature14236Paper.pdf
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out,
num_outputs=32,
kernel_size=8,
stride=4,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=4,
stride=2,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("action_value"):
out = layers.fully_connected(out,
num_outputs=512,
activation_fn=tf.nn.relu)
if dropout:
out = layers.dropout(out, keep_prob=keep_prob)
out = layers.fully_connected(out,
num_outputs=num_actions,
activation_fn=None)
return out
def bootstrap_model(img_in, num_actions, scope, reuse=False, heads=10):
""" As described in https://arxiv.org/abs/1602.04621"""
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out,
num_outputs=32,
kernel_size=8,
stride=4,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=4,
stride=2,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
out_list = []
with tf.variable_scope("heads"):
for _ in range(heads):
scope_net = "action_value_head_" + str(_)
with tf.variable_scope(scope_net):
out_temp = out
out_temp = layers.fully_connected(out_temp,
num_outputs=512,
activation_fn=tf.nn.relu)
out_temp = layers.fully_connected(out_temp,
num_outputs=num_actions,
activation_fn=None)
out_list.append(out_temp)
return out_list
def unit_representation_model_cnn(img_in, num_actions, scope, reuse=False):
"""As described in https://storage.googleapis.com/deepmind-data/assets/papers/DeepMindNature14236Paper.pdf"""
img_size = img_in.shape[1]
print("img shape", img_in.shape)
with tf.variable_scope(scope, reuse=reuse):
out = img_in
# coordinate = np.meshgrid()
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out,
num_outputs=32,
kernel_size=8,
stride=4,
activation_fn=tf.nn.leaky_relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=4,
stride=2,
activation_fn=tf.nn.leaky_relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.leaky_relu)
out = layers.flatten(out)
out = layers.fully_connected(out,
num_outputs=32,
activation_fn=tf.nn.leaky_relu)
z = layers.fully_connected(out, num_outputs=32, activation_fn=None)
normed_z = z / tf.maximum(1e-10, tf.norm(z, axis=1, keepdims=True))
# normed_z =
# print("normed_z:", normed_z.shape)
# with tf.variable_scope("action_value"):
# v_h = layers.fully_connected(z, num_outputs=512, activation_fn=tf.nn.relu)
# v = layers.fully_connected(v_h, num_outputs=1, activation_fn=None)
return normed_z
def nature_cnn(self, state, scope, reuse=False):
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)
# Berkeley Deep RL implementation
with tf.variable_scope(scope, reuse=reuse):
# with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out,
num_outputs=size1,
kernel_size=8,
stride=4,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=size2,
kernel_size=4,
stride=2,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=size3,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
# with tf.variable_scope("action_value"):
out = layers.fully_connected(out,
num_outputs=size4,
activation_fn=tf.nn.relu)
out = layers.fully_connected(out,
num_outputs=num_actions,
activation_fn=None)
return out
def discriminator(input_img, input_latent):
# input_img = Input(batch_shape=(None, 3, 32, 32), dtype=im_dtype)
with tf.variable_scope('Net_Dis') as scope:
# pdb.set_trace()
input_latent_d = tf.tile(tf.reshape(input_latent, [-1,1,1,tf.shape(input_latent)[-1]]), [1,tf.shape(input_img)[1],tf.shape(input_img)[2],1] )
xx = tf.concat( [input_latent_d, input_img], axis=3)
xx = tf.nn.dropout(input_img, 0.8)
xx = layers.convolution2d(xx, 96, kernel_size=(3,3), stride=(1, 1), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = layers.convolution2d(xx, 96, kernel_size=(3,3), stride=(1, 1), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = layers.convolution2d(xx, 96, kernel_size=(3,3), stride=(2, 2), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = tf.nn.dropout(xx, 0.5)
xx = layers.convolution2d(xx, 192, kernel_size=(3,3), stride=(1, 1), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = layers.convolution2d(xx, 192, kernel_size=(3,3), stride=(1, 1), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = layers.convolution2d(xx, 192, kernel_size=(3,3), stride=(2, 2), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = tf.nn.dropout(xx, 0.5)
xx = layers.convolution2d(xx, 192, kernel_size=(3,3), stride=(1, 1), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = layers.convolution2d(xx, 192, kernel_size=(1,1), stride=(1, 1), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx = layers.convolution2d(xx, 192, kernel_size=(1,1), stride=(1, 1), padding='same', activation_fn=None)
xx = layers.batch_norm(xx)
xx = lrelu(xx)
xx0 = tf.reduce_mean(xx, axis=[1, 2])
xx = layers.fully_connected(xx0, label_size, activation_fn=None)
logits = layers.batch_norm(xx)
return logits, xx0
def conv1d(self, net, num_ker, ker_size, stride):
# 1D-convolution
net = convolution2d(
net,
num_outputs=num_ker,
kernel_size=[ker_size, 1],
stride=[stride, 1],
padding='SAME',
activation_fn=None,
normalizer_fn=None,
weights_initializer=variance_scaling_initializer(),
weights_regularizer=l2_regularizer(self.weight_decay),
biases_initializer=tf.zeros_initializer)
return net
def make_cnn(convs, padding, inpt, initializer=None):
if initializer is None:
initializer = tf.orthogonal_initializer(np.sqrt(2.0))
out = inpt
with tf.variable_scope('convnet'):
for num_outputs, kernel_size, stride in convs:
out = layers.convolution2d(out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
padding=padding,
activation_fn=tf.nn.relu,
weights_initializer=initializer)
return out
def model(img_in, num_actions, scope, noisy=False, reuse=False, concat_softmax=False):
"""As described in https://storage.googleapis.com/deepmind-data/assets/papers/DeepMindNature14236Paper.pdf"""
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(
out, num_outputs=32, kernel_size=8, stride=4, activation_fn=tf.nn.relu)
out = layers.convolution2d(
out, num_outputs=64, kernel_size=4, stride=2, activation_fn=tf.nn.relu)
out = layers.convolution2d(
out, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("action_value"):
out = layers.fully_connected(
out, num_outputs=512, activation_fn=tf.nn.relu)
out = layers.fully_connected(
out, num_outputs=num_actions, activation_fn=None)
#V: Softmax - inspired by deep-rl-attack #
if concat_softmax:
out = tf.nn.softmax(out)
return out
def model(img_in, num_actions, scope, reuse=False, layer_norm=False, distributed=False, atoms=51):
"""As described in https://storage.googleapis.com/deepmind-data/assets/papers/DeepMindNature14236Paper.pdf"""
print("create default model: distributed? ", distributed, "atoms", atoms)
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out, num_outputs=32, kernel_size=8, stride=4, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=4, stride=2, activation_fn=tf.nn.relu)
out = layers.convolution2d(out, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu)
conv_out = layers.flatten(out)
with tf.variable_scope("action_value"):
value_out = layers.fully_connected(conv_out, num_outputs=512, activation_fn=None)
if layer_norm:
value_out = layer_norm_fn(value_out, relu=True)
else:
value_out = tf.nn.relu(value_out)
value_out = layers.fully_connected(value_out, num_outputs=num_actions*atoms, activation_fn=None)
if distributed:
value_out = tf.reshape(value_out, [-1, num_actions, atoms])
print("output shape:", tf.shape(value_out))
return value_out
def _encode_conv(self,
x,
conv_params,
scope='obs_conv_encoding',
layer_norm=False,
nonlinearity='swish',
spatial_softmax=False,
reuse=False):
with tf.variable_scope(scope, reuse=reuse):
out = x
for num_outputs, kernel_size, stride, padding in conv_params:
out = layers.convolution2d( out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
padding=padding,
activation_fn=None)
if layer_norm is True:
#out = layers.layer_norm(out, center=True, scale=True)
out = layers.layer_norm(out)
# Apply the non-linearity after layer-norm
if nonlinearity == 'swish':
out = tf.nn.sigmoid(out)*out #swish non-linearity
elif nonlinearity == 'relu':
out = tf.nn.relu(out)
if spatial_softmax:
shape = tf.shape(out)
static_shape = out.shape
height, width, num_channels = shape[1], shape[2], static_shape[3]
pos_x, pos_y = tf.meshgrid(tf.linspace(-1., 1., num=height),
tf.linspace(-1., 1., num=width),
indexing='ij')
pos_x = tf.reshape(pos_x, [height*width])
pos_y = tf.reshape(pos_y, [height*width])
out = tf.reshape(tf.transpose(out, [0,3,1,2]), [-1, height*width])
softmax_attention = tf.nn.softmax(out)
expected_x = tf.reduce_sum(pos_x*softmax_attention, [1], keep_dims=True)
expected_y = tf.reduce_sum(pos_y*softmax_attention, [1], keep_dims=True)
expected_xy = tf.concat([expected_x, expected_y], 1)
feature_keypoints = tf.reshape(expected_xy, [-1, num_channels.value*2])
feature_keypoints.set_shape([None, num_channels.value*2])
return feature_keypoints
else:
out = layers.flatten(out) # flatten the conv output
return out
def discriminator_forward(img, reuse=None, name="discriminator"):
with tf.variable_scope(name, reuse=reuse):
# size is 28, 28, 64
out = layers.convolution2d(img,
num_outputs=64,
kernel_size=3,
stride=1)
# size is 14, 14, 128
out = layers.convolution2d(out,
num_outputs=128,
kernel_size=3,
stride=2)
# size is 7, 7, 256
out = layers.convolution2d(out,
num_outputs=256,
kernel_size=3,
stride=2)
# size is 12544
out = layers.flatten(out)
prob = layers.fully_connected(out,
num_outputs=1,
activation_fn=tf.nn.sigmoid)
return prob
def _decode(self, feature_map, is_training):
h = L.convolution2d_transpose(feature_map, 128, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.convolution2d(h, len(self.classes) + 1, [1, 1], [1, 1], activation_fn=None)
return h
def atari_model(img_in, num_actions, scope, reuse=False):
# as described in https://storage.googleapis.com/deepmind-data/assets/papers/DeepMindNature14236Paper.pdf
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope("convnet"):
# original architecture
out = layers.convolution2d(out,
num_outputs=32,
kernel_size=8,
stride=4,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=4,
stride=2,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("action_value"):
out = layers.fully_connected(out,
num_outputs=512,
activation_fn=tf.nn.relu)
out = layers.fully_connected(out,
num_outputs=num_actions,
activation_fn=None)
'''with tf.variable_scope("value_stream"):
value_out = layers.fully_connected(out, num_outputs=512, activation_fn=tf.nn.relu)
value_out = layers.fully_connected(value_out, num_outputs=1)
with tf.variable_scope("advantage_stream"):
ad_out = layers.fully_connected(out, num_outputs=512, activation_fn=tf.nn.relu)
ad_out = layers.fully_connected(ad_out, num_outputs=num_actions)
out = value_out+ad_out-tf.reduce_mean(ad_out,axis=1,keep_dims=True)'''
return out
def dueling_model(img_in, num_actions, scope, reuse=False):
with tf.variable_scope(scope, reuse=reuse):
out = img_in
with tf.variable_scope('convnet'):
out = layers.convolution2d(out,
num_outputs=32,
kernel_size=8,
stride=4,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=4,
stride=2,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope('state_value'):
v_hidden = layers.fully_connected(out,
num_outputs=512,
activation_fn=tf.nn.relu)
state_val = layers.fully_connected(v_hidden,
num_outputs=1,
activation_fn=None)
with tf.variable_scope('adv_value'):
adv_hidden = layers.fully_connected(out,
num_outputs=512,
activation_fn=tf.nn.relu)
adv = layers.fully_connected(adv_hidden,
num_outputs=num_actions,
activation_fn=None)
adv_mean = tf.reduce_mean(adv, axis=1, keepdims=True)
adv -= adv_mean
return state_val + adv
def pyramid_pooling_layer(net):
sd = net.get_shape()[1:3]
sd1 = [sd[0].value, sd[1].value]
sd2 = [sd[0].value // 2, sd[1].value // 2]
sd3 = [sd1[0] // 3, sd1[1] // 3]
sd4 = [sd1[0] // 6, sd1[1] // 6]
upsampled_size = [
FLAGS.img_height // FLAGS.subsample_factor,
FLAGS.img_width // FLAGS.subsample_factor
]
first = layers.avg_pool2d(net, kernel_size=sd1)
first_conv = layers.convolution2d(first, 128, kernel_size=1)
first_up = tf.image.resize_bilinear(
first_conv, upsampled_size, name='spp-1')
second = layers.max_pool2d(net, kernel_size=sd2, stride=sd2)
second_conv = layers.convolution2d(
second, 128, kernel_size=1, scope='spp-2')
second_up = tf.image.resize_bilinear(
second_conv, upsampled_size, name='spp-2')
third = layers.max_pool2d(net, kernel_size=sd3, stride=sd3)
third_conv = layers.convolution2d(third, 128, kernel_size=1, scope='spp-3')
third_up = tf.image.resize_bilinear(
third_conv, upsampled_size, name='spp-3')
forth = layers.max_pool2d(net, kernel_size=sd4, stride=sd4)
forth_conv = layers.convolution2d(forth, 128, kernel_size=1, scope='spp-4')
forth_up = tf.image.resize_bilinear(
forth_conv, upsampled_size, name='spp-4')
stacked = tf.concat(
3, [first_up, second_up, third_up, forth_up], name='spp')
print('result shape', stacked.get_shape())
return stacked
def __call__(self, z, reuse=True):
with tf.variable_scope(self.name) as vs:
if reuse:
vs.reuse_variables()
bs = tf.shape(z)[0]
z = tf.reshape(z, [bs, 256, 256, 3])
conv = tcl.convolution2d(
z,
32, [4, 4], [2, 2],
weights_initializer=tf.random_normal_initializer(stddev=0.02),
activation_fn=tf.identity)
conv = tcl.max_pool2d(conv, [2, 2])
#(bs, 64, 64, 32)
conv = leaky_relu(conv)
for _ in range(2):
conv = tcl.convolution2d(
conv,
64, [4, 4], [2, 2],
weights_initializer=tf.random_normal_initializer(
stddev=0.02),
activation_fn=tf.identity)
conv = tcl.max_pool2d(conv, [2, 2])
#conv = tc.layers.batch_norm(conv,decay=0.9,scale=True,updates_collections=None)
conv = leaky_relu(conv)
#(bs, 4, 4, 64)
#fc = tf.reshape(conv, [bs, -1])
fc = tcl.flatten(conv)
#(bs, 1568)
fc = tcl.fully_connected(
fc,
1024,
weights_initializer=tf.random_normal_initializer(stddev=0.02),
activation_fn=tf.identity)
#fc = tc.layers.batch_norm(fc,decay=0.9,scale=True,updates_collections=None)
fc = leaky_relu(fc)
output = tcl.fully_connected(fc, 1, activation_fn=tf.identity)
return output
def _cnn_to_dist_mlp(convs, hiddens, dueling, inpt, n_action, nb_atoms, scope, reuse=False, layer_norm=False):
with tf.variable_scope(scope, reuse=reuse):
out = inpt
with tf.variable_scope("convnet"):
for num_outputs, kernel_size, stride in convs:
out = layers.convolution2d(out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
activation_fn=tf.nn.relu)
conv_out = layers.flatten(out)
with tf.variable_scope("action_value"):
action_out = conv_out
for hidden in hiddens:
action_out = layers.fully_connected(action_out, num_outputs=hidden, activation_fn=None)
if layer_norm:
action_out = layers.layer_norm(action_out, center=True, scale=True)
action_out = tf.nn.relu(action_out)
action_scores = layers.fully_connected(action_out, num_outputs=n_action * 3 * nb_atoms, activation_fn=None)
if dueling:
raise ValueError('Dueling not supported')
# with tf.variable_scope("state_value"):
# state_out = conv_out
# for hidden in hiddens:
# state_out = layers.fully_connected(state_out, num_outputs=hidden, activation_fn=None)
# if layer_norm:
# state_out = layers.layer_norm(state_out, center=True, scale=True)
# state_out = tf.nn.relu(state_out)
# state_score = layers.fully_connected(state_out, num_outputs=1, activation_fn=None)
# action_scores_mean = tf.reduce_mean(action_scores, 1)
# action_scores_centered = action_scores - tf.expand_dims(action_scores_mean, 1)
# q_out = state_score + action_scores_centered
else:
_out = tf.reshape(action_scores, shape=[-1, n_action, 3*nb_atoms])
out_pi_hat, out_sigma_hat, out_mu = tf.split(_out, 3, axis=-1)
out_pi_hat = tf.exp(out_pi_hat - tf.reduce_max(out_pi_hat, -1, keepdims=True))
nor_pi = tf.reciprocal(tf.reduce_sum(out_pi_hat, -1, keepdims=True))
out_pi = tf.multiply(nor_pi, out_pi_hat)
# out_sigma = 10*tf.sigmoid(out_sigma_hat) + 0.1 # + 1e-8
out_sigma = tf.exp(out_sigma_hat) + 0.01
#out = tf.map_fn(lambda x: tf.scalar_mul(1.,x), out) # lower sparsity
#out = tf.map_fn(tf.contrib.sparsemax.sparsemax, out, name='sparsemax')
#out = tf.nn.softmax(out, dim=-1, name='softmax')
return out_pi, out_sigma, out_mu
def _make_network(convs, fcs, use_lstm, padding, inpt, masks, rnn_state,
num_actions, lstm_unit, nenvs, step_size, scope):
with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
out = inpt
with tf.variable_scope('convnet'):
for num_outputs, kernel_size, stride in convs:
out = layers.convolution2d(
out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
padding=padding,
activation_fn=tf.nn.relu,
weights_initializer=tf.orthogonal_initializer(
np.sqrt(2.0)))
out = layers.flatten(out)
with tf.variable_scope('hiddens'):
for hidden in fcs:
out = layers.fully_connected(
out,
hidden,
activation_fn=tf.nn.relu,
weights_initializer=tf.orthogonal_initializer(
np.sqrt(2.0)))
with tf.variable_scope('rnn'):
rnn_in = batch_to_seq(out, nenvs, step_size)
masks = batch_to_seq(masks, nenvs, step_size)
rnn_out, rnn_state = lstm(rnn_in, masks, rnn_state, lstm_unit,
np.sqrt(2.0))
rnn_out = seq_to_batch(rnn_out, nenvs, step_size)
if use_lstm:
out = rnn_out
policy = layers.fully_connected(
out,
num_actions,
activation_fn=tf.nn.softmax,
weights_initializer=tf.orthogonal_initializer(0.1))
value = layers.fully_connected(
out,
1,
activation_fn=None,
weights_initializer=tf.orthogonal_initializer(1.0))
return policy, value, rnn_state
def build_model(inputs, labels, num_classes):
weight_decay = config["weight_decay"]
conv1sz = 16
fc3sz = 512
with tf.contrib.framework.arg_scope(
[layers.convolution2d],
kernel_size=5,
stride=1,
padding='SAME',
activation_fn=tf.nn.relu,
weights_initializer=layers.variance_scaling_initializer(),
weights_regularizer=layers.l2_regularizer(weight_decay)):
net = layers.convolution2d(inputs, conv1sz, scope='conv1')
# ostatak konvolucijskih i pooling slojeva
net = layers.max_pool2d(net, 2, 2, scope='pool1')
net = layers.convolution2d(net, 32, scope='conv2')
net = layers.max_pool2d(net, 2, 2, scope='pool2')
with tf.contrib.framework.arg_scope(
[layers.fully_connected],
activation_fn=tf.nn.relu,
weights_initializer=layers.variance_scaling_initializer(),
weights_regularizer=layers.l2_regularizer(weight_decay)):
# sada definiramo potpuno povezane slojeve
# ali najprije prebacimo 4D tenzor u matricu
net = layers.flatten(net)
net = layers.fully_connected(net, fc3sz, scope='fc3')
logits = layers.fully_connected(net,
num_classes,
activation_fn=None,
scope='logits')
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
return logits, loss
def __call__(self, x, reuse=True):
with tf.variable_scope(self.name) as vs:
if reuse:
vs.reuse_variables()
bs = tf.shape(x)[0]
if self.dataset == "mnist":
x = tf.reshape(x, [bs, 28, 28, 1])
elif self.dataset == "cifar10":
x = tf.reshape(x, [bs, 32, 32, 3])
conv = tcl.convolution2d(x,
32, [4, 4], [2, 2],
activation_fn=tf.identity)
#(bs, 14, 14, 32)
conv = leaky_relu(conv)
for _ in range(self.nb_layers - 1):
conv = tcl.convolution2d(conv,
64, [4, 4], [2, 2],
activation_fn=tf.identity)
conv = tc.layers.batch_norm(conv,
decay=0.9,
scale=True,
updates_collections=None)
conv = leaky_relu(conv)
#(bs, 7, 7, 32)
#fc = tf.reshape(conv, [bs, -1])
fc = tcl.flatten(conv)
#(bs, 1568)
fc = tcl.fully_connected(fc, 1024, activation_fn=tf.identity)
fc = tc.layers.batch_norm(fc,
decay=0.9,
scale=True,
updates_collections=None)
fc = leaky_relu(fc)
output = tcl.fully_connected(fc, 1, activation_fn=tf.identity)
return output
def _build_net(self):
with tf.variable_scope("conv"):
out = layers.convolution2d(self.s,
num_outputs=32,
kernel_size=8,
stride=4,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=4,
stride=2,
activation_fn=tf.nn.relu)
out = layers.convolution2d(out,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("actor"):
a_prob = layers.fully_connected(out,
num_outputs=512,
activation_fn=tf.nn.relu)
a_prob = layers.fully_connected(a_prob,
num_outputs=N_A,
activation_fn=tf.nn.softmax)
with tf.variable_scope("critic"):
v = layers.fully_connected(out,
num_outputs=512,
activation_fn=tf.nn.relu)
v = layers.fully_connected(v,
num_outputs=1,
activation_fn=tf.nn.softmax)
return a_prob, v
def write_network(self, memory):
print 'Write-CNN', '-'*70
print self.write
num_layer = len(self.write['kernel'])
for i in range(num_layer):
with tf.variable_scope('write-CNN-%d' % i):
memory = layers.convolution2d(
inputs=memory, num_outputs=self.write['channel'][i],
kernel_size=[self.write['kernel'][i], self.dim_memory],
stride=[self.write['stride'][i], 1],
weights_initializer=self.initializer_conv,
biases_initializer=self.initializer,
activation_fn=tf.nn.relu)
memory = tf.reshape(memory, [-1, self.dim_memory])
return memory
def create_shallow_net_inference_op(self, images):
"""
Performs a forward pass estimating label maps from RGB images using a (shallow) deep convolution net.
:param images: The RGB images tensor.
:type images: tf.Tensor
:return: The label maps tensor.
:rtype: tf.Tensor
"""
module1_output = self.mercury_module('module1', images, 3, 8, 3)
module2_output = self.mercury_module('module2', module1_output, 8, 16, 16)
module3_output = self.mercury_module('module3', module2_output, 16, 32, 32)
predicted_labels = convolution2d(module3_output, 1, kernel_size=1)
return predicted_labels
def forward(self, feature_map, is_training):
h = L.convolution2d(feature_map,
256, [7, 7], [2, 2],
activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=0.5, is_training=is_training)
h = L.max_pool2d(h, [2, 2], [2, 2])
batch_size, height, width, depth = h.get_shape()
h = tf.reshape(h, tf.stack([-1, height * width * depth]))
logits = L.fully_connected(h,
len(self.classes) + 1,
activation_fn=None)
return logits
def _make_convolutional_layers(convs, inpt, with_fc=True, reuse=None):
with tf.variable_scope('convnet', reuse=reuse):
out = inpt
for num_outputs, kernel_size, stride, padding in convs:
out = layers.convolution2d(out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
padding='SAME',
activation_fn=tf.nn.elu)
conv_out = layers.flatten(out)
if with_fc:
conv_out = layers.fully_connected(conv_out,
256,
activation_fn=tf.nn.elu)
return conv_out
def __building_block_B(self, input, ws):
# Dimension where we want to iteration through with multiple 1D CNN
dimension = input.get_shape()[2].value
# Stores the 1d conv output
convs = []
# Per dimension iteration
with tf.variable_scope("building_block_B"):
for d in xrange(dimension):
conv = convolution2d(tf.expand_dims(input[:,:,d,:],1), self.conf.num_filters_B, kernel_size=[1,ws], stride=[1,1], \
padding='VALID', weights_regularizer=self.regularizer, biases_regularizer=self.regularizer)
# Removing the dimension with 1
conv = tf.squeeze(conv, axis=[0,1])
convs.append(conv)
return convs
def __call__(self, x, reuse=tf.AUTO_REUSE, split=False):
with tf.variable_scope(self.name,
reuse=tf.AUTO_REUSE,
regularizer=tcl.l2_regularizer(1e-3)) as vs:
x = tf.reshape(x, [-1, 200, 200, 2])
conv0 = tcl.convolution2d(x,
64, [3, 3], [1, 1],
activation_fn=tf.nn.relu)
conv0 = tcl.convolution2d(conv0,
64, [4, 4], [2, 2],
activation_fn=tf.nn.relu)
conv0 = tcl.convolution2d(conv0,
128, [4, 4], [2, 2],
activation_fn=tf.nn.relu)
conv0 = tcl.instance_norm(conv0)
conv1 = tcl.convolution2d(conv0,
128, [4, 4], [2, 2],
activation_fn=tf.nn.relu)
conv1 = tcl.convolution2d(conv1,
128, [4, 4], [2, 2],
activation_fn=tf.nn.relu)
conv1 = tcl.convolution2d(conv1,
128, [3, 3], [1, 1],
activation_fn=tf.nn.relu)
conv1 = tcl.instance_norm(conv1)
conv2 = tcl.convolution2d(conv1,
256, [4, 4], [2, 2],
activation_fn=tf.nn.relu)
conv2 = tcl.convolution2d(conv2,
512, [4, 4], [2, 2],
activation_fn=tf.nn.relu)
conv2 = tcl.convolution2d(conv2,
512, [3, 3], [1, 1],
activation_fn=tf.nn.relu)
conv6 = tcl.flatten(conv2)
fc2 = tcl.fully_connected(conv6,
self.class_num,
activation_fn=tf.identity)
return fc2
def forward(self, input_tensor, is_training):
dropout_value = 0.5
input_tensor = tf.expand_dims(input_tensor, -1)
h = tf.layers.conv3d(input_tensor, 16, [5, 5, 3], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = tf.layers.max_pooling3d(h, [2, 2, 2], [2, 2, 2])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.layers.conv3d(h, 32, [5, 5, 2], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = tf.layers.max_pooling3d(h, [2, 2, 1], [2, 2, 1])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.layers.conv3d(h, 64, [5, 5, 2], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = tf.layers.max_pooling3d(h, [2, 2, 2], [2, 2, 2])
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.layers.conv3d(h, 128, [5, 5, 1], padding="same")
h = tf.layers.batch_normalization(h)
h = tf.nn.relu(h)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
print(h)
h = tf.squeeze(h, 3)
print(h)
h = L.convolution2d_transpose(h, 128, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 64, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d_transpose(h, 32, [5, 5], [2, 2], activation_fn=tf.nn.relu)
h = L.dropout(h, keep_prob=dropout_value, is_training=is_training)
h = L.convolution2d(h, len(self.classes) + 1, [1, 1], [1, 1], activation_fn=None)
return h
def _cnn_to_mlp(convs,
hiddens,
dueling,
inpt,
num_actions,
scope,
reuse=False):
with tf.variable_scope(scope, reuse=reuse):
tf.summary.histogram('input', inpt)
out = inpt
with tf.variable_scope("convnet"):
for num_outputs, kernel_size, stride in convs:
out = layers.convolution2d(out,
num_outputs=num_outputs,
kernel_size=kernel_size,
stride=stride,
activation_fn=tf.nn.relu)
out = layers.flatten(out)
with tf.variable_scope("action_value"):
action_out = out
for hidden in hiddens:
action_out = layers.fully_connected(action_out,
num_outputs=hidden,
activation_fn=tf.nn.relu)
action_scores = layers.fully_connected(action_out,
num_outputs=num_actions,
activation_fn=None)
if dueling:
with tf.variable_scope("state_value"):
state_out = out
for hidden in hiddens:
state_out = layers.fully_connected(
state_out,
num_outputs=hidden,
activation_fn=tf.nn.relu)
state_score = layers.fully_connected(state_out,
num_outputs=1,
activation_fn=None)
action_scores_mean = tf.reduce_mean(action_scores, 1)
action_scores_centered = action_scores - tf.expand_dims(
action_scores_mean, 1)
return state_score + action_scores_centered
else:
return action_scores
return out
def res_net(x, y, activation=tf.nn.relu):
"""Builds a residual network.
Note that if the input tensor is 2D, it must be square in order to be
converted to a 4D tensor.
Borrowed structure from:
github.com/pkmital/tensorflow_tutorials/blob/master/10_residual_network.py
Args:
x: Input of the network
y: Output of the network
activation: Activation function to apply after each convolution
Returns:
Predictions and loss tensors.
"""
# Configurations for each bottleneck group.
BottleneckGroup = namedtuple(
'BottleneckGroup', ['num_blocks', 'num_filters', 'bottleneck_size'])
groups = [BottleneckGroup(3, 128, 32),
BottleneckGroup(3, 256, 64),
BottleneckGroup(3, 512, 128),
BottleneckGroup(3, 1024, 256)]
input_shape = x.get_shape().as_list()
# Reshape the input into the right shape if it's 2D tensor
if len(input_shape) == 2:
ndim = int(sqrt(input_shape[1]))
x = tf.reshape(x, [-1, ndim, ndim, 1])
# First convolution expands to 64 channels
with tf.variable_scope('conv_layer1'):
net = convolution2d(x, 64, 7,
normalizer_fn=batch_norm,
activation_fn=activation)
# Max pool
net = tf.nn.max_pool(
net, [1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME')
# First chain of resnets
with tf.variable_scope('conv_layer2'):
net = convolution2d(net, groups[0].num_filters, 1,
padding='VALID')
# Create the bottleneck groups, each of which contains `num_blocks`
# bottleneck groups.
for group_i, group in enumerate(groups):
for block_i in range(group.num_blocks):
name = 'group_%d/block_%d' % (group_i, block_i)
# 1x1 convolution responsible for reducing dimension
with tf.variable_scope(name + '/conv_in'):
conv = convolution2d(net, group.bottleneck_size, 1,
padding='VALID',
activation_fn=activation,
normalizer_fn=batch_norm)
with tf.variable_scope(name + '/conv_bottleneck'):
conv = convolution2d(conv, group.bottleneck_size, 3,
padding='SAME',
activation_fn=activation,
normalizer_fn=batch_norm)
# 1x1 convolution responsible for restoring dimension
with tf.variable_scope(name + '/conv_out'):
input_dim = net.get_shape()[-1].value
conv = convolution2d(conv, input_dim, 1,
padding='VALID',
activation_fn=activation,
normalizer_fn=batch_norm)
# shortcut connections that turn the network into its counterpart
# residual function (identity shortcut)
net = conv + net
try:
# upscale to the next group size
next_group = groups[group_i + 1]
with tf.variable_scope('block_%d/conv_upscale' % group_i):
net = convolution2d(net, next_group.num_filters, 1,
activation_fn=None,
biases_initializer=None,
padding='SAME')
except IndexError:
pass
net_shape = net.get_shape().as_list()
net = tf.nn.avg_pool(net,
ksize=[1, net_shape[1], net_shape[2], 1],
strides=[1, 1, 1, 1], padding='VALID')
net_shape = net.get_shape().as_list()
net = tf.reshape(net, [-1, net_shape[1] * net_shape[2] * net_shape[3]])
target = tf.one_hot(y, depth=10, dtype=tf.float32)
logits = tf.contrib.layers.fully_connected(net, 10, activation_fn=None)
loss = tf.contrib.losses.softmax_cross_entropy(logits, target)
return tf.softmax(logits), loss
import tensorflow as tf
# from tensorflow.contrib import learn
from tensorflow.contrib.layers import convolution2d
from tensorflow.contrib.framework.python.ops import variables
from tensorflow.contrib.layers.python.layers import utils
from tensorflow.contrib.layers.python.layers import initializers
# method 1: contirb API
net = convolution2d(net,
num_outputs=num_ker,
kernel_size=[ker_size,1],
stride=[stride,1]
padding='SAME',
activation_fn=None,
normalizer_fn=None,
weights_initializer=initializers.variance_scaling_initializer(),
biases_initializer=init_ops.zeros_initializer,)
# method 2: original conv2d API
weights = variables.model_variable(
'weights',
shape=[ker_size, 1, num_ker_in, num_ker],
dtype=dtype,
initializer=initializers.variance_scaling_initializer(),
trainable=True)
biases = variables.model_variable(
'biases',
shape=[num_ker],
dtype=dtype,
initializer=tf.zeros_initializer,
trainable=True)
def run_network(inpt, string, is_training, debug=False, strip_batchnorm_from_last_layer=False):
maybe_fc_batch_norm = layers.batch_norm
maybe_conv_batch_norm = conv_batch_norm
if debug:
print ("%s architecture" % (tf.get_variable_scope().name,))
layer_idx = 0
out = inpt
layer_strs = string.split(",")
for i, layer in enumerate(layer_strs):
if i + 1 == len(layer_strs) and strip_batchnorm_from_last_layer:
maybe_fc_batch_norm = None
maybe_conv_batch_norm = None
if layer.startswith("conv:"):
nkernels, stride, num_outputs, nonlinearity_str = parse_conv_params(layer[len("conv:"):].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
normalizer_params={"is_training": is_training},
normalizer_fn=maybe_conv_batch_norm,
activation_fn=nonlinearity,
scope='layer_%d' % (layer_idx,)
)
layer_idx += 1
if debug:
print ("Convolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s" %
(nkernels, stride, num_outputs, nonlinearity_str))
elif layer.startswith("deconv:"):
nkernels, stride, num_outputs, nonlinearity_str = parse_conv_params(layer[len("deconv:"):].split(":"))
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.convolution2d_transpose(
out,
num_outputs=num_outputs,
kernel_size=nkernels,
stride=stride,
activation_fn=nonlinearity,
normalizer_fn=maybe_conv_batch_norm,
normalizer_params={"is_training": is_training},
scope='layer_%d' % (layer_idx,)
)
layer_idx += 1
if debug:
print ("Deconvolution with nkernels=%d, stride=%d, num_outputs=%d followed by %s" %
(nkernels, stride, num_outputs, nonlinearity_str))
elif layer.startswith("fc:"):
params = layer[len("fc:"):].split(":")
nonlinearity_str = 'relu'
if len(params) == 2:
params, nonlinearity_str = params[:-1], params[-1]
num_outputs = parse_math(params[0])
nonlinearity = NONLINEARITY_NAME_TO_F[nonlinearity_str]
out = layers.fully_connected(
out,
num_outputs=num_outputs,
activation_fn=nonlinearity,
normalizer_fn=maybe_fc_batch_norm,
normalizer_params={"is_training": is_training, "updates_collections": None},
scope='layer_%d' % (layer_idx,)
)
layer_idx += 1
if debug:
print ("Fully connected with num_outputs=%d followed by %s" %
(num_outputs, nonlinearity_str))
elif layer.startswith("reshape:"):
params = layer[len("reshape:"):].split(":")
dims = [parse_math(dim) for dim in params]
out = tf.reshape(out, [-1] + dims)
if debug:
print("Reshape to %r" % (dims,))
else:
raise ValueError("Could not parse layer description: %r" % (layer,))
if debug:
print("")
return out
import tensorflow as tf
import tensorflow.contrib.layers as layers
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("data/mnist", one_hot=True)
num_train = mnist.train.num_examples
num_test = mnist.test.num_examples
batch_size = 100
num_train_batches = num_train / batch_size
num_test_batches = num_test / batch_size
num_epochs = 10
x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
x_img = tf.reshape(x, [-1,28,28,1])
conv1 = layers.max_pool2d(
layers.convolution2d(x_img, 32, [5, 5]),
[2, 2], [2, 2])
conv2 = layers.max_pool2d(
layers.convolution2d(conv1, 64, [5, 5]),
[2, 2], [2, 2])
y = layers.fully_connected(layers.flatten(conv2),
10, activation_fn=tf.nn.softmax)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_*tf.log(y), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer().minimize(cross_entropy)
correct = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))
import time
init = tf.initialize_all_variables()
with tf.Session() as sess:
def layer_function(*args, **kwargs):
kwargs['activation_fn'] = f
return convolution2d(*args, **kwargs)
def resnn(self, sequences):
"""Build the resnn model.
Args:
page_batch: Sequences returned from inputs_train() or inputs_eval.
Returns:
Logits.
"""
# [batch_size, html_len, 1, we_dim]
target_expanded = tf.expand_dims(sequences, 2)
# Configurations for each bottleneck block.
BottleneckBlock = namedtuple(
'BottleneckBlock',
['num_layers', 'num_filters', 'bottleneck_size'])
# blocks = [BottleneckBlock(3, 128, 32),
# BottleneckBlock(3, 256, 64),
# BottleneckBlock(3, 512, 128),
# BottleneckBlock(3, 1024, 256)]
# blocks = [BottleneckBlock(3, 128, 32),
# BottleneckBlock(3, 256, 64)]
blocks = [BottleneckBlock(3, 64, 32), BottleneckBlock(6, 128, 64),
BottleneckBlock(3, 256, 128)]
# BottleneckBlock(3, 512, 256)]
# First convolution expands to 64 channels
with tf.variable_scope('conv_layer1'):
net = convolution2d(target_expanded,
64,
[7, 1],
stride=[2, 1],
activation_fn=self.activation,
normalizer_fn=batch_norm,
normalizer_params={'decay': self.norm_decay})
# Max pool
net = tf.nn.max_pool(net,
[1, 3, 1, 1],
strides=[1, 2, 1, 1],
padding='SAME')
# First chain of resnets
with tf.variable_scope('conv_layer2'):
net = convolution2d(net,
blocks[0].num_filters,
[1, 1],
padding='VALID',
activation_fn=self.activation,
normalizer_fn=batch_norm,
normalizer_params={'decay': self.norm_decay})
# Create each bottleneck building block for each layer
for block_i, block in enumerate(blocks):
for layer_i in range(block.num_layers):
name = 'block_%d/layer_%d' % (block_i, layer_i)
# 1x1 convolution responsible for reducing dimension
with tf.variable_scope(name + '/conv_in'):
conv = convolution2d(
net,
block.bottleneck_size,
[1, 1],
padding='VALID',
activation_fn=self.activation,
normalizer_fn=batch_norm,
normalizer_params={'decay': self.norm_decay})
with tf.variable_scope(name + '/conv_bottleneck'):
conv = convolution2d(
conv,
block.bottleneck_size,
[3, 1],
padding='SAME',
activation_fn=self.activation,
normalizer_fn=batch_norm,
normalizer_params={'decay': self.norm_decay})
# 1x1 convolution responsible for restoring dimension
with tf.variable_scope(name + '/conv_out'):
conv = convolution2d(
conv,
block.num_filters,
[1, 1],
padding='VALID',
activation_fn=self.activation,
normalizer_fn=batch_norm,
normalizer_params={'decay': self.norm_decay})
# shortcut connections that turn the network into its counterpart
# residual function (identity shortcut)
net = conv + net
try:
# upscale to the next block size
next_block = blocks[block_i + 1]
with tf.variable_scope('block_%d/conv_upscale' % block_i):
net = convolution2d(
net,
next_block.num_filters,
[1, 1],
activation_fn=self.activation,
normalizer_fn=batch_norm,
normalizer_params={'decay': self.norm_decay})
except IndexError:
pass
net_shape = net.get_shape().as_list()
net = tf.nn.avg_pool(net,
ksize=[1, net_shape[1], net_shape[2], 1],
strides=[1, 1, 1, 1],
padding='VALID')
net_shape = net.get_shape().as_list()
softmax_len = net_shape[1] * net_shape[2] * net_shape[3]
net = tf.reshape(net, [-1, softmax_len])
# softmax, i.e. softmax(WX + b)
with tf.variable_scope('softmax_linear'):
WW = tf.get_variable(
"WW",
shape=[softmax_len, self.num_cats],
initializer=tf.contrib.layers.xavier_initializer())
b = self._variable_on_cpu('b',
[self.num_cats],
tf.constant_initializer(value=0.1))
softmax_linear = tf.nn.xw_plus_b(net, WW, b, name="scores")
return softmax_linear
