def resnet_v1(inputs,
blocks,
num_classes=None,
is_training=True,
global_pool=True,
include_root_block=True,
reuse=None,
scope=None,
normalize_inside=True):
"""Removes output_stride, use pre-defined rate
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.
"""
if normalize_inside:
# if no normalization is used outside, use detectron style normalization
inputs = _detectron_img_preprocess(inputs)
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(
[conv2d, bottleneck, stack_blocks_dense, max_pool2d],
outputs_collections=end_points_collection):
with arg_scope([batch_norm], is_training=is_training):
net = inputs
if include_root_block:
# net = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope='conv1')
net = conv2d(net, 64, 7, 2, scope='conv1')
net = max_pool2d(net, 3, 2, scope='pool1')
net = stack_blocks_dense(net, blocks)
if global_pool:
# Global average pooling.
net = math_ops.reduce_mean(net, [1, 2], name='pool5', keepdims=True)
net = utils.collect_named_outputs(end_points_collection,
sc.name+'/gap', net)
if num_classes is not None:
net = conv2d(
net,
num_classes, 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:
end_points['predictions'] = layers_lib.softmax(
net, scope='predictions')
return net, end_points
def build_graph(self):
logit = self.resnet(self._images)
cross_entropy_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logit, labels=self._labels)
cross_entropy_loss = tf.reduce_mean(cross_entropy_loss, name='cross_entropy_loss')
# cal l2loss
l2_costs = []
for var in tf.trainable_variables():
if var.op.name.find(r'weight') > 0:
l2_costs.append(tf.nn.l2_loss(var))
tf.summary.histogram(var.op.name, var)
# [l2_costs.append(tf.nn.l2_loss(var)) for var in tf.trainable_variables() if var.op.name.find(r'weight') > 0]
self.l2loss = self.model_conf.WEIGHT_DECAY_RATE*tf.add_n(l2_costs)
self.loss = cross_entropy_loss + self.model_conf.WEIGHT_DECAY_RATE*tf.add_n(l2_costs)
self.prediction = layers.softmax(logit)
_labels = tf.arg_max(self.prediction, 1)
self.acc = tf.reduce_mean(tf.to_float(tf.equal(_labels, self._labels)))
if self._is_training:
self.build_train_op()
tf.summary.scalar('loss', self.loss)
tf.summary.scalar('l2loss', self.l2loss)
tf.summary.scalar('accuracy', self.acc)
tf.summary.image('image', self._images, max_outputs=10)
def _network_template(self, state):
"""Builds the convolutional network used to compute the agent's Q-values.
Args:
state: `tf.Tensor`, contains the agent's current state.
Returns:
net: _network_type object containing the tensors output by the network.
"""
weights_initializer = slim.variance_scaling_initializer(
factor=1.0 / np.sqrt(3.0), mode='FAN_IN', uniform=True)
net = tf.cast(state, tf.float32)
net = tf.div(net, 255.)
net = slim.conv2d(
net, 32, [8, 8], stride=4, weights_initializer=weights_initializer)
net = slim.conv2d(
net, 64, [4, 4], stride=2, weights_initializer=weights_initializer)
net = slim.conv2d(
net, 64, [3, 3], stride=1, weights_initializer=weights_initializer)
net = slim.flatten(net)
net = noisy_dqn_agent.fully_connected(
net, 512, scope='fully_connected')
net = noisy_dqn_agent.fully_connected(
net,
self.num_actions * self._num_atoms,
activation_fn=None,
scope='fully_connected_1')
logits = tf.reshape(net, [-1, self.num_actions, self._num_atoms])
probabilities = contrib_layers.softmax(logits)
q_values = tf.reduce_sum(self._support * probabilities, axis=2)
return self._get_network_type()(q_values, logits, probabilities)
def __init__(self, feature_num, class_num, is_training, step=0.001):
self.weight_decay = 1e-3
self.bn_params = {
# Decay for the moving averages.
'decay': 0.999,
'center': True,
'scale': True,
# epsilon to prevent 0s in variance.
'epsilon': 0.001,
# None to force the updates during train_op
'updates_collections': None,
'is_training': is_training
}
self.feature_num = feature_num
self.class_num = class_num
self.X = tf.placeholder(tf.float32, [None, feature_num])
self.y_ = tf.placeholder(tf.float32, [None, class_num])
with tf.contrib.framework.arg_scope(
[layers.convolution2d],
kernel_size=3,
stride=1,
padding='SAME',
activation_fn=tf.nn.relu,
normalizer_fn=layers.batch_norm,
normalizer_params=self.bn_params,
weights_initializer=layers.variance_scaling_initializer(),
weights_regularizer=layers.l2_regularizer(self.weight_decay)):
self.X = tf.reshape(self.X, [-1, 28, 28, 1])
net = layers.convolution2d(self.X, num_outputs=16, scope='conv1')
net = layers.max_pool2d(net, kernel_size=2, scope='pool1')
net = layers.relu(net, num_outputs=16)
net = layers.convolution2d(net, num_outputs=32, scope='conv2')
net = layers.max_pool2d(net, kernel_size=2, scope='pool2')
net = layers.relu(net, num_outputs=32)
net = layers.flatten(net, [-1, 7 * 7 * 32])
net = layers.fully_connected(net,
num_outputs=512,
activation_fn=tf.nn.relu,
scope='fc1')
net = layers.relu(net, num_outputs=512)
net = layers.fully_connected(net,
num_outputs=self.class_num,
scope='fc2')
self.y = layers.softmax(net, scope='softmax')
self.loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(net, self.y_))
self.optimizer = tf.train.AdamOptimizer(step).minimize(self.loss)
pred = tf.equal(tf.argmax(self.y, 1), tf.argmax(self.y_, 1))
self.acc = tf.reduce_mean(tf.cast(pred, tf.float32))
self.sess = tf.Session()
def __init__(self, params):
"""
:param params: dictionary with fields:
"N_HIDDEN": number of hidden states
"N_BINS": number of bins on input/ output
"WINDOW_LENGTH": number of time-steps in training window
"""
tf.reset_default_graph()
self.session = tf.Session()
self.inputs = tf.placeholder(tf.float32,
(None, None, params['N_BINS']))
self.cell = tf.contrib.rnn.LSTMCell(params['N_HIDDEN'],
state_is_tuple=True)
self.batch_size = tf.shape(self.inputs)[1]
self.h_init = tf.Variable(tf.zeros([1, params['N_HIDDEN']]),
trainable=True)
self.h_init_til = tf.tile(self.h_init, [self.batch_size, 1])
self.c_init = tf.Variable(tf.zeros([1, params['N_HIDDEN']]),
trainable=True)
self.c_init_til = tf.tile(self.c_init, [self.batch_size, 1])
self.initial_state = LSTMStateTuple(self.c_init_til, self.h_init_til)
self.rnn_outputs, self.rnn_states = \
tf.nn.dynamic_rnn(self.cell,
self.inputs,
initial_state=self.initial_state,
time_major=True)
self.intermediate_projection = layers.fully_connected(
self.rnn_outputs[params["WINDOW_LENGTH"] - 2, :, :],
num_outputs=params['N_HIDDEN'])
self.final_features = layers.linear(self.intermediate_projection,
num_outputs=params["N_BINS"])
self.predicted_outputs = layers.softmax(self.final_features)
with tf.variable_scope("train"):
# get element-wise error
self.outputs = \
tf.placeholder(tf.float32, (None, params['N_BINS']))
self.all_errors = losses.categorical_crossentropy(
self.outputs, self.predicted_outputs)
# measure error
self.error = tf.reduce_mean(self.all_errors)
self.train_fn = \
tf.train.AdamOptimizer(learning_rate=params['LEARNING_RATE']) \
.minimize(self.error)
def softmax_prediction(X, opt, is_reuse=None):
#X shape: batchsize L emb 1
biasInit = bias_init
pred_H = layers.conv2d(X,
num_outputs=opt.n_words,
kernel_size=[1, opt.embed_size],
biases_initializer=biasInit,
activation_fn=tf.nn.relu,
padding='VALID',
scope='pred',
reuse=is_reuse) # batch L 1 V
pred_prob = layers.softmax(pred_H, scope='pred') # batch L 1 V
pred_prob = tf.squeeze(pred_prob) # batch L V
return pred_prob
def model(inpt, num_actions, scope, reuse=False):
"""This model takes as input an observation and returns values of all actions."""
import tensorflow as tf # need to keep imports here for serialization to work
import tensorflow.contrib.layers as layers
with tf.variable_scope(scope, reuse=reuse):
out = inpt
out = layers.fully_connected(out,
num_outputs=64,
activation_fn=tf.nn.tanh)
out = layers.fully_connected(out,
num_outputs=num_actions,
activation_fn=tf.nn.tanh)
out = layers.softmax(out)
return out
def build_forward(self, x_in):
with tf.variable_scope(self.name):
# input layer
layer = x_in
# hidden layers
for _ in range(self.depth):
layer = layers.relu(layer, self.width)
# logits and output
self.logits = layers.linear(layer, self.n_classes)
self.output = tf.reshape(layers.softmax(self.logits)[:, 1], shape=(-1, 1))
self.tf_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=self.name)
def visualize_landmark_predictions(landmark_predictions,
image_size,
use_softmax=True):
grid_size = landmark_predictions.shape[1]
assert grid_size == landmark_predictions.shape[2]
# Row = [[0, 1, 2, 3...], [0, 1, 2, 3...]...]. Column = [[0, 0, ..], [1, 1,...]...]
row, column = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))
dtype = landmark_predictions.dtype
row = tf.cast(row, dtype) / tf.cast(grid_size, dtype)
column = tf.cast(column, dtype) / tf.cast(grid_size, dtype)
rc = tf.stack((row, column), axis=-1)
rc_reshaped = tf.expand_dims(tf.expand_dims(rc, 0), 3)
rc_reshaped = tf_repeat(rc_reshaped, [
landmark_predictions.shape[0], 1, 1, landmark_predictions.shape[3], 1
])
if True:
landmark_confidence_reshaped = tf.transpose(
landmark_predictions[..., 2], (0, 3, 1, 2))
landmark_confidence_reshaped = tf.reshape(
landmark_confidence_reshaped,
tf.TensorShape([
landmark_confidence_reshaped.shape[0],
landmark_confidence_reshaped.shape[1],
landmark_confidence_reshaped.shape[2] *
landmark_confidence_reshaped.shape[3],
]))
c = layers.softmax(landmark_confidence_reshaped)
else:
c = tf.sigmoid(landmark_predictions[..., 2])
c = tf.transpose(c, (0, 2, 1))
# c = tf.reshape(c, tf.TensorShape(
# [c.shape[0], grid_size, grid_size, c.shape[2]])) # [batch size, height, width, num_landmarks]
xy = rc_reshaped + landmark_predictions[..., 0:2] / int(
grid_size) # [batch size, height, width, num_landmarks, 2]
xy_reshaped = tf.reshape(
xy,
tf.TensorShape([
xy.shape[0], xy.shape[1] * xy.shape[2] * xy.shape[3] * xy.shape[4]
]))
xy_one_hot = xy_to_one_hot(xy_reshaped, image_size)
xy_one_hot_weighed = xy_one_hot * tf.expand_dims(
tf.expand_dims(layers.flatten(c), 1), 2)
xy_one_hot_weighed = tf.reduce_sum(xy_one_hot_weighed,
axis=-1,
keepdims=True)
return xy_one_hot_weighed
def rainbow_network(num_actions, num_atoms, support, network_type, state):
"""The convolutional network used to compute agent's Q-value distributions.
Args:
num_actions: int, number of actions.
num_atoms: int, the number of buckets of the value function distribution.
support: tf.linspace, the support of the Q-value distribution.
network_type: namedtuple, collection of expected values to return.
state: `tf.Tensor`, contains the agent's current state.
Returns:
net: _network_type object containing the tensors output by the network.
"""
weights_initializer = contrib_slim.variance_scaling_initializer(
factor=1.0 / np.sqrt(3.0), mode='FAN_IN', uniform=True)
net = tf.cast(state, tf.float32)
net = tf.div(net, 255.)
net = contrib_slim.conv2d(net,
32, [8, 8],
stride=4,
weights_initializer=weights_initializer)
net = contrib_slim.conv2d(net,
64, [4, 4],
stride=2,
weights_initializer=weights_initializer)
net = contrib_slim.conv2d(net,
64, [3, 3],
stride=1,
weights_initializer=weights_initializer)
net = contrib_slim.flatten(net)
net = contrib_slim.fully_connected(net,
512,
weights_initializer=weights_initializer)
net = contrib_slim.fully_connected(net,
num_actions * num_atoms,
activation_fn=None,
weights_initializer=weights_initializer)
logits = tf.reshape(net, [-1, num_actions, num_atoms])
probabilities = contrib_layers.softmax(logits)
q_values = tf.reduce_sum(support * probabilities, axis=2)
return network_type(q_values, logits, probabilities)
def make_forward_pass(self, input_layer):
# build the graph in the scope
with tf.variable_scope(self.name):
# input layer
layer = input_layer
# hidden layers
for _ in range(int(self.hps['depth'])):
layer = layers.relu(layer, int(self.hps['n_units']))
# output layer
self.logits = layers.linear(layer, self.hps['n_classes'])
# and an extra layer for getting the predictions directly
self.proba = tf.reshape(layers.softmax(self.logits)[:, 1],
shape=(-1, 1))
self.tf_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=self.name)
def __init__(self, lr, s_size, a_size, h_size):
#These lines established the feed-forward part of the network. The agent takes a state and produces an action.
self.inputs = tf.placeholder(shape=[None, s_size], dtype=tf.float32)
self.dropout_ratio = tf.placeholder(shape=(), dtype=tf.float32)
hidden = layers.fully_connected(self.inputs, h_size)
hidden = layers.dropout(hidden, self.dropout_ratio)
hidden2 = layers.fully_connected(hidden, int(h_size / 2))
hidden2 = layers.dropout(hidden2, self.dropout_ratio)
output1, output2 = tf.split(hidden2, 2, 1)
self.advantage_weights = tf.Variable(
tf.random_normal([int(h_size / 4), a_size]))
self.value_weights = tf.Variable(tf.random_normal([int(h_size / 4),
1]))
self.advantage = tf.matmul(output1, self.advantage_weights)
self.value = tf.matmul(output2, self.value_weights)
#Then combine them together to get our final Q-values.
self.q_values = self.value + tf.subtract(
self.advantage,
tf.reduce_mean(self.advantage, reduction_indices=1,
keep_dims=True))
self.q_dist = layers.softmax(self.q_values)
self.predict = tf.argmax(self.q_values, 1)
#Below we obtain the loss by taking the sum of squares difference between the target and prediction Q values.
self.targetQ = tf.placeholder(shape=[None], dtype=tf.float32)
self.actions = tf.placeholder(shape=[None], dtype=tf.int32)
self.actions_onehot = tf.one_hot(self.actions,
a_size,
dtype=tf.float32)
self.Q = tf.reduce_sum(tf.multiply(self.q_values, self.actions_onehot),
axis=1)
self.error = tf.reduce_mean(tf.square(self.targetQ - self.Q))
self.trainer = tf.train.AdamOptimizer(learning_rate=0.0001)
self.updateModel = self.trainer.minimize(self.error)
def acrobot_rainbow_network(num_actions, num_atoms, support, network_type,
state):
"""Build the deep network used to compute the agent's Q-value distributions.
Args:
num_actions: int, number of actions.
num_atoms: int, the number of buckets of the value function distribution.
support: tf.linspace, the support of the Q-value distribution.
network_type: `namedtuple`, collection of expected values to return.
state: `tf.Tensor`, contains the agent's current state.
Returns:
net: _network_type object containing the tensors output by the network.
"""
net = _basic_discrete_domain_network(ACROBOT_MIN_VALS,
ACROBOT_MAX_VALS,
num_actions,
state,
num_atoms=num_atoms)
logits = tf.reshape(net, [-1, num_actions, num_atoms])
probabilities = contrib_layers.softmax(logits)
q_values = tf.reduce_sum(support * probabilities, axis=2)
return network_type(q_values, logits, probabilities)
def call(self, state):
x = self.net(state)
logits = tf.reshape(x, [-1, self.num_actions, self.num_atoms])
probabilities = contrib_layers.softmax(logits)
q_values = tf.reduce_sum(self.support * probabilities, axis=2)
return atari_lib.RainbowNetworkType(q_values, logits, probabilities)
def __init__(self,
num_actions,
state_shape=[8, 8, 5],
convs=[[32, 4, 2], [64, 2, 1]],
fully_connected=[128],
activation_fn=tf.nn.relu,
optimizers=[
tf.train.AdamOptimizer(2.5e-4),
tf.train.AdamOptimizer(2.5e-4),
tf.train.AdamOptimizer(2.5e-4)
],
scope="sac",
reuse=False):
with tf.variable_scope(scope, reuse=reuse):
###################### Neural network architecture ######################
input_shape = [None] + state_shape
self.input_states = tf.placeholder(dtype=tf.float32,
shape=input_shape)
with tf.variable_scope("value", reuse=reuse):
self.v_values = full_module(self.input_states, convs,
fully_connected, 1, activation_fn)
with tf.variable_scope("qfunc", reuse=reuse):
self.q_values = full_module(self.input_states, convs,
fully_connected, num_actions,
activation_fn)
with tf.variable_scope("policy", reuse=reuse):
self.p_logits = full_module(self.input_states, convs,
fully_connected, num_actions,
activation_fn)
self.p_values = layers.softmax(self.p_logits)
######################### Optimization procedure ########################
# one-hot encode actions to get q-values for state-action pairs
self.input_actions = tf.placeholder(dtype=tf.int32, shape=[None])
actions_onehot = tf.one_hot(self.input_actions,
num_actions,
dtype=tf.float32)
q_values_selected = tf.reduce_sum(tf.multiply(
self.q_values, actions_onehot),
axis=1)
p_logits_selected = tf.reduce_sum(tf.multiply(
self.p_logits, actions_onehot),
axis=1)
# choose best actions (according to q-values)
self.q_argmax = tf.argmax(self.q_values, axis=1)
# create loss function and update rule
self.q_targets = tf.placeholder(dtype=tf.float32, shape=[None])
self.v_targets = tf.placeholder(dtype=tf.float32, shape=[None])
self.p_targets = tf.placeholder(dtype=tf.float32, shape=[None])
q_loss = tf.losses.huber_loss(self.q_targets, q_values_selected)
self.q_loss = tf.reduce_sum(q_loss)
q_optimizer = optimizers[0]
v_targets_reshaped = tf.reshape(self.v_targets, (-1, 1))
v_loss = tf.losses.huber_loss(v_targets_reshaped, self.v_values)
self.v_loss = tf.reduce_sum(v_loss)
v_optimizer = optimizers[1]
p_loss = tf.losses.huber_loss(self.p_targets, p_logits_selected)
self.p_loss = tf.reduce_sum(p_loss)
p_optimizer = optimizers[2]
self.update_q_values = q_optimizer.minimize(self.q_loss)
self.update_v_values = v_optimizer.minimize(self.v_loss)
self.update_p_logits = p_optimizer.minimize(self.p_loss)
def setup(self):
l1 = layers.conv2d(inputs=1 - self.data,
num_outputs=32,
kernel_size=[3, 3],
stride=[2, 2])
l1_bis = layers.conv2d(inputs=l1,
num_outputs=64,
kernel_size=[3, 3],
stride=[2, 2])
l2 = layers.conv2d(inputs=l1_bis,
num_outputs=64,
kernel_size=[3, 3],
stride=[2, 2])
l3 = layers.conv2d(
inputs=l2, num_outputs=128, kernel_size=[3, 3],
stride=[1, 1]) # layer 3 saves our ass 3 pq pas 8 ou 16 ou plus ?
self.rpn_cls_score = layers.conv2d(inputs=l3,
num_outputs=len(ratios) *
len(anchor_scales) * 2,
kernel_size=[1, 1],
stride=[1, 1],
padding='VALID',
activation_fn=None)
self.rpn_bbox_pred = layers.conv2d(inputs=l3,
num_outputs=len(ratios) *
len(anchor_scales) * 4,
kernel_size=[1, 1],
stride=[1, 1],
padding='VALID',
activation_fn=None)
self.rpn_cls_prob = tf.nn.softmax(self.rpn_cls_score)
if self.state == "TRAIN":
self.rpn_labels, self.rpn_bbox_targets, self.rpn_bbox_inside_weights, self.rpn_bbox_outside_weights, debug_info = tf.py_func(
anchor_target_layer, [
self.rpn_cls_score, self.gt_boxes, self.im_info, self.data,
_feat_stride, anchor_scales, ratios
], [tf.int32, tf.float32, tf.float32, tf.float32, tf.float32])
self.debug_info = debug_info
self.rpn_rois = tf.reshape(tf.py_func(proposal_layer, [
self.rpn_cls_prob, self.rpn_bbox_pred, self.im_info, self.state,
_feat_stride, anchor_scales, ratios
], [tf.float32]), [-1, 5],
name='rpn_rois')
if self.state == "TRAIN":
rois, self.labels, self.bbox_targets, self.bbox_inside_weights, self.bbox_outside_weights = tf.py_func(
proposal_target_layer,
[self.rpn_rois, self.gt_boxes, n_classes],
[tf.float32, tf.int32, tf.float32, tf.float32, tf.float32])
rois = tf.reshape(rois, [-1, 5], name='rois')
l2_swapped = tf.transpose(l2, perm=[0, 3, 1, 2])
output_shape_tf = tf.constant((7, 7))
if self.state == "TRAIN":
#rois_pooled = roi_pool_op.roi_pool(l2, rois,7,7,1/16.0,name='pool_5')[0]
new_rois, = tf.py_func(adapt_rois, [rois], [tf.int32])
else:
#rois_pooled = roi_pool_op.roi_pool(l2, self.rpn_rois,7,7,1/16.0,name='pool_5')[0]
# 1. Adapt rois
new_rois, = tf.py_func(adapt_rois, [self.rpn_rois], [tf.int32])
rois_pooled_before, argmax = roi_pooling_op_2(l2_swapped, new_rois,
output_shape_tf)
rois_pooled_transposed = tf.transpose(rois_pooled_before,
perm=[0, 2, 1, 3, 4])
rois_pooled = tf.reshape(
rois_pooled_transposed,
[-1, 64, 7, 7]) # Be careful ! The final depth is 64
# output : [batch_size, 7, 7, features_depth]
l5 = layers.flatten(rois_pooled)
fc6 = layers.fully_connected(l5, 128)
fc6 = layers.dropout(fc6, is_training=self.state == "TRAIN")
fc7 = layers.fully_connected(fc6, 128)
fc7 = layers.dropout(fc7, is_training=self.state == "TRAIN")
self.logits = layers.fully_connected(fc7,
n_classes,
activation_fn=None)
self.cls_prob = layers.softmax(self.logits)
self.bbox_pred = layers.fully_connected(fc7,
4 * n_classes,
activation_fn=None,
scope='bbox_pred')
def atari_network(num_actions,
num_atoms,
support,
network_type,
state,
representation_layer=10):
"""The convolutional network used to compute agent's Q-value distributions.
Args:
num_actions: int, number of actions.
num_atoms: int, the number of buckets of the value function distribution.
support: tf.linspace, the support of the Q-value distribution.
network_type: namedtuple, collection of expected values to return.
state: `tf.Tensor`, contains the agent's current state.
representation_layer: int, the layer which will be used as the
representation for computing the bisimulation distances. Defaults to
a high value, which defaults to the penultimate layer.
Returns:
net: _network_type object containing the tensors output by the network.
"""
weights_initializer = contrib_slim.variance_scaling_initializer(
factor=1.0 / np.sqrt(3.0), mode='FAN_IN', uniform=True)
curr_layer = 1
net = tf.cast(state, tf.float32)
net = tf.div(net, 255.)
representation = None
if representation_layer <= curr_layer:
representation = contrib_slim.flatten(net)
net = contrib_slim.conv2d(net,
32, [8, 8],
stride=4,
weights_initializer=weights_initializer,
trainable=False)
curr_layer += 1
if representation is None and representation_layer <= curr_layer:
representation = contrib_slim.flatten(net)
net = contrib_slim.conv2d(net,
64, [4, 4],
stride=2,
weights_initializer=weights_initializer,
trainable=False)
curr_layer += 1
if representation is None and representation_layer <= curr_layer:
representation = contrib_slim.flatten(net)
net = contrib_slim.conv2d(net,
64, [3, 3],
stride=1,
weights_initializer=weights_initializer,
trainable=False)
net = contrib_slim.flatten(net)
curr_layer += 1
if representation is None and representation_layer <= curr_layer:
representation = net
net = contrib_slim.fully_connected(net,
512,
weights_initializer=weights_initializer,
trainable=False)
curr_layer += 1
if representation is None:
representation = net
net = contrib_slim.fully_connected(net,
num_actions * num_atoms,
activation_fn=None,
weights_initializer=weights_initializer,
trainable=False)
logits = tf.reshape(net, [-1, num_actions, num_atoms])
probabilities = contrib_layers.softmax(logits)
q_values = tf.reduce_sum(support * probabilities, axis=2)
return network_type(q_values, logits, probabilities, representation)
def __init__(self, num_bins=8):
tf.reset_default_graph()
self.num_bins = num_bins
self.x = tf.placeholder(tf.float32, shape=(None, 80,80,1), name="input")
self.y = tf.placeholder(tf.int32, shape=(None,), name="label")
self.training = tf.placeholder(tf.bool, name="training")
# used for calculating average of predicted distribution
self.classes = tf.constant(list(range(0,self.num_bins)), dtype=tf.float32, name="classes")
with tf.name_scope("lay1"):
filt_num = 10
filt_size = (8,8)
filt_stride = (2, 2) # (Height, Width)
padding = "same"
activation = tf.nn.relu
# xavier initializer by default :-)
self.lay1 = layers.conv2d(self.x, filt_num, filt_size, filt_stride, padding, activation_fn=activation, scope="lay1")
with tf.name_scope("lay2"):
filt_num = 20
filt_size = (4,4)
filt_stride = (2, 2)
padding = "same"
activation = tf.nn.relu
self.lay2 = layers.conv2d(self.lay1, filt_num, filt_size, filt_stride, padding, activation_fn=activation, scope="lay2")
with tf.name_scope("lay3"):
filt_num = 40
filt_size = (2,2)
filt_stride = (1, 1)
padding = "same"
activation = tf.nn.relu
self.lay3 = layers.conv2d(self.lay2, filt_num, filt_size, filt_stride, padding, activation_fn=activation, scope="lay3")
self.lay3_flat = layers.flatten(self.lay3)
with tf.name_scope("fc1"):
neurons = 1600
activation = tf.nn.relu
dropout_rate = 0.6
self.fc1 = layers.fully_connected(self.lay3_flat, neurons, activation_fn=activation, scope="fc1")
self.fc1_drop = tf.layers.dropout(self.fc1, rate=dropout_rate, training=self.training, name="drop1")
with tf.name_scope("fc2"):
neurons = 160
activation = tf.nn.relu
dropout_rate = 0.6
self.fc2 = layers.fully_connected(self.fc1_drop, neurons, activation_fn=activation, scope="fc2")
self.fc2_drop = tf.layers.dropout(self.fc2, rate=dropout_rate, training=self.training, name="drop2")
with tf.name_scope("output"):
neurons = self.num_bins
activation = None
self.logits = layers.fully_connected(self.fc2_drop, neurons, activation_fn=activation, scope="lay_logits")
self.probs = layers.softmax(self.logits, scope="probs")
with tf.name_scope("loss"):
self.per_class_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.y, logits=self.logits, name="class_loss")
self.loss = tf.reduce_mean(self.per_class_loss)
with tf.name_scope("accuracy"):
'''
eg: This is not code, it's more like a derivation
just for my own reference.
classes = [0,1,2] # index of steering angle bins
probs = [[0.1, 0.7, 0.2], [0.8, 0.2, 0.0]]
true = [1, 0]
Expected value of the pdf output by the softmax opperation
prediction = [[0.0, 0.7, 0.4], [0.0, 0.2, 0.0]] # classes * probs
prediction = [1.1, 0.2] # tf.reduce_sum axis=1
abs_dif = [0.1, 0.2] # abs(true - prediction)
percent_er = [0.1/3, 0.2/3] # where 3 is the number of classes
acc = 1 - pervent_er
mean_acc = tf.reduce_mean(acc)
'''
self.prediction = tf.reduce_sum(tf.multiply(self.probs, self.classes), axis=1)
abs_diff = tf.abs(self.prediction - tf.cast(self.y, tf.float32))
percent_error = abs_diff / tf.cast(tf.shape(self.classes), tf.float32)
self.accuracy = 1. - percent_error
self.mean_accuracy = tf.reduce_mean(self.accuracy)
self.saver = tf.train.Saver()
def __init__(self,
sequence_length,
num_classes,
model_type,
vocab_size,
fc_hidden_size,
embedding_size,
embedding_type,
filter_sizes,
num_filters,
l2_reg_lambda=0.0,
pretrained_embedding=None):
# Placeholders for input, output, dropout_prob and training_tag
self.input_x_front = tf.placeholder(tf.int32, [None, sequence_length],
name="input_x_front")
self.input_x_behind = tf.placeholder(tf.int32, [None, sequence_length],
name="input_x_behind")
self.input_y = tf.placeholder(tf.float32, [None, num_classes],
name="input_y")
self.dropout_keep_prob = tf.placeholder(tf.float32,
name="dropout_keep_prob")
self.is_training = tf.placeholder(tf.bool, name="is_training")
self.global_step = tf.Variable(0, trainable=False, name="Global_Step")
def cos_sim(input_x1, input_x2):
norm1 = tf.square(tf.reduce_sum(tf.square(input_x1), axis=1))
norm2 = tf.square(tf.reduce_sum(tf.square(input_x2), axis=1))
dot_products = tf.reduce_sum(input_x1 * input_x2,
axis=1,
name="cos_sim")
return dot_products / (norm1 * norm2)
def make_attention_mat(input_x1, input_x2):
# shape of `input_x1` and `input_x2`: [batch_size, embedding_size, sequence_length, 1]
# input_x2 need to transpose to the [batch_size, embedding_size, 1, sequence_length]
# shape of output: [batch_size, sequence_length, sequence_length]
euclidean = tf.sqrt(
tf.reduce_sum(tf.square(input_x1 -
tf.matrix_transpose(input_x2)),
axis=1))
return 1 / (1 + euclidean)
def w_pool(input_x, attention, filter_size, scope):
# input_x: [batch_size, num_filters, sequence_length + filter_size - 1, 1]
# attention: [batch_size, sequence_length + filter_size - 1]
if model_type in ['ABCNN2', 'ABCNN3']:
pools = []
# [batch_size, 1, sequence_length + filter_size - 1, 1]
attention = tf.transpose(
tf.expand_dims(tf.expand_dims(attention, -1), -1),
[0, 2, 1, 3])
for i in range(sequence_length):
# [batch_size, num_filters, filter_size, 1]
# reduce_sum => [batch_size, num_filters, 1, 1]
pools.append(
tf.reduce_sum(input_x[:, :, i:i + filter_size, :] *
attention[:, :, i:i + filter_size, :],
axis=2,
keepdims=True))
# [batch_size, num_filters, sequence_length, 1]
w_ap = tf.concat(pools, axis=2, name="w_ap_" + scope)
else:
# [batch_size, num_filters, sequence_length, 1]
w_ap = tf.nn.avg_pool(input_x,
ksize=[1, 1, filter_size, 1],
strides=[1, 1, 1, 1],
padding="VALID",
name="w_ap_" + scope)
return w_ap
def all_pool(input_x, filter_size, scope):
# input_x: [batch_size, num_filters, sequence_length + filter_size -1, 1]
all_ap = tf.nn.avg_pool(
input_x,
ksize=[1, 1, sequence_length + filter_size - 1, 1],
strides=[1, 1, 1, 1],
padding="VALID",
name="all_pool_" + scope)
all_ap_reshaped = tf.reshape(all_ap, [-1, num_filters])
return all_ap_reshaped
def cnn_layer(variable_scope, input_x1, input_x2, dims):
"""
Args:
variable_scope: `cnn-1` or `cnn-2`
input_x1:
dims: embedding_size in `cnn-1`, num_filters in `cnn-2`
"""
with tf.name_scope(variable_scope):
if model_type in ['ABCNN1', 'ABCNN3']:
# Attention
with tf.name_scope("attention_matrix"):
W_a = tf.Variable(tf.truncated_normal(
shape=[sequence_length, embedding_size],
stddev=0.1,
dtype=tf.float32),
name="W_a")
# shape of `attention_matrix`: [batch_size, sequence_length, sequence_length]
attention_matrix = make_attention_mat(
self.embedded_sentence_expanded_front_trans,
self.embedded_sentence_expanded_behind_trans)
# [batch_size, sequence_length, sequence_length] * [sequence_length, embedding_size]
# einsum => [batch_size, sequence_length, embedding_size]
# matrix transpose => [batch_size, embedding_size, sequence_length]
# expand dims => [batch_size, embedding_size, sequence_length, 1]
front_attention = tf.expand_dims(
tf.matrix_transpose(
tf.einsum("ijk,kl->ijl", attention_matrix,
W_a)), -1)
behind_attention = tf.expand_dims(
tf.matrix_transpose(
tf.einsum(
"ijk,kl->ijl",
tf.matrix_transpose(attention_matrix),
W_a)), -1)
# shape of new `embedded_sentence_expanded_front`: [batch_size, sequence_length, embedding_size, 2]
self.embedded_sentence_expanded_front = tf.transpose(
tf.concat([
self.embedded_sentence_expanded_front_trans,
front_attention
],
axis=3),
perm=[0, 2, 1, 3])
self.embedded_sentence_expanded_behind = tf.transpose(
tf.concat([
self.embedded_sentence_expanded_behind_trans,
behind_attention
],
axis=3),
perm=[0, 2, 1, 3])
for filter_size in filter_sizes:
with tf.name_scope("conv-filter{0}".format(filter_size)):
# Convolution Layer
if model_type in ['ABCNN1', 'ABCNN3']:
# The in_channels of filter_shape is 2 (two channels, origin + attention)
in_channels = 2
else:
in_channels = 1
# shape of new `embedded_sentence_expanded_front`
# [batch_size, sequence_length + filter_size - 1, embedding_size, 2]
self.embedded_sentence_expanded_front = tf.pad(
self.embedded_sentence_expanded_front,
np.array([[0,
0], [filter_size - 1, filter_size - 1],
[0, 0], [0, 0]]), "CONSTANT")
self.embedded_sentence_expanded_behind = tf.pad(
self.embedded_sentence_expanded_behind,
np.array([[0,
0], [filter_size - 1, filter_size - 1],
[0, 0], [0, 0]]), "CONSTANT")
filter_shape = [
filter_size, embedding_size, in_channels,
num_filters
]
W = tf.Variable(tf.truncated_normal(shape=filter_shape,
stddev=0.1,
dtype=tf.float32),
name="W")
b = tf.Variable(tf.constant(0.1,
shape=[num_filters],
dtype=tf.float32),
name="b")
conv_front = tf.nn.conv2d(
self.embedded_sentence_expanded_front,
W,
strides=[1, 1, 1, 1],
padding="VALID",
name="conv_front")
conv_behind = tf.nn.conv2d(
self.embedded_sentence_expanded_behind,
W,
strides=[1, 1, 1, 1],
padding="VALID",
name="conv_behind")
# Batch Normalization Layer
conv_bn_front = tf.layers.batch_normalization(
tf.nn.bias_add(conv_front, b),
training=self.is_training)
conv_bn_behind = tf.layers.batch_normalization(
tf.nn.bias_add(conv_behind, b),
training=self.is_training)
# Apply nonlinearity
# [batch_size, sequence_length + filter_size - 1, 1, num_filters]
conv_out_front = tf.nn.relu(conv_bn_front,
name="relu_front")
conv_out_behind = tf.nn.relu(conv_bn_behind,
name="relu_behind")
# [batch_size, num_filters, sequence_length + filter_size - 1, 1]
conv_out_front_trans = tf.transpose(conv_out_front,
perm=[0, 3, 1, 2])
conv_out_behind_trans = tf.transpose(conv_out_behind,
perm=[0, 3, 1, 2])
front_attention_v2, behind_attention_v2 = None, None
if model_type in ['ABCNN2', 'ABCNN3']:
# [batch_size, sequence_length + filter_size - 1, sequence_length + filter_size - 1]
attention_matrix_v2 = make_attention_mat(
conv_out_front_trans, conv_out_behind_trans)
# [batch_size, sequence_length + filter_size - 1]
front_attention_v2 = tf.reduce_sum(attention_matrix_v2,
axis=2)
behind_attention_v2 = tf.reduce_sum(
attention_matrix_v2, axis=1)
with tf.name_scope("pool-filter{0}".format(filter_size)):
# shape of `front_wp`: [batch_size, num_filters, sequence_length, 1]
front_wp = w_pool(input_x=conv_out_front_trans,
attention=front_attention_v2,
filter_size=filter_size,
scope="front")
behind_wp = w_pool(input_x=conv_out_behind_trans,
attention=behind_attention_v2,
filter_size=filter_size,
scope="behind")
# shape of `front_ap`: [batch_size, num_filters]
front_ap = all_pool(input_x=conv_out_front_trans,
filter_size=filter_size,
scope="front")
behind_ap = all_pool(input_x=conv_out_behind_trans,
filter_size=filter_size,
scope="behind")
FI_1, BI_1 = front_wp, behind_wp
F0_1, B0_1 = front_ap, behind_ap
# Embedding Layer
with tf.device('/cpu:0'), tf.name_scope("embedding"):
# Use random generated the word vector by default
# Can also be obtained through our own word vectors trained by our corpus
if pretrained_embedding is None:
self.embedding = tf.Variable(tf.random_uniform(
[vocab_size, embedding_size], -1.0, 1.0, dtype=tf.float32),
trainable=True,
name="embedding")
else:
if embedding_type == 0:
self.embedding = tf.constant(pretrained_embedding,
dtype=tf.float32,
name="embedding")
if embedding_type == 1:
self.embedding = tf.Variable(pretrained_embedding,
trainable=True,
dtype=tf.float32,
name="embedding")
self.embedded_sentence_front = tf.nn.embedding_lookup(
self.embedding, self.input_x_front)
self.embedded_sentence_behind = tf.nn.embedding_lookup(
self.embedding, self.input_x_behind)
self.embedded_sentence_expanded_front = tf.expand_dims(
self.embedded_sentence_front, -1)
self.embedded_sentence_expanded_behind = tf.expand_dims(
self.embedded_sentence_behind, -1)
self.embedded_sentence_front_trans = tf.transpose(
self.embedded_sentence_front, perm=[0, 2, 1])
self.embedded_sentence_behind_trans = tf.transpose(
self.embedded_sentence_behind, perm=[0, 2, 1])
# [batch_size, embedding_size, sequence_length, 1]
self.embedded_sentence_expanded_front_trans = tf.expand_dims(
self.embedded_sentence_front_trans, -1)
self.embedded_sentence_expanded_behind_trans = tf.expand_dims(
self.embedded_sentence_behind_trans, -1)
# Average-pooling Layer
with tf.name_scope("input-all-avg_pool"):
self.embedded_sentence_front_avg_pool = tf.nn.avg_pool(
self.embedded_sentence_expanded_front,
ksize=[sequence_length, 1, 1, 1],
strides=[1, 1, 1, 1],
padding="VALID",
name="all_avg_pool_front")
self.embedded_sentence_behind_avg_pool = tf.nn.avg_pool(
self.embedded_sentence_expanded_behind,
ksize=[sequence_length, 1, 1, 1],
strides=[1, 1, 1, 1],
padding="VALID",
name="all_avg_pool_behind")
# shape of `L0_0` and `R0_0`: [batch_size, embedding_size]
self.F0_0 = tf.reshape(self.embedded_sentence_front_avg_pool,
[-1, embedding_size])
self.B0_0 = tf.reshape(self.embedded_sentence_behind_avg_pool,
[-1, embedding_size])
pooled_outputs_front = []
pooled_outputs_behind = []
sims = []
FI_1, F0_1, BI_1, B0_1 = cnn_layer(variable_scope="CNN-1",
x1=x1_expanded,
x2=x2_expanded,
d=d0)
pooled_outputs_front.append(F0_1)
pooled_outputs_behind.append(B0_1)
# Convolution Layer
# Combine all the pooled features
num_filters_total = num_filters * len(filter_sizes)
self.pool_front = tf.concat(pooled_outputs_front, 1)
self.pool_behind = tf.concat(pooled_outputs_behind, 1)
# self.pool_flat_combine = tf.concat([self.pool_flat_front, self.pool_flat_behind], 1)
sims.append([
cos_sim(self.F0_0, self.B0_0),
cos_sim(self.pool_front, self.pool_behind)
])
self.pool_features = tf.transpose(tf.stack(sims, axis=1),
perm=[2, 0, 1])
print(self.pool_features)
self.fc_out = fully_connected(
inputs=self.pool_features,
num_outputs=fc_hidden_size,
activation_fn=tf.nn.relu,
weights_initializer=xavier_initializer(),
weights_regularizer=l2_regularizer(scale=l2_reg_lambda),
biases_initializer=tf.constant_initializer(0.1),
scope="fc")
print(self.fc_out)
self.haha = softmax(self.fc_out)[:, 1]
print(self.haha)
# Fully Connected Layer
with tf.name_scope("fc"):
W = tf.Variable(tf.truncated_normal(
shape=[num_filters_total * 2, fc_hidden_size],
stddev=0.1,
dtype=tf.float32),
name="W")
b = tf.Variable(tf.constant(0.1,
shape=[fc_hidden_size],
dtype=tf.float32),
name="b")
self.fc = tf.nn.xw_plus_b(self.pool_flat_combine, W, b)
# Batch Normalization Layer
self.fc_bn = tf.layers.batch_normalization(
self.fc, training=self.is_training)
# Apply nonlinearity
self.fc_out = tf.nn.relu(self.fc_bn, name="relu")
# Highway Layer
self.highway = highway(self.fc_out,
self.fc_out.get_shape()[1],
num_layers=1,
bias=0,
scope="Highway")
# Add dropout
with tf.name_scope("dropout"):
self.h_drop = tf.nn.dropout(self.highway, self.dropout_keep_prob)
# Final scores and predictions
with tf.name_scope("output"):
W = tf.Variable(tf.truncated_normal(
shape=[fc_hidden_size, num_classes],
stddev=0.1,
dtype=tf.float32),
name="W")
b = tf.Variable(tf.constant(0.1,
shape=[num_classes],
dtype=tf.float32),
name="b")
self.logits = tf.nn.xw_plus_b(self.h_drop, W, b, name="logits")
self.softmax_scores = tf.nn.softmax(self.logits,
name="softmax_scores")
self.predictions = tf.argmax(self.logits, 1, name="predictions")
self.topKPreds = tf.nn.top_k(self.softmax_scores,
k=1,
sorted=True,
name="topKPreds")
# Calculate mean cross-entropy loss, L2 loss
with tf.name_scope("loss"):
losses = tf.nn.softmax_cross_entropy_with_logits_v2(
labels=self.input_y, logits=self.logits)
losses = tf.reduce_mean(losses, name="softmax_losses")
l2_losses = tf.add_n([
tf.nn.l2_loss(tf.cast(v, tf.float32))
for v in tf.trainable_variables()
],
name="l2_losses") * l2_reg_lambda
self.loss = tf.add(losses, l2_losses, name="loss")
# Accuracy
with tf.name_scope("accuracy"):
correct_predictions = tf.equal(self.predictions,
tf.argmax(self.input_y, 1))
self.accuracy = tf.reduce_mean(tf.cast(correct_predictions,
"float"),
name="accuracy")
# Number of correct predictions
with tf.name_scope("num_correct"):
correct = tf.equal(self.predictions, tf.argmax(self.input_y, 1))
self.num_correct = tf.reduce_sum(tf.cast(correct, "float"),
name="num_correct")
# Calculate Fp
with tf.name_scope("fp"):
fp = tf.metrics.false_positives(labels=tf.argmax(self.input_y, 1),
predictions=self.predictions)
self.fp = tf.reduce_sum(tf.cast(fp, "float"), name="fp")
# Calculate Fn
with tf.name_scope("fn"):
fn = tf.metrics.false_negatives(labels=tf.argmax(self.input_y, 1),
predictions=self.predictions)
self.fn = tf.reduce_sum(tf.cast(fn, "float"), name="fn")
# Calculate Recall
with tf.name_scope("recall"):
self.recall = self.num_correct / (self.num_correct + self.fn)
# Calculate Precision
with tf.name_scope("precision"):
self.precision = self.num_correct / (self.num_correct + self.fp)
# Calculate F1
with tf.name_scope("F1"):
self.F1 = (2 * self.precision * self.recall) / (self.precision +
self.recall)
# Calculate AUC
with tf.name_scope("AUC"):
self.AUC = tf.metrics.auc(self.softmax_scores,
self.input_y,
name="AUC")
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.
This function generates a family of ResNet v1 models. See the resnet_v1_*()
methods for specific model instantiations, obtained by selecting different
block instantiations that produce ResNets of various depths.
Training for image classification on Imagenet is usually done with [224, 224]
inputs, resulting in [7, 7] feature maps at the output of the last ResNet
block for the ResNets defined in [1] that have nominal stride equal to 32.
However, for dense prediction tasks we advise that one uses inputs with
spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
this case the feature maps at the ResNet output will have spatial shape
[(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
and corners exactly aligned with the input image corners, which greatly
facilitates alignment of the features to the image. Using as input [225, 225]
images results in [8, 8] feature maps at the output of the last ResNet block.
For dense prediction tasks, the ResNet needs to run in fully-convolutional
(FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
have nominal stride equal to 32 and a good choice in FCN mode is to use
output_stride=16 in order to increase the density of the computed features at
small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.
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.conv2d, bottleneck, resnet_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_utils.stack_blocks_dense(net, blocks, output_stride)
if global_pool:
# Global average pooling.
net = math_ops.reduce_mean(net, [1, 2], name='pool5', keep_dims=True)
if num_classes is not None:
net = layers.conv2d(
net,
num_classes, [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:
end_points['predictions'] = layers_lib.softmax(
net, scope='predictions')
return net, end_points
def __init__(self,
num_actions,
state_shape=[8, 8, 5],
convs=[[32, 4, 2], [64, 2, 1]],
fully_connected=[128],
activation_fn=tf.nn.relu,
optimizers=[
tf.train.AdamOptimizer(2.5e-4),
tf.train.AdamOptimizer(2.5e-4),
tf.train.AdamOptimizer(2.5e-4)
],
scope="sac",
reuse=False):
with tf.variable_scope(scope, reuse=reuse):
################### Neural network architecture ###################
input_shape = [None] + state_shape
self.input_states = tf.placeholder(dtype=tf.float32,
shape=input_shape)
self.v_values = full_module(self.input_states, convs,
fully_connected, 1, activation_fn)
self.q_values = full_module(self.input_states, convs,
fully_connected, num_actions,
activation_fn)
self.p_logits = full_module(self.input_states, convs,
fully_connected, num_actions,
activation_fn)
self.p_values = layers.softmax(self.p_logits)
##################### Optimization procedure ######################
# convert =actions to indices for p-logits and q-values selection
self.input_actions = tf.placeholder(dtype=tf.int32, shape=[None])
indices_range = tf.range(tf.shape(self.input_actions)[0])
action_indices = tf.stack([indices_range, self.input_actions],
axis=1)
q_values_selected = tf.gather_nd(self.q_values, action_indices)
p_logits_selected = tf.gather_nd(self.p_logits, action_indices)
# choose best actions (according to q-values)
self.q_argmax = tf.argmax(self.q_values, axis=1)
# define loss function and update rule
self.q_targets = tf.placeholder(dtype=tf.float32, shape=[None])
self.v_targets = tf.placeholder(dtype=tf.float32, shape=[None])
self.p_targets = tf.placeholder(dtype=tf.float32, shape=[None])
q_loss = tf.losses.huber_loss(self.q_targets, q_values_selected)
self.q_loss = tf.reduce_sum(q_loss)
q_optimizer = optimizers[0]
v_loss = tf.losses.huber_loss(self.v_targets[:, None],
self.v_values)
self.v_loss = tf.reduce_sum(v_loss)
v_optimizer = optimizers[1]
p_loss = tf.losses.huber_loss(self.p_targets, p_logits_selected)
self.p_loss = tf.reduce_sum(p_loss)
p_optimizer = optimizers[2]
self.update_q_values = q_optimizer.minimize(self.q_loss)
self.update_v_values = v_optimizer.minimize(self.v_loss)
self.update_p_logits = p_optimizer.minimize(self.p_loss)
def __init__(self,
nqc,
value_encodings,
relation_encodings,
num_gpus=1,
encoder=None):
"""Builds a simple, fully-connected model to predict the outcome set given a query string.
Args:
nqc: NeuralQueryContext
value_encodings: (bert features for values, length of value span)
relation_encodings: (bert features for relations, length of relation span)
num_gpus: number of gpus for distributed computation
encoder: encoder (layers.RNN) for parameter sharing between train and dev
Needs:
self.input_ph: input to encoder (either one-hot or BERT layers)
self.mask_ph: mask for the input
self.correct_set_ph.name: target labels (if loss or accuracy is computed)
self.prior_start: sparse matrix for string similarity features
self.is_training: whether the model should is training (for dropout)
Exposes:
self.loss: objective for loss
self.accuracy: mean accuracy metric (P_{predicted}(gold))
self.accuracy_per_ex: detailed per example accuracy
self.log_nql_pred_set: predicted entity set (in nql)
self.log_decoded_relations: predicted relations (as indices)
self.log_start_values: predicted start values (in nql)
self.log_start_cmps: components of predicted start values (in nql)
"""
# Encodings should have the same dimensions
assert value_encodings[0].shape[-1] == relation_encodings[0].shape[-1]
self.context = nqc
self.input_ph = tf.placeholder(tf.float32,
shape=(None, FLAGS.max_query_length,
value_encodings[0].shape[-1]),
name="oh_seq_ph")
self.mask_ph = tf.placeholder(tf.float32,
shape=(None, FLAGS.max_query_length),
name="oh_mask_ph")
self.debug = None
layer_size = FLAGS.layer_size
num_layers = FLAGS.num_layers
max_properties = FLAGS.max_properties
logits_strategy = FLAGS.logits
dropout_rate = FLAGS.dropout
inferred_batch_size = tf.shape(self.input_ph)[0]
self.is_training = tf.placeholder(tf.bool, shape=[])
value_tensor = util.reshape_to_tensor(value_encodings[0],
value_encodings[1])
relation_tensor = util.reshape_to_tensor(relation_encodings[0],
relation_encodings[1])
# The last state of LSTM encoder is the representation of the input string
with tf.variable_scope("model"):
# Build all the model parts:
# encoder: LSTM encoder
# prior: string features
# {value, relation}_similarity: learned embedding similarty
# decoder: LSTM decoder
# value_model: map from encoder to key for attention
# attention: Luong (dot product) attention
# Builds encoder - note that this is in keras
self.encoder = self._build_encoder(encoder, layer_size, num_layers)
# Build module to turn prior (string features) into logits
self.prior_start = tf.sparse.placeholder(
tf.float32,
name="prior_start_ph",
shape=[inferred_batch_size, value_tensor.shape[1]])
with tf.variable_scope("prior"):
prior = Prior()
# Build similarity module - biaffine qAr
with tf.variable_scope("value_similarity"):
value_similarity = Similarity(layer_size, value_tensor,
num_gpus)
# Build relation decoder
with tf.variable_scope("relation_decoder"):
rel_dec_rnn_layers = [
contrib_rnn.LSTMBlockCell(layer_size,
name=("attr_lstm_%d" % i))
for (i, layer_size) in enumerate([layer_size] * num_layers)
]
relation_decoder_cell = tf.nn.rnn_cell.MultiRNNCell(
rel_dec_rnn_layers)
tf.logging.info(
"relation decoder lstm has state of size: {}".format(
relation_decoder_cell.state_size))
# Build similarity module - biaffine qAr
with tf.variable_scope("relation_similarity"):
relation_similarity = Similarity(layer_size, relation_tensor,
1)
with tf.variable_scope("attention"):
attention = layers.Attention()
value_model = tf.get_variable(
"value_transform",
shape=[layer_size, relation_decoder_cell.output_size],
trainable=True)
# Initialization for logging, variables shouldn't be used elsewhere
log_decoded_starts = []
log_start_logits = []
log_decoded_relations = []
# Initialization to prepare before first iteration of loop
prior_logits_0 = prior.compute_logits(
tf.sparse.to_dense(self.prior_start))
cumulative_entities = nqc.all("id_t")
relation_decoder_out = tf.zeros([inferred_batch_size, layer_size])
encoder_output = self.encoder(self.input_ph, mask=self.mask_ph)
query_encoder_out = encoder_output[0]
relation_decoder_state = encoder_output[1:]
# Initialization for property loss, equal to log vars but separating
value_dist = []
relation_dist = []
for i in range(max_properties):
prior_logits = tf.layers.dropout(prior_logits_0,
rate=dropout_rate,
training=self.is_training)
# Use the last state to determine key; more stable than last output
query_key = tf.nn.relu(
tf.matmul(
tf.expand_dims(relation_decoder_state[-1][-1], axis=1),
value_model))
query_emb = tf.squeeze(attention(
[query_key, query_encoder_out],
mask=[None, tf.cast(self.mask_ph, tf.bool)]),
axis=1)
similarity_logits = value_similarity.compute_logits(query_emb)
if logits_strategy == "prior":
total_logits = prior_logits
elif logits_strategy == "sim":
total_logits = similarity_logits
elif logits_strategy == "mixed":
total_logits = prior_logits + similarity_logits
total_dist = contrib_layers.softmax(total_logits)
values_pred = nqc.as_nql(total_dist, "val_g")
with tf.variable_scope("start_follow_{}".format(i)):
start_pred = nqc.all("v_t").follow(
values_pred) # find starting nodes
# Given the previous set of attributes, where are we going?
(relation_decoder_out,
relation_decoder_state) = relation_decoder_cell(
relation_decoder_out, relation_decoder_state)
pred_relation = tf.nn.softmax(
relation_similarity.compute_logits(relation_decoder_out))
if FLAGS.enforce_type:
if i == 0:
is_adjust = nqc.as_tf(nqc.one(IS_A, "rel_g"))
else:
is_adjust = 1 - nqc.as_tf(nqc.one(IS_A, "rel_g"))
pred_relation = pred_relation * is_adjust
nql_pred_relation = nqc.as_nql(pred_relation, "rel_g")
# Conjunctive (& start.follow() & start.follow()...).
with tf.variable_scope("relation_follow_{}".format(i)):
current_entities = start_pred.follow(nql_pred_relation)
cumulative_entities = cumulative_entities & current_entities
# For property loss and regularization
value_dist.append(total_dist)
relation_dist.append(pred_relation)
# Store predictions for logging
log_decoded_starts.append(start_pred)
log_decoded_relations.append(pred_relation)
log_start_logits.append([prior_logits, similarity_logits])
(loss, pred_set_tf,
pred_set_tf_norm) = self._compute_loss(cumulative_entities)
property_loss = self._compute_property_loss(value_dist, relation_dist)
(accuracy_per_ex,
accuracy) = self._compute_accuracy(cumulative_entities, pred_set_tf)
value_loss = self._compute_distribution_regularizer(value_dist)
relation_loss = self._compute_distribution_regularizer(relation_dist)
self.regularization = FLAGS.time_reg * (value_loss + relation_loss)
self.loss = loss - self.regularization
self.property_loss = property_loss
self.accuracy_per_ex = accuracy_per_ex
self.accuracy = accuracy
# Debugging/logging information
log_decoded_relations = tf.transpose(tf.stack(log_decoded_relations),
[1, 0, 2])
tf.logging.info("decoded relations has shape: {}".format(
log_decoded_relations.shape))
self.log_start_values = log_decoded_starts
self.log_start_cmps = [[
nqc.as_nql(logits, "val_g") for logits in comp
] for comp in log_start_logits]
self.log_decoded_relations = tf.nn.top_k(log_decoded_relations, k=5)
self.log_nql_pred_set = nqc.as_nql(pred_set_tf_norm, "id_t")
def _network_template(self, state):
"""Builds a convolutional network that outputs Q-value distributions.
Args:
state: `tf.Tensor`, contains the agent's current state.
Returns:
net: _network_type object containing the tensors output by the network.
"""
weights_initializer = slim.variance_scaling_initializer(factor=1.0 /
np.sqrt(3.0),
mode='FAN_IN',
uniform=True)
with tf.variable_scope('body'):
net = tf.cast(state, tf.float32)
net = tf.div(net, 255.)
net = slim.conv2d(net,
int(32 * self.network_size_expansion), [8, 8],
stride=4,
weights_initializer=weights_initializer)
net = slim.conv2d(net,
int(64 * self.network_size_expansion), [4, 4],
stride=2,
weights_initializer=weights_initializer)
net = slim.conv2d(net,
int(64 * self.network_size_expansion), [3, 3],
stride=1,
weights_initializer=weights_initializer)
net = slim.flatten(net)
body_net = slim.fully_connected(
net,
int(512 * self.network_size_expansion),
weights_initializer=weights_initializer)
logits = []
probabilities = []
q_values = []
with tf.variable_scope('head'):
for _ in range(self.number_of_gammas):
net = slim.fully_connected(
body_net,
self.num_actions * self._num_atoms,
activation_fn=None,
weights_initializer=weights_initializer)
gamma_logits = tf.reshape(
net, [-1, self.num_actions, self._num_atoms])
gamma_probabilities = contrib_layers.softmax(gamma_logits)
gamma_q_values = tf.reduce_sum(self._support *
gamma_probabilities,
axis=2)
# Add one for each gamma being used.
logits.append(gamma_logits)
probabilities.append(gamma_probabilities)
q_values.append(gamma_q_values)
# Estimate the hyperbolic discounted q-values.
hyp_q_values = agent_utils.integrate_q_values(q_values,
self.integral_estimate,
self.eval_gammas,
self.number_of_gammas,
self.gammas)
return self._get_network_type()(hyp_q_values, q_values, logits,
probabilities)
def _create_model(self):
self.input_image = tf.placeholder(tf.float32, shape=(None, None, None, self.img_input_channels), name='input_image_placeholder')
self.gt_image = tf.placeholder(tf.int32, shape=(None, None, None, self.num_classes), name='gt_image_placeholder')
self.gt_contours = tf.placeholder(tf.int32, shape=(None, None, None, self.num_classes), name='gt_contours_placeholder')
self.dropout_prob = tf.placeholder(dtype=tf.float32, shape=None, name='dropout_prob_placeholder')
self.lr = tf.placeholder(dtype=tf.float32, shape=None, name='learning_rate_placeholder')
scale_nc = self.hps.get('scale_nc')
with tf.variable_scope("encoder"):
with tf.variable_scope("block_1"):
conv1 = self._add_common_layers(conv2d(self.input_image, filters=32*scale_nc, kernel_size=3, padding='same'))
conv2 = self._add_common_layers(conv2d(conv1, filters=32*scale_nc, kernel_size=3, padding='same'))
with tf.variable_scope("block_2"):
mp2 = max_pooling2d(conv2, pool_size=2, strides=2, padding='same')
bn1 = self._add_common_layers(self._bottleneck(mp2, size=64*scale_nc))
bn2 = self._add_common_layers(self._bottleneck(bn1, size=64*scale_nc))
with tf.variable_scope("block_3"):
mp3 = max_pooling2d(bn2, pool_size=2, strides=2, padding='same')
bn3 = self._add_common_layers(self._bottleneck(mp3, size=128*scale_nc))
bn4 = self._add_common_layers(self._bottleneck(bn3, size=128*scale_nc))
with tf.variable_scope("block_4"):
mp4 = max_pooling2d(bn4, pool_size=2, strides=2, padding='same')
bn5 = self._add_common_layers(self._bottleneck(mp4, size=256*scale_nc))
bn6 = self._add_common_layers(self._bottleneck(bn5, size=256*scale_nc))
d1 = dropout(bn6, rate=self.dropout_prob)
with tf.variable_scope("block_5"):
mp5 = max_pooling2d(d1, pool_size=2, strides=2, padding='same')
bn7 = self._add_common_layers(self._bottleneck(mp5, size=256*scale_nc))
bn8 = self._add_common_layers(self._bottleneck(bn7, size=256*scale_nc))
d2 = dropout(bn8, rate=self.dropout_prob)
with tf.variable_scope("block_6"):
mp6 = max_pooling2d(d2, pool_size=2, strides=2, padding='same')
bn9 = self._add_common_layers(self._bottleneck(mp6, size=256*scale_nc))
bn10 = self._add_common_layers(self._bottleneck(bn9, size=256*scale_nc))
d3 = dropout(bn10, rate=self.dropout_prob)
self.img_descriptor = tf.reduce_mean(d3, axis=(1, 2))
with tf.variable_scope("decoder_seg"):
deconvs = []
deconvs.append(conv2d(conv2, filters=self.num_classes, kernel_size=3,
padding='same'))
deconvs.append(self._upsample(bn2, k=1))
deconvs.append(self._upsample(bn4, k=2))
deconvs.append(self._upsample(d1, k=3))
deconvs.append(self._upsample(d2, k=4))
deconvs.append(self._upsample(d3, k=5))
concat = tf.concat(deconvs, axis=3)
conv3 = conv2d(concat, filters=self.num_classes, kernel_size=3, padding='same')
ac1 = self._add_common_layers(conv3)
conv4 = conv2d(ac1, filters=self.num_classes, kernel_size=1, padding='same')
ac2 = self._add_common_layers(conv4)
self.preds_seg = softmax(ac2)
with tf.variable_scope("decoder_cont"):
deconvs = []
deconvs.append(conv2d(conv2, filters=self.num_classes, kernel_size=3,
padding='same'))
deconvs.append(self._upsample(bn2, k=1))
deconvs.append(self._upsample(bn4, k=2))
deconvs.append(self._upsample(d1, k=3))
deconvs.append(self._upsample(d2, k=4))
deconvs.append(self._upsample(d3, k=5))
concat = tf.concat(deconvs, axis=3)
conv3 = conv2d(concat, filters=self.num_classes, kernel_size=3, padding='same')
ac1 = self._add_common_layers(conv3)
conv4 = conv2d(ac1, filters=self.num_classes, kernel_size=1, padding='same')
ac2 = self._add_common_layers(conv4)
self.preds_cont = softmax(ac2)
cond1 = tf.greater_equal(self.preds_seg, self.threshold)
cond2 = tf.less(self.preds_cont, self.threshold)
conditions = tf.logical_and(cond1, cond2)
self.preds = tf.where(conditions, tf.ones_like(conditions), tf.zeros_like(conditions))
self._add_train_op()
self.summaries = tf.summary.merge_all()
def my_digit_classifier(x: (None, 28 * 28)): # specify shape as (None, 28*28)
y = layers.fully_connected(x, 100)
z = layers.fully_connected(y, 10, None)
p = layers.softmax(z)
return x, y, z, p
# Fully connected layer 2
net = lays.fully_connected(net, num_outputs=256, activation_fn=tf.nn.tanh)
print(net.shape)
# Apply dropout to reduce overfitting
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(net, keep_prob)
# Matmul layer
W_fc2 = weight_variable([256, numClasses])
b_fc2 = bias_variable([numClasses])
matmulResult = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
print(matmulResult.shape)
# Softmax layer
net = lays.softmax(matmulResult)
print(net.shape)
# Create session and initialise variables
sess = tf.Session()
# Train and evaluate the model
cross_entropy = tf.reduce_mean(
-tf.reduce_sum(y_ * tf.log(net), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(learningRate).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
sess.run(tf.global_variables_initializer())
# Create the saver
saver = tf.train.Saver(tf.trainable_variables())
