def __init__(self, input_, outdim=2, debug=False):
assert outdim >= 1
self._outdim = outdim
input_shape = tuple(input_.get_shape().as_list())
to_flatten = input_shape[self._outdim - 1:]
if any(s is None for s in to_flatten):
flattened = None
else:
flattened = int(np.prod(to_flatten))
self._output_shape = input_shape[1:self._outdim - 1] + (flattened,)
if debug:
util.header('Flatten(new_shape=%s)' % str(self._output_shape))
pre_shape = tf.shape(input_)[:self._outdim - 1:]
to_flatten = tf.reduce_prod(tf.shape(input_)[self._outdim - 1:])
self._output = tf.reshape(input_, tf.concat(0, [pre_shape, tf.pack([to_flatten])]))
python类pack()的实例源码
def _make_actiondist_ops(self, obs_B_H_Df):
B = tf.shape(obs_B_H_Df)[0]
H = tf.shape(obs_B_H_Df)[1]
flatobs_B_H_Df = tf.reshape(obs_B_H_Df, tf.pack([B, H, -1]))
if self.state_include_action:
net_in = tf.concat(2, [flatobs_B_H_Df, self._prev_actions_B_H_Da])
net_shape = (np.prod(self.observation_space.shape) + self.action_space.n,)
else:
net_in = flatobs_B_H_Df
net_shape = (np.prod(self.observation_space.shape),)
with tf.variable_scope('net'):
net = nn.GRUNet(net_in, net_shape, self.action_space.n, self.hidden_spec)
# XXX
self.hidden_dim = net._hidden_dim
scores_B_H_Pa = net.output
actiondist_B_H_Pa = scores_B_H_Pa - tfutil.logsumexp(scores_B_H_Pa, axis=2)
compute_step_prob = tfutil.function([net.step_input, net.step_prev_hidden],
[net.step_output, net.step_hidden])
return actiondist_B_H_Pa, net.step_input, compute_step_prob, net.hid_init
def importance_weights(self, cache):
gen_ll = {}
rec_ll = {}
# w[t][i] -- likelihood ratio for the i-th object after t objects has been seen
w = [0.] * episode_length
for i in xrange(episode_length):
scg.likelihood(self.z[i], cache, rec_ll)
scg.likelihood(self.x[i], cache, gen_ll)
w[i] = gen_ll[VAE.observed_name(i)] + gen_ll[VAE.hidden_name(i)] - rec_ll[VAE.hidden_name(i)]
w = tf.pack(w)
return w, [gen_ll, rec_ll]
def __init__(self, scope):
with tf.variable_scope("%s_shared" % scope):
self.obs = obs = tf.placeholder(
tf.float32, shape=[None, pms.obs_shape], name="%s_obs"%scope)
self.action_n = tf.placeholder(tf.float32, shape=[None, pms.action_shape], name="%s_action"%scope)
self.advant = tf.placeholder(tf.float32, shape=[None], name="%s_advant"%scope)
self.old_dist_means_n = tf.placeholder(tf.float32, shape=[None, pms.action_shape],
name="%s_oldaction_dist_means"%scope)
self.old_dist_logstds_n = tf.placeholder(tf.float32, shape=[None, pms.action_shape],
name="%s_oldaction_dist_logstds"%scope)
self.action_dist_means_n = (pt.wrap(self.obs).
fully_connected(64, activation_fn=tf.nn.relu, init=tf.random_normal_initializer(-0.05, 0.05), bias_init=tf.constant_initializer(0),
name="%s_fc1"%scope).
fully_connected(64, activation_fn=tf.nn.relu, init=tf.random_normal_initializer(-0.05, 0.05), bias_init=tf.constant_initializer(0),
name="%s_fc2"%scope).
fully_connected(pms.action_shape, init=tf.random_normal_initializer(-0.05, 0.05), bias_init=tf.constant_initializer(0),
name="%s_fc3"%scope))
self.N = tf.shape(obs)[0]
Nf = tf.cast(self.N, tf.float32)
self.action_dist_logstd_param = tf.Variable((.01*np.random.randn(1, pms.action_shape)).astype(np.float32), name="%spolicy_logstd"%scope)
self.action_dist_logstds_n = tf.tile(self.action_dist_logstd_param,
tf.pack((tf.shape(self.action_dist_means_n)[0], 1)))
self.var_list = [v for v in tf.trainable_variables()if v.name.startswith(scope)]
def get_mixture_coef(output, KMIX=24, OUTPUTDIM=1):
out_pi = tf.placeholder(dtype=tf.float32, shape=[None,KMIX], name="mixparam")
out_sigma = tf.placeholder(dtype=tf.float32, shape=[None,KMIX], name="mixparam")
out_mu = tf.placeholder(dtype=tf.float32, shape=[None,KMIX*OUTPUTDIM], name="mixparam")
splits = tf.split(1, 2 + OUTPUTDIM, output)
out_pi = splits[0]
out_sigma = splits[1]
out_mu = tf.pack(splits[2:], axis=2)
out_mu = tf.transpose(out_mu, [1,0,2])
# use softmax to normalize pi into prob distribution
max_pi = tf.reduce_max(out_pi, 1, keep_dims=True)
out_pi = tf.sub(out_pi, max_pi)
out_pi = tf.exp(out_pi)
normalize_pi = tf.inv(tf.reduce_sum(out_pi, 1, keep_dims=True))
out_pi = tf.mul(normalize_pi, out_pi)
# use exponential to make sure sigma is positive
out_sigma = tf.exp(out_sigma)
return out_pi, out_sigma, out_mu
def one_hot(labels, num_classes, name='one_hot'):
"""Transform numeric labels into onehot_labels.
Args:
labels: [batch_size] target labels.
num_classes: total number of classes.
scope: Optional scope for op_scope.
Returns:
one hot encoding of the labels.
"""
with tf.op_scope(name):
batch_size = labels.get_shape()[0]
indices = tf.expand_dims(tf.range(0, batch_size), 1)
labels = tf.cast(tf.expand_dims(labels, 1), indices.dtype)
concated = tf.concat(1, [indices, labels])
onehot_labels = tf.sparse_to_dense(
concated, tf.pack([batch_size, num_classes]), 1.0, 0.0)
onehot_labels.set_shape([batch_size, num_classes])
return onehot_labels
def distort_image(image):
"""Perform random distortions to the given 4D image and return result"""
# Switch to 3D as that's what these operations require
slices = tf.unpack(image)
output = []
# Perform pixel-wise distortions
for image in slices:
image = tf.image.random_flip_left_right(image)
image = tf.image.random_saturation(image, .2, 2.)
image += tf.truncated_normal(image.get_shape(), stddev=.05)
image = tf.image.random_contrast(image, .85, 1.15)
image = tf.image.random_brightness(image, .3)
output.append(image)
# Go back to 4D
image = tf.pack(output)
return image
def image_processing_layer(self, X):
K = 1 / 12. * tf.constant(
[
[-1, 2, -2, 2, -1],
[2, -6, 8, -6, 2],
[-2, 8, -12, 8, -2],
[2, -6, 8, -6, 2],
[-1, 2, -2, 2, -1]
], dtype= tf.float32
)
#kernel = tf.pack([K, K, K])
#kernel = tf.pack([kernel, kernel, kernel])
kernel = tf.stack([K, K, K])
kernel = tf.stack([kernel, kernel, kernel])
return tf.nn.conv2d(X, tf.transpose(kernel, [2, 3, 0, 1]), [1, 1, 1, 1], padding='SAME')
def buildAttention(self):
q_relu = self.tensors['q_relu']
a_relu = self.tensors['a_relu']
with tf.name_scope("attention"):
W = identity([self.params['nb_filter'], self.params['nb_filter']], name='W')
batch = tf.shape(q_relu)[0]
q_matmul = tf.batch_matmul(q_relu, tf.tile(tf.expand_dims(W,[0]), tf.pack([batch, tf.constant(1), tf.constant(1)])))
qa_attention = tf.batch_matmul(q_matmul, a_relu, adj_x=False, adj_y=True, name="attention")
# shape = (batch, q_length, 1)
qa_attention = tf.tanh(qa_attention)
q_max = tf.reduce_max(qa_attention, reduction_indices=[2], keep_dims=True, name='q_max')
# shape = (batch, 1, a_length)
a_max = tf.reduce_max(qa_attention, reduction_indices=[1], keep_dims=True, name='a_max')
# shape = (batch, q_length, 1)
q_softmax = tf.expand_dims(tf.nn.softmax(tf.squeeze(q_max, [2])), -1)
# shape = (batch, a_length, 1)
a_softmax = tf.expand_dims(tf.nn.softmax(tf.squeeze(a_max, [1])), -1)
# https://www.tensorflow.org/versions/r0.9/api_docs/python/math_ops.html#batch_matmul
# shape = (batch, NUM_FILTERS, 1)
q_feature = tf.batch_matmul(q_relu, q_softmax, adj_x=True, adj_y=False)
a_feature = tf.batch_matmul(a_relu, a_softmax, adj_x=True, adj_y=False)
self.tensors['q_feature'] = q_feature
self.tensors['a_feature'] = a_feature
self.tensors.setdefault('weights', []).append(W)
def model_chain_from_position(cls, chains_num, layer_descriptions, position_tensor, input_tensor):
""" Creates multiple-chain model from the specified position and description. """
positions = tf.split(0, chains_num, position_tensor)
m = []
for i in range(chains_num):
m.append(cls.model_from_position(layer_descriptions, positions[i], input_tensor))
models = tf.pack(m)
return models
def glimpseSensor(normalLocation, inputPlaceholder):
location = tf.round(tf.multiply((normalLocation + 1)/2.0, InputImageSize))
location = tf.cast(location, tf.int32)
images = tf.reshape(inputPlaceholder, (batchSize, InputImageSize[0],
InputImageSize[1],
InputImageSize[2]))
zooms = []
for k in xrange(batchSize):
imgZooms = []
img = images[k]
loc = location[k]
for i in xrange(glimpseDepth):
radius = int(glimpseRadius * (2 ** i))
glimpse = getGlipmse(img, loc, radius)
glimpse = tf.reshape(glimpse, (glimpseBandwidth, glimpseBandwidth, glimpseBandwidth))
imgZooms.append(glimpse)
zooms.append(tf.pack(imgZooms))
zooms = tf.pack(zooms)
return zooms
def random_flip_left_right(image, seed=None):
uniform_random = random_ops.random_uniform([], 0, 1.0, seed=seed)
mirror = math_ops.less(tf.pack(
[1.0, 1.0, uniform_random, 1.0]), 0.5)
return tf.reverse(image, mirror)
def random_flip_up_down(image, seed=None):
uniform_random = random_ops.random_uniform([], 0, 1.0, seed=seed)
mirror = math_ops.less(tf.pack(
[1.0, uniform_random, 1.0, 1.0]), 0.5)
return tf.reverse(image, mirror)
def _combine_box_and_delta(self, bboxes, deltas):
widths = bboxes[:, 2] - bboxes[:, 0] + 1.0
heights = bboxes[:, 3] - bboxes[:, 1] + 1.0
ctr_x = bboxes[:, 0] + 0.5 * widths
ctr_y = bboxes[:, 1] + 0.5 * heights
# use 0::4 to make it a [-1, 1] matrix, while the columns are 4
dx = deltas[:, 0::4]
dy = deltas[:, 1::4]
dw = deltas[:, 2::4]
dh = deltas[:, 3::4]
# do not understand the transformation
# TF ?????reshape????????????????
pred_ctr_x = tf.reshape(dx * widths[:, tf.newaxis] + ctr_x[:, tf.newaxis], (-1,))
pred_ctr_y = tf.reshape(dy * heights[:, tf.newaxis] + ctr_y[:, tf.newaxis], (-1,))
pred_w = tf.reshape(tf.exp(dw) * widths[:, tf.newaxis], (-1,))
pred_h = tf.reshape(tf.exp(dh) * heights[:, tf.newaxis], (-1,))
pred_boxes = tf.pack(
[pred_ctr_x - 0.5 * pred_w,
pred_ctr_y - 0.5 * pred_h,
pred_ctr_x + 0.5 * pred_w,
pred_ctr_y + 0.5 * pred_h],
axis=1
)
return pred_boxes
def _repeat(self, x, n_repeats):
with tf.variable_scope('_repeat'):
rep = tf.transpose(
tf.expand_dims(tf.ones(shape=tf.pack([n_repeats, ])), 1), [1, 0])
rep = tf.cast(rep, 'int32')
x = tf.matmul(tf.reshape(x, (-1, 1)), rep)
return tf.reshape(x, [-1])
def _transform(self, theta, input_dim, out_size, channel_input):
with tf.variable_scope('_transform'):
print input_dim.get_shape(), theta.get_shape(), out_size[0], out_size[1]
num_batch = self.hps.batch_size #tf.shape(input_dim)[0]
height = tf.shape(input_dim)[1]
width = tf.shape(input_dim)[2]
num_channels = tf.shape(input_dim)[3]
theta = tf.reshape(theta, (-1, 2, 3))
theta = tf.cast(theta, 'float32')
# grid of (x_t, y_t, 1), eq (1) in ref [1]
height_f = tf.cast(height, 'float32')
width_f = tf.cast(width, 'float32')
out_height = out_size[0]
out_width = out_size[1]
grid = self._meshgrid(out_height, out_width)
#print grid, grid.get_shape()
grid = tf.expand_dims(grid, 0)
grid = tf.reshape(grid, [-1])
grid = tf.tile(grid, tf.pack([num_batch]))
grid = tf.reshape(grid, tf.pack([num_batch, 3, -1]))
#print grid, grid.get_shape()
# Transform A x (x_t, y_t, 1)^T -> (x_s, y_s)
T_g = tf.batch_matmul(theta, grid)
x_s = tf.slice(T_g, [0, 0, 0], [-1, 1, -1])
y_s = tf.slice(T_g, [0, 1, 0], [-1, 1, -1])
x_s_flat = tf.reshape(x_s, [-1])
y_s_flat = tf.reshape(y_s, [-1])
#print x_s_flat.get_shape(), y_s_flat.get_shape()
input_transformed = self._interpolate(input_dim, x_s_flat, y_s_flat, out_size, channel_input)
#print input_transformed.get_shape()
output = tf.reshape(input_transformed, tf.pack([num_batch, out_height, out_width, channel_input]))
return output
#return input_dim
def accuracy_instance(predictions, targets, n=[1, 2, 3, 4, 5, 10], nb_classes=5, nb_samples_per_class=10, batch_size=1):
targets = tf.cast(targets, predictions.dtype)
accuracy = tf.constant(value=0, shape=(batch_size, nb_samples_per_class), dtype=tf.float32)
indices = tf.constant(value=0, shape=(batch_size, nb_classes+1), dtype=tf.float32)
def step_((accuracy, indices), (p, t)):
"""with tf.variable_scope("Metric_step_var", reuse=True):
accuracy = tf.get_variable(name="accuracy", shape=(batch_size, nb_samples_per_class),
initializer=tf.constant_initializer(0), dtype=tf.float32)
indices = tf.get_variable(name="indices", shape=(batch_size, nb_classes + 1),
initializer=tf.constant_initializer(0), dtype=tf.float32)"""
p = tf.cast(p, tf.int32)
t = tf.cast(t, tf.int32)
##Accuracy Update
batch_range = tf.cast(tf.range(0, batch_size), dtype=tf.int32)
gather = tf.cast(tf.gather_nd(indices,tf.pack([tf.range(0,p.get_shape().as_list()[0]), t], axis=1)), tf.int32)
index = tf.cast(tf.pack([batch_range, gather], axis=1), dtype=tf.int64)
val = tf.cast(tf.equal(p, t), tf.float32)
delta = tf.SparseTensor(indices=index, values=val, shape=tf.cast(accuracy.get_shape().as_list(), tf.int64))
accuracy = accuracy + tf.sparse_tensor_to_dense(delta)
##Index Update
index = tf.cast(tf.pack([batch_range, t], axis=1), dtype=tf.int64)
val = tf.constant(1.0, shape=[batch_size])
delta = tf.SparseTensor(indices=index, values=val, shape=tf.cast(indices.get_shape().as_list(), dtype=tf.int64))
indices = indices + tf.sparse_tensor_to_dense(delta)
return [accuracy, indices]
def process_single_image(img, scale, crop, mean):
"""
Processing an image for zero-mean/std-dev fix etc
"""
new_shape = tf.pack([scale, scale])
img = tf.image.resize_images(img, new_shape[0], new_shape[1])
offset = (new_shape - crop) / 2
img = tf.slice(img, begin=tf.pack([offset[0], offset[1], 0]), size=tf.pack([crop, crop, -1]))
return tf.to_float(img) - mean
def _reduced_kernel_size_for_small_input(input_tensor, kernel_size):
"""Define kernel size which is automatically reduced for small input.
If the shape of the input images is unknown at graph construction time this
function assumes that the input images are is large enough.
Args:
input_tensor: input tensor of size [batch_size, height, width, channels].
kernel_size: desired kernel size of length 2: [kernel_height, kernel_width]
Returns:
a tensor with the kernel size.
TODO(jrru): Make this function work with unknown shapes. Theoretically, this
can be done with the code below. Problems are two-fold: (1) If the shape was
known, it will be lost. (2) inception.slim.ops._two_element_tuple cannot
handle tensors that define the kernel size.
shape = tf.shape(input_tensor)
return = tf.pack([tf.minimum(shape[1], kernel_size[0]),
tf.minimum(shape[2], kernel_size[1])])
"""
shape = input_tensor.get_shape().as_list()
if shape[1] is None or shape[2] is None:
kernel_size_out = kernel_size
else:
kernel_size_out = [min(shape[1], kernel_size[0]),
min(shape[2], kernel_size[1])]
return kernel_size_out
def _reduced_kernel_size_for_small_input(input_tensor, kernel_size):
"""Define kernel size which is automatically reduced for small input.
If the shape of the input images is unknown at graph construction time this
function assumes that the input images are is large enough.
Args:
input_tensor: input tensor of size [batch_size, height, width, channels].
kernel_size: desired kernel size of length 2: [kernel_height, kernel_width]
Returns:
a tensor with the kernel size.
TODO(jrru): Make this function work with unknown shapes. Theoretically, this
can be done with the code below. Problems are two-fold: (1) If the shape was
known, it will be lost. (2) inception.slim.ops._two_element_tuple cannot
handle tensors that define the kernel size.
shape = tf.shape(input_tensor)
return = tf.pack([tf.minimum(shape[1], kernel_size[0]),
tf.minimum(shape[2], kernel_size[1])])
"""
shape = input_tensor.get_shape().as_list()
if shape[1] is None or shape[2] is None:
kernel_size_out = kernel_size
else:
kernel_size_out = [min(shape[1], kernel_size[0]),
min(shape[2], kernel_size[1])]
return kernel_size_out
