def _meshgrid(depth, height, width, z_near, z_far):
with tf.variable_scope('_meshgrid'):
x_t = tf.reshape(
tf.tile(tf.linspace(-1.0, 1.0, width), [height * depth]),
[depth, height, width])
y_t = tf.reshape(
tf.tile(tf.linspace(-1.0, 1.0, height), [width * depth]),
[depth, width, height])
y_t = tf.transpose(y_t, [0, 2, 1])
sample_grid = tf.tile(
tf.linspace(float(z_near), float(z_far), depth), [width * height])
z_t = tf.reshape(sample_grid, [height, width, depth])
z_t = tf.transpose(z_t, [2, 0, 1])
z_t = 1 / z_t
d_t = 1 / z_t
x_t /= z_t
y_t /= z_t
x_t_flat = tf.reshape(x_t, (1, -1))
y_t_flat = tf.reshape(y_t, (1, -1))
d_t_flat = tf.reshape(d_t, (1, -1))
ones = tf.ones_like(x_t_flat)
grid = tf.concat([d_t_flat, y_t_flat, x_t_flat, ones], 0)
return grid
def meshgrid(batch, height, width, is_homogeneous=True):
"""Construct a 2D meshgrid.
Args:
batch: batch size
height: height of the grid
width: width of the grid
is_homogeneous: whether to return in homogeneous coordinates
Returns:
x,y grid coordinates [batch, 2 (3 if homogeneous), height, width]
"""
x_t = tf.matmul(tf.ones(shape=tf.stack([height, 1])),
tf.transpose(tf.expand_dims(
tf.linspace(-1.0, 1.0, width), 1), [1, 0]))
y_t = tf.matmul(tf.expand_dims(tf.linspace(-1.0, 1.0, height), 1),
tf.ones(shape=tf.stack([1, width])))
x_t = (x_t + 1.0) * 0.5 * tf.cast(width - 1, tf.float32)
y_t = (y_t + 1.0) * 0.5 * tf.cast(height - 1, tf.float32)
if is_homogeneous:
ones = tf.ones_like(x_t)
coords = tf.stack([x_t, y_t, ones], axis=0)
else:
coords = tf.stack([x_t, y_t], axis=0)
coords = tf.tile(tf.expand_dims(coords, 0), [batch, 1, 1, 1])
return coords
def _meshgrid(height, width, fp):
x_t = tf.matmul(
tf.ones(shape=tf.stack([height, 1])),
tf.transpose(tf.expand_dims(tf.linspace(-1.0, 1.0, width), 1), [1, 0]))
y_t = tf.matmul(
tf.expand_dims(tf.linspace(-1.0, 1.0, height), 1),
tf.ones(shape=tf.stack([1, width])))
x_t_flat = tf.reshape(x_t, (1, -1))
y_t_flat = tf.reshape(y_t, (1, -1))
x_t_flat_b = tf.expand_dims(x_t_flat, 0) # [1, 1, h*w]
y_t_flat_b = tf.expand_dims(y_t_flat, 0) # [1, 1, h*w]
num_batch = tf.shape(fp)[0]
px = tf.expand_dims(fp[:,:,0], 2) # [n, nx*ny, 1]
py = tf.expand_dims(fp[:,:,1], 2) # [n, nx*ny, 1]
d = tf.sqrt(tf.pow(x_t_flat_b - px, 2.) + tf.pow(y_t_flat_b - py, 2.))
r = tf.pow(d, 2) * tf.log(d + 1e-6) # [n, nx*ny, h*w]
x_t_flat_g = tf.tile(x_t_flat_b, tf.stack([num_batch, 1, 1])) # [n, 1, h*w]
y_t_flat_g = tf.tile(y_t_flat_b, tf.stack([num_batch, 1, 1])) # [n, 1, h*w]
ones = tf.ones_like(x_t_flat_g) # [n, 1, h*w]
grid = tf.concat([ones, x_t_flat_g, y_t_flat_g, r], 1) # [n, nx*ny+3, h*w]
return grid
def gabor(n_values=32, sigma=1.0, mean=0.0): x = tf.linspace(-3.0, 3.0, n_values) z = (tf.exp(tf.negative(tf.pow(x - mean, 2.0)/ (2.0 * tf.pow(sigma, 2.0)))) * (1.0 / (sigma * tf.sqrt(2.0 * 3.145)))) gauss_kernel = tf.matmul(tf.reshape(z, [n_values, 1]), tf.reshape(z,[1, n_values])) x = tf.reshape(tf.sin(tf.linspace(-3.0, 3.0, n_values)), [n_values, 1]) y = tf.reshape(tf.ones_like(x), [1, n_values]) gabor_kernel = tf.multiply(tf.matmul(x ,y), gauss_kernel) return gabor_kernel
def get_input_vectors(shape, phases, scaling, offset):
x = tf.reshape(tf_repeat(offset[0] + tf.linspace(0.0, tf.to_float(shape[0] - 1), shape[0]) / scaling,
shape[1] * phases),
[shape[0], shape[1], phases]) * tf.pow(2.0, tf.linspace(0.0, tf.to_float(phases - 1), phases))
y = tf.reshape(tf_repeat(tf.tile(
offset[1] + tf.linspace(0.0, tf.to_float(shape[1] - 1), shape[1]) / scaling,
[shape[0]]
), phases), [shape[0], shape[1], phases]) * tf.pow(2.0, tf.linspace(0.0, tf.to_float(phases - 1), phases))
z = tf.reshape(
tf.tile(offset[2] + 10 * tf.linspace(0.0, tf.to_float(phases - 1), phases), [shape[0] * shape[1]]),
[shape[0], shape[1], phases, 1])
x = tf.reshape(x, [shape[0], shape[1], phases, 1])
y = tf.reshape(y, [shape[0], shape[1], phases, 1])
return tf.reshape(tf.concat(3, [x, y, z]), [shape[0] * shape[1] * phases, 3])
def _meshgrid_abs(height, width):
"""Meshgrid in the absolute coordinates."""
x_t = tf.matmul(
tf.ones(shape=tf.stack([height, 1])),
tf.transpose(tf.expand_dims(tf.linspace(-1.0, 1.0, width), 1), [1, 0]))
y_t = tf.matmul(
tf.expand_dims(tf.linspace(-1.0, 1.0, height), 1),
tf.ones(shape=tf.stack([1, width])))
x_t = (x_t + 1.0) * 0.5 * tf.cast(width - 1, tf.float32)
y_t = (y_t + 1.0) * 0.5 * tf.cast(height - 1, tf.float32)
x_t_flat = tf.reshape(x_t, (1, -1))
y_t_flat = tf.reshape(y_t, (1, -1))
ones = tf.ones_like(x_t_flat)
grid = tf.concat([x_t_flat, y_t_flat, ones], axis=0)
return grid
def mgrid(*args, **kwargs):
"""
create orthogonal grid
similar to np.mgrid
Parameters
----------
args : int
number of points on each axis
low : float
minimum coordinate value
high : float
maximum coordinate value
Returns
-------
grid : tf.Tensor [len(args), args[0], ...]
orthogonal grid
"""
low = kwargs.pop("low", -1)
high = kwargs.pop("high", 1)
low = tf.to_float(low)
high = tf.to_float(high)
coords = (tf.linspace(low, high, arg) for arg in args)
grid = tf.pack(tf.meshgrid(*coords, indexing='ij'))
return grid
def testNanFromGradsDontPropagate(self):
"""Test that update with NaN gradients does not cause NaN in results."""
def _nan_log_prob_with_nan_gradient(x):
return np.nan * tf.reduce_sum(x)
initial_x = tf.linspace(0.01, 5, 10)
hmc = tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=_nan_log_prob_with_nan_gradient,
step_size=2.,
num_leapfrog_steps=5,
seed=_set_seed(47))
updated_x, kernel_results = hmc.one_step(
current_state=initial_x,
previous_kernel_results=hmc.bootstrap_results(initial_x))
initial_x_, updated_x_, log_accept_ratio_ = self.evaluate(
[initial_x, updated_x, kernel_results.log_accept_ratio])
acceptance_probs = np.exp(np.minimum(log_accept_ratio_, 0.))
tf.logging.vlog(1, 'initial_x = {}'.format(initial_x_))
tf.logging.vlog(1, 'updated_x = {}'.format(updated_x_))
tf.logging.vlog(1, 'log_accept_ratio = {}'.format(log_accept_ratio_))
self.assertAllEqual(initial_x_, updated_x_)
self.assertEqual(acceptance_probs, 0.)
self.assertAllFinite(
self.evaluate(tf.gradients(updated_x, initial_x)[0]))
self.assertAllEqual(
[True],
[g is None for g in tf.gradients(
kernel_results.proposed_results.grads_target_log_prob,
initial_x)])
def _LinSpace(self, start, stop, num):
# NOTE(touts): Needs to pass a graph to get a new session each time.
with tf.Graph().as_default() as graph:
with self.test_session(graph=graph, force_gpu=self.force_gpu):
tf_ans = tf.linspace(start, stop, num, name="linspace")
self.assertEqual([num], tf_ans.get_shape())
return tf_ans.eval()
def __init__(self, config):
self.dim_img = config.dim_img
self.dim_wav = config.dim_wav
self.dim_mem = config.dim_mem
self.mem_size = self.steps = config.mem_size
self.n_hop = config.n_hop
self.batch_size = config.batch_size
self.do_prob = config.do_prob # keep prob
self.nl = config.nl # keep prob
self.learning_rate = config.learning_rate
self.global_step = tf.Variable(0, name='g_step')
self.A = tf.Variable(tf.random_normal([self.dim_wav, self.dim_mem]), name='A')
self.b_A = tf.Variable(tf.random_normal([self.dim_mem]), name='b_A')
self.B = tf.Variable(tf.random_normal([self.dim_img, self.dim_mem]), name='B')
self.b_B = tf.Variable(tf.random_normal([self.dim_mem]), name='b_B')
self.C = tf.Variable(tf.random_normal([self.dim_wav, self.dim_mem]), name='C')
self.b_C = tf.Variable(tf.random_normal([self.dim_mem]), name='b_C')
self._temporal = tf.linspace(0.0, np.float32(self.mem_size-1), self.mem_size)
self.T_A = self.T_C = tf.Variable(self._temporal/tf.reduce_sum(self._temporal))
self.W_o = tf.Variable(tf.random_normal([self.dim_mem, 1]))
self.b_o = tf.Variable(tf.random_normal([1]))
def compute_center_coords(self, y_true, y_pred):
batch_size = tf.shape(y_pred)[0]
h = tf.shape(y_pred)[1]
w = tf.shape(y_pred)[2]
n_chans = tf.shape(y_pred)[3]
n_dims = 5
# weighted center of mass
x = tf.cast(tf.tile(tf.reshape(self.xs, [1, h, w]), [batch_size, 1, 1]), tf.float32)
y = tf.cast(tf.tile(tf.reshape(self.ys, [1, h, w]), [batch_size, 1, 1]), tf.float32)
eps = 1e-8
# grayscale
pred_gray = tf.reduce_mean(y_pred, axis=-1) # should be batch_size x h x w
# normalize
pred_gray = pred_gray - tf.reduce_min(pred_gray, axis=[1, 2], keepdims=True)
pred_gray = pred_gray / (eps + tf.reduce_max(pred_gray, axis=[1, 2], keepdims=True))
pred_gray = tf.clip_by_value(pred_gray, 0., 1.)
# make each of these (batch_size, 1)
weighted_x = tf.round(tf.expand_dims(
tf.reduce_sum(x * pred_gray, axis=[1, 2]) / (eps + tf.reduce_sum(pred_gray, axis=[1, 2])), axis=-1))
weighted_y = tf.round(tf.expand_dims(
tf.reduce_sum(y * pred_gray, axis=[1, 2]) / (eps + tf.reduce_sum(pred_gray, axis=[1, 2])), axis=-1))
batch_indices = tf.reshape(tf.linspace(0., tf.cast(batch_size, tf.float32) - 1., batch_size), [batch_size, 1])
indices = tf.cast(tf.concat([batch_indices, weighted_y, weighted_x], axis=-1), tf.int32)
#center_rgb = transform_network_utils.interpolate([y_true, weighted_x, weighted_y], constant_vals=1.)
center_rgb = tf.gather_nd(y_true, indices)
center_rgb = tf.reshape(center_rgb, [batch_size, n_chans])
center_point_xyrgb = tf.concat([
weighted_x, weighted_y, center_rgb
], axis=-1)
return pred_gray, center_point_xyrgb
def compute_auc(tp, fn, tn, fp, name):
"""Computes the roc-auc or pr-auc based on confusion counts."""
rec = tf.div(tp + epsilon, tp + fn + epsilon)
if curve == 'ROC':
fp_rate = tf.div(fp, fp + tn + epsilon)
x = fp_rate
y = rec
elif curve == 'R': # recall auc
x = tf.linspace(1., 0., num_thresholds)
y = rec
else: # curve == 'PR'.
prec = tf.div(tp + epsilon, tp + fp + epsilon)
x = rec
y = prec
if summation_method == 'trapezoidal':
return tf.reduce_sum(
tf.multiply(x[:num_thresholds - 1] - x[1:],
(y[:num_thresholds - 1] + y[1:]) / 2.),
name=name)
elif summation_method == 'minoring':
return tf.reduce_sum(
tf.multiply(x[:num_thresholds - 1] - x[1:],
tf.minimum(y[:num_thresholds - 1], y[1:])),
name=name)
elif summation_method == 'majoring':
return tf.reduce_sum(
tf.multiply(x[:num_thresholds - 1] - x[1:],
tf.maximum(y[:num_thresholds - 1], y[1:])),
name=name)
else:
raise ValueError('Invalid summation_method: %s' % summation_method)
def testRWM1DNNormal(self):
"""Sampling from the Standard Normal Distribution."""
dtype = np.float32
with self.test_session(graph=tf.Graph()) as sess:
target = tfd.Normal(loc=dtype(0), scale=dtype(1))
def make_kernel_fn(target_log_prob_fn, seed):
return tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=target_log_prob_fn,
seed=seed, step_size=1.0, num_leapfrog_steps=3)
remc = tfp.mcmc.ReplicaExchangeMC(
target_log_prob_fn=target.log_prob,
inverse_temperatures=10.**tf.linspace(0., -2., 5),
make_kernel_fn=make_kernel_fn,
seed=42)
samples, _ = tfp.mcmc.sample_chain(
num_results=1000,
current_state=dtype(1),
kernel=remc,
num_burnin_steps=500,
parallel_iterations=1) # For determinism.
sample_mean = tf.reduce_mean(samples, axis=0)
sample_std = tf.sqrt(
tf.reduce_mean(tf.squared_difference(samples, sample_mean),
axis=0))
[sample_mean_, sample_std_] = sess.run([sample_mean, sample_std])
self.assertAllClose(sample_mean_, 0., atol=0.1, rtol=0.1)
self.assertAllClose(sample_std_, 1., atol=0.1, rtol=0.1)
def testBijector(self, lower, upper):
bijector = tfb.Reciprocal()
self.assertEqual('reciprocal', bijector.name)
x = tf.linspace(lower, upper, 100)
y = 1. / x
self.assertAllClose(self.evaluate(y), self.evaluate(bijector.forward(x)))
self.assertAllClose(self.evaluate(x), self.evaluate(bijector.inverse(y)))
def w(input_data, cu, kappas_t_1, config): batch_size = config.batch_size mixture_size = config.mixture_size vocab_length = config.vocab_length # split along dim of mixture size * 3 hat_alphas_t, hat_betas_t, hat_kappas_t = tf.split(1, 3, input_data) alphas_t = tf.exp(hat_alphas_t) betas_t = tf.exp(hat_betas_t) kappas_t = tf.add(kappas_t_1, tf.exp(hat_kappas_t)) speech_length = tf.shape(cu)[1] u = tf.linspace(1.0, tf.cast(speech_length,tf.float32) , speech_length) u = tf.expand_dims(u, 0) u = tf.expand_dims(u, 0) u = tf.tile(u, [batch_size, mixture_size, 1]) alphas_t_expanded = tf.tile(tf.expand_dims(alphas_t, -1), [1, 1, speech_length]) betas_t_expanded = tf.tile(tf.expand_dims(betas_t, -1), [1, 1, speech_length]) kappas_t_expanded = tf.tile(tf.expand_dims(kappas_t, -1), [1, 1, speech_length]) calc = tf.square(tf.sub(kappas_t_expanded, u)) calc = tf.mul(calc, tf.neg(betas_t_expanded)) calc = tf.exp(calc) calc = tf.mul(calc, alphas_t_expanded) phi_t = tf.expand_dims(tf.reduce_sum(calc, 1), 1) output = tf.squeeze(tf.batch_matmul(phi_t, cu), [1]) return output, kappas_t, phi_t
def _meshgrid(self, height, width, depth):
x_t = tf.matmul(tf.ones(shape=tf.stack([height, 1])),
tf.transpose(tf.expand_dims(tf.linspace(0.0,
tf.cast(width, tf.float32)-1.0, width), 1), [1, 0]))
y_t = tf.matmul(tf.expand_dims(tf.linspace(0.0,
tf.cast(height, tf.float32)-1.0, height), 1),
tf.ones(shape=tf.stack([1, width])))
x_t = tf.tile(tf.expand_dims(x_t, 2), [1, 1, depth])
y_t = tf.tile(tf.expand_dims(y_t, 2), [1, 1, depth])
z_t = tf.linspace(0.0, tf.cast(depth, tf.float32)-1.0, depth)
z_t = tf.expand_dims(tf.expand_dims(z_t, 0), 0)
z_t = tf.tile(z_t, [height, width, 1])
return x_t, y_t, z_t
def _lin_space_weights(num, img_size):
if num > 1:
start_weights = tf.linspace(img_size - 1.0, 0.0, num)
stop_weights = img_size - 1 - start_weights
else:
start_weights = tf.constant(num * [.5 * (img_size - 1)], dtype=tf.float32)
stop_weights = tf.constant(num * [.5 * (img_size - 1)], dtype=tf.float32)
return (start_weights, stop_weights)
def test_finds_max_of_long_array(self): # d - 1 == d in float32 and d = 3e7. # So this test only passes if we use double for the percentile indices. # If float is used, it fails with InvalidArgumentError about an index out of # bounds. x = tf.linspace(0., 3e7, num=int(3e7)) minval = tfd.percentile(x, q=0, validate_args=True) self.assertAllEqual(0, self.evaluate(minval))
def _multi_gamma_sequence(self, a, p, name="multi_gamma_sequence"):
"""Creates sequence used in multivariate (di)gamma; shape = shape(a)+[p]."""
with self._name_scope(name, values=[a, p]):
# Linspace only takes scalars, so we'll add in the offset afterwards.
seq = tf.linspace(
tf.constant(0., dtype=self.dtype), 0.5 - 0.5 * p, tf.cast(
p, tf.int32))
return seq + tf.expand_dims(a, [-1])
def calculate_image(noise_values, phases, shape):
val = tf.floor((tf.add_n(tf.split(
2,
phases,
tf.reshape(noise_values, [shape[0], shape[1], phases]) / tf.pow(
2.0,
tf.linspace(0.0, tf.to_float(phases - 1), phases))
)) + 1.0) * 128)
return tf.concat(2, [val, val, val])
def _meshgrid(height, width):
# This should be equivalent to:
# x_t, y_t = np.meshgrid(np.linspace(-1, 1, width),
# np.linspace(-1, 1, height))
# ones = np.ones(np.prod(x_t.shape))
# grid = np.vstack([x_t.flatten(), y_t.flatten(), ones])
x_t = tf.matmul(
tf.ones(shape=tf.stack([height, 1])),
tf.transpose(a=tf.expand_dims(tf.linspace(-1.0, 1.0, width), 1), perm=[1, 0])
)
y_t = tf.matmul(tf.expand_dims(tf.linspace(-1.0, 1.0, height), 1), tf.ones(shape=tf.stack([1, width])))
x_t_flat = tf.reshape(x_t, (1, -1))
y_t_flat = tf.reshape(y_t, (1, -1))
ones = tf.ones_like(x_t_flat)
grid = tf.concat(axis=0, values=[x_t_flat, y_t_flat, ones])
return grid
def make_variable(self):
n = 256
shape = (n, n, n)
items = n**3
var = tf.Variable(
tf.reshape(
tf.linspace(1., float(items), items), shape),
dtype=tf.float32)
return var
def test_new_style_audio(self):
audio = tf.reshape(tf.linspace(0.0, 100.0, 4 * 10 * 2), (4, 10, 2))
op = audio_summary.op('k488',
tf.cast(audio, tf.float32),
sample_rate=44100,
display_name='Piano Concerto No.23',
description='In **A major**.')
value = self._value_from_op(op)
assert value.HasField('tensor'), value
self._assert_noop(value)
def _create_features(self):
"""Creates the coordinates for resampling. If field_transform is
None, these are constant and are created in field space; otherwise,
the final coordinates will be transformed by an input tensor
representing a transform from output coordinates to field
coordinates, so they are created are created in output coordinate
space
"""
embedded_output_shape = list(self._output_shape)+[1]*(len(self._source_shape) - len(self._output_shape))
embedded_coeff_shape = list(self._coeff_shape)+[1]*(len(self._source_shape) - len(self._output_shape))
if self._field_transform==None and self._interpolation == 'BSPLINE':
range_func= lambda f,x: tf.linspace(1.,f-2.,x)
elif self._field_transform==None and self._interpolation != 'BSPLINE':
range_func= lambda f,x: tf.linspace(0.,f-1.,x)
else:
range_func= lambda f,x: np.arange(x,dtype=np.float32)
embedded_output_shape+=[1] # make homogeneous
embedded_coeff_shape+=[1]
ranges = [range_func(f,x) for f,x in zip(embedded_coeff_shape,embedded_output_shape)]
coords= tf.stack([tf.reshape(x,[1,-1]) for x in tf.meshgrid(*ranges, indexing='ij')],2)
return coords
def test_on_1d_array_log_spaced_grid(self):
x_min = 1.
x_max = 100000.
num_pts = 10
# With only 10 interpolating points between x_ref = 1 and 100000,
# and y_ref = log(x_ref), we better use a log-spaced grid, or else error
# will be very bad.
implied_x_ref = tf.exp(tf.linspace(tf.log(x_min), tf.log(x_max), num_pts))
y_ref = tf.log(implied_x_ref)
x = tf.linspace(x_min + 0.123, x_max, 20)
y_expected = tf.log(x)
with self.test_session():
y = tfp.math.interp_regular_1d_grid(
x, x_min, x_max, y_ref, grid_regularizing_transform=tf.log)
self.assertAllEqual(y_expected.shape, y.shape)
y_ = self.evaluate(y)
# Super duper accuracy! Note accuracy was not good if I did not use the
# grid_regularizing_transform.
self.assertAllClose(y_, y_expected, atol=0, rtol=1e-6)
def generate_boxes(fm_side, scale, aspect_ratios=[]):
"""generates a regular grid fm_size * fm_size of bboxes
corresponding to the current scale"""
stride_space = tf.linspace(0.5 / fm_side, 1 - 0.5 / fm_side, fm_side)
yv, xv = tf.meshgrid(stride_space, stride_space, indexing='ij')
h_s, w_s = tf.zeros_like(xv) + scale, tf.zeros_like(xv) + scale
xywh_space = tf.stack([xv, yv, w_s, h_s], 2)
bbox_set = tf.reshape(xywh_space, [fm_side, fm_side, 1, 4])
priors = [bbox_set]
for aspect_ratio in aspect_ratios:
# using a reference grid of square bboxes generates asymmetric bboxes
priors.append(adjust_for_aspect_ratio(bbox_set, aspect_ratio))
return priors
def testRWM2DMixNormal(self):
"""Sampling from a 2-D Mixture Normal Distribution."""
dtype = np.float32
# By symmetry, target has mean [0, 0]
# Therefore, Var = E[X^2] = E[E[X^2 | c]], where c is the component.
# Now..., for the first component,
# E[X1^2] = Var[X1] + Mean[X1]^2
# = 0.1^2 + 1^2,
# and similarly for the second. As a result,
# Var[mixture] = 1.01.
target = tfd.MixtureSameFamily(
mixture_distribution=tfd.Categorical(probs=[0.5, 0.5]),
components_distribution=tfd.MultivariateNormalDiag(
# Mixture components are 20 standard deviations apart!
loc=[[-1., -1], [1., 1.]],
scale_identity_multiplier=[0.1, 0.1]))
def make_kernel_fn(target_log_prob_fn, seed):
return tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=target_log_prob_fn,
seed=seed,
step_size=0.3,
num_leapfrog_steps=3)
remc = tfp.mcmc.ReplicaExchangeMC(
target_log_prob_fn=target.log_prob,
# Verified that test fails if inverse_temperatures = [1]
inverse_temperatures=10.**tf.linspace(0., -2., 5),
make_kernel_fn=make_kernel_fn,
seed=_set_seed(888))
samples, _ = tfp.mcmc.sample_chain(
num_results=2000,
# Start at one of the modes, in order to make mode jumping necessary
# if we want to pass test.
current_state=np.ones(2, dtype=dtype),
kernel=remc,
num_burnin_steps=500,
parallel_iterations=1) # For determinism.
self.assertAllEqual((2000, 2), samples.shape)
sample_mean = tf.reduce_mean(samples, axis=0)
sample_std = tf.sqrt(
tf.reduce_mean(tf.squared_difference(samples, sample_mean), axis=0))
[sample_mean_, sample_std_] = self.evaluate([sample_mean, sample_std])
self.assertAllClose(sample_mean_, [0., 0.], atol=0.3, rtol=0.3)
self.assertAllClose(
sample_std_, [np.sqrt(1.01), np.sqrt(1.01)], atol=0.1, rtol=0.1)
def main(_):
sns.set(color_codes=True)
ed.set_seed(42)
# DATA. We use a placeholder to represent a minibatch. During
# inference, we generate data on the fly and feed `x_ph`.
x_ph = tf.placeholder(tf.float32, [FLAGS.M, 1])
# MODEL
with tf.variable_scope("Gen"):
eps = tf.linspace(-8.0, 8.0, FLAGS.M) + 0.01 * tf.random_normal([FLAGS.M])
eps = tf.reshape(eps, [FLAGS.M, 1])
x = generative_network(eps)
# INFERENCE
optimizer = tf.train.GradientDescentOptimizer(0.03)
optimizer_d = tf.train.GradientDescentOptimizer(0.03)
inference = ed.WGANInference(
data={x: x_ph}, discriminator=discriminative_network)
inference.initialize(
optimizer=optimizer, optimizer_d=optimizer_d, penalty=0.1,
n_iter=1000)
tf.global_variables_initializer().run()
for _ in range(inference.n_iter):
x_data = next_batch(FLAGS.M).reshape([FLAGS.M, 1])
for _ in range(5):
info_dict_d = inference.update(feed_dict={x_ph: x_data}, variables="Disc")
info_dict = inference.update(feed_dict={x_ph: x_data}, variables="Gen")
info_dict['t'] = info_dict['t'] // 6 # say set of 6 updates is 1 iteration
info_dict['loss_d'] = info_dict_d['loss_d'] # get disc loss from update
inference.print_progress(info_dict)
# CRITICISM
db, pd, pg = get_samples(x_ph)
db_x = np.linspace(-8, 8, len(db))
p_x = np.linspace(-8, 8, len(pd))
f, ax = plt.subplots(1)
ax.plot(db_x, db, label="Decision boundary")
ax.set_ylim(0, 1)
plt.plot(p_x, pd, label="Real data")
plt.plot(p_x, pg, label="Generated data")
plt.title("1D Generative Adversarial Network")
plt.xlabel("Data values")
plt.ylabel("Probability density")
plt.legend()
plt.show()
def testLogProbSameFor1D(self):
# 1D MVT is exactly a regular Student's T distribution.
t_dist = student_t.StudentT(
df=self._input(5.), loc=self._input(2.), scale=self._input(3.))
scale = tf.linalg.LinearOperatorDiag([self._input(3.)])
mvt_dist = mvt.MultivariateStudentTLinearOperator(
loc=[self._input(2.)], df=self._input(5.), scale=scale)
test_points = tf.cast(tf.linspace(-10.0, 10.0, 100), self.dtype)
t_log_probs = self.evaluate(t_dist.log_prob(test_points))
mvt_log_probs = self.evaluate(
mvt_dist.log_prob(test_points[..., tf.newaxis]))
self.assertAllClose(t_log_probs, mvt_log_probs)
def _compute_quantiles():
"""Helper to build quantiles."""
# Omit {0, 1} since they might lead to Inf/NaN.
zero = tf.zeros([], dtype=dist.dtype)
edges = tf.linspace(zero, 1., quadrature_size + 3)[1:-1]
# Expand edges so its broadcast across batch dims.
edges = tf.reshape(
edges,
shape=tf.concat(
[[-1], tf.ones([batch_ndims], dtype=tf.int32)], axis=0))
quantiles = dist.quantile(edges)
# Cyclically permute left by one.
perm = tf.concat([tf.range(1, 1 + batch_ndims), [0]], axis=0)
quantiles = tf.transpose(quantiles, perm)
return quantiles
import tensorflow as tf import os #忽略CPU AVX2訊息 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' a=tf.zeros([2, 3], tf.int32) b=tf.zeros_like(a, dtype=None, name=None) #我要一個零矩陣維度跟指定的變數一樣 c=tf.fill([2, 3], 8) d=tf.linspace(10.0, 13.0, 10) #下限 上限 切幾塊 e=tf.range(1, limit=10, delta=1, dtype=None,name='range') #下陷 上限 一刀切多少 a1=tf.constant([[1,2,3],[4,5,6],[7,8,9]], tf.float32) a2=tf.constant([[1,2,3],[4,5,6],[7,8,9]], tf.float32) f=tf.matmul(a1,a2) g=tf.linalg.det(f).numpy() #det必須要float32的格式 print(g)
zero_similar = tf.Variable(tf.zeros_like(zero_var))
ones_similar = tf.Variable(tf.ones_like(ones_var))
sess.run(ones_similar.initializer)
sess.run(zero_similar.initializer)
# Fill shape with a constant
fill_var = tf.Variable(tf.fill([row_dim, col_dim], -1))
# Create a variable from a constant
const_var = tf.Variable(tf.constant([8, 6, 7, 5, 3, 0, 9]))
# This can also be used to fill an array:
const_fill_var = tf.Variable(tf.constant(-1, shape=[row_dim, col_dim]))
# Sequence generation
linear_var = tf.Variable(tf.linspace(
start=0.0, stop=1.0, num=3)) # Generates [0.0, 0.5, 1.0] includes the end
sequence_var = tf.Variable(
tf.range(start=6, limit=15,
delta=3)) # Generates [6, 9, 12] doesn't include the end
# Random Numbers
# Random Normal
rnorm_var = tf.random_normal([row_dim, col_dim], mean=0.0, stddev=1.0)
# Add summaries to tensorboard
merged = tf.summary.merge_all()
# Initialize graph writer:
def _LinSpace(self, start, stop, num):
with self.test_session():
tf_ans = tf.linspace(start, stop, num, name="linspace")
self.assertEqual([num], tf_ans.get_shape())
return tf_ans.eval()
"""## `linear_lookup()` Synthesize audio with an array of sinusoidal oscillators. Frequencies and amplitudes must be provided at audio rate. ### Ex: Sinusoidal lookup As a simple example, lookup from a sin-wave wavetable produces a sin wave at the lookup frequency """ n_samples = int(sample_rate * 1.0) n_wavetable = 2048 n_cycles = 440 # Sin wave wavetable = tf.sin(tf.linspace(0.0, 2.0 * np.pi, n_wavetable)) wavetable = wavetable[tf.newaxis, tf.newaxis, :] phase = tf.linspace(0.0, n_cycles, n_samples) % 1.0 phase = phase[tf.newaxis, :, tf.newaxis] output = ddsp.core.linear_lookup(phase, wavetable) target = np.sin(np.linspace(0.0, 2.0 * np.pi * n_cycles, n_samples)) # For plotting. output = output[0] phase = phase[0, :, 0] # Plot the results plt.figure(figsize=(12, 6))
batch_size = 2
s = tf.placeholder(tf.float32, [1])
gt = tf.placeholder(tf.float32, [2, 3, 3, 7])
t = tf.Variable([[4., 9., 16., 25., 30.], [5., 10., 17., 26., 31.]],
tf.float32)
print("t.shape:", t.shape)
d = 3
w = 3
z_b = tf.tile(t, [1, d * w])
print("z_b.shape:", z_b.shape)
matrix = tf.reshape(z_b, [batch_size, d, w, 5])
print("matrix.shape: ", matrix.shape)
x = tf.linspace(tf.constant(-1, tf.float32), tf.constant(1, tf.float32), w)
print('x:', x)
y = tf.linspace(tf.constant(-1, tf.float32), tf.constant(1, tf.float32), w)
print('y:', y)
xb, yb = tf.meshgrid(x, y)
print("xb: ", xb)
xb_dim1 = tf.expand_dims(xb, 2)
print("xb_dim1.shape: ", xb_dim1.shape)
#xb_const = tf.stop_gradient(xb_dim1)
xb_const = xb_dim1
print("xb_const: ", xb_const)
yb_dim1 = tf.expand_dims(yb, 2)
print("yb_dim1.shape: ", yb_dim1.shape)
def main():
# the data is assumed to have been sampled from a 2-model gaussian mixtured model (GMM) distribution
# inference the parameters of the gaussian mixtured model (GMM).
# download observation data and convert to tensor
url = 'https://raw.githubusercontent.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/master/Chapter3_MCMC/data/mixture_data.csv'
filename = wget.download(url)
data = np.loadtxt(filename, delimiter=',')
data = tf.constant(data, dtype=tf.float32)
step_size = tf.Variable(0.5, dtype=tf.float32, trainable=False)
bijectors = [
tfp.bijectors.Identity(),
tfp.bijectors.Identity(),
tfp.bijectors.Identity()
]
# inference the posteriori according to the observation with MCMC
[model1_probs, mus, sigmas], kernel_results = tfp.mcmc.sample_chain(
num_results=25000,
num_burnin_steps=1000,
current_state=[
tf.constant(0.5),
tf.constant([120., 190.]),
tf.constant([10., 10.])
],
kernel=tfp.mcmc.TransformedTransitionKernel(
inner_kernel=tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=log_prob_generator(data),
num_leapfrog_steps=2,
step_size=step_size,
step_size_update_fn=tfp.mcmc.
make_simple_step_size_update_policy(num_adaptation_steps=1000),
state_gradients_are_stopped=True),
bijector=bijectors))
print('acceptance rate: %f' % tf.math.reduce_mean(
tf.cast(kernel_results.inner_results.is_accepted, dtype=tf.float32)))
print('final step size: %f' % tf.math.reduce_mean(
kernel_results.inner_results.extra.step_size_assign[-100:]))
# plot the samples
# for pretty colors later in the book.
colors = ['#5DA5DA', '#F15854'
] if mus[-1, 0] > mus[-1, 1] else ['#F15854', '#5DA5DA']
plt.figure(figsize(12.5, 9))
# plot means of two models.
plt.subplot(311)
plt.plot(mus[:, 0], label="trace of center 0", c=colors[0], lw=1)
plt.plot(mus[:, 1], label="trace of center 1", c=colors[1], lw=1)
plt.title("Traces of unknown parameters")
leg = plt.legend(loc="upper right")
leg.get_frame().set_alpha(0.7)
# plot sigmas of two models.
plt.subplot(312)
plt.plot(sigmas[:, 0],
label="trace of standard deviation of cluster 0",
c=colors[0],
lw=1)
plt.plot(sigmas[:, 1],
label="trace of standard deviation of cluster 1",
c=colors[1],
lw=1)
plt.legend(loc="upper left")
# plot mixture probability of GMM.
plt.subplot(313)
plt.plot(model1_probs,
label="$p$: frequency of assignment to cluster 0",
c='#60BD68',
lw=1)
plt.xlabel("Steps")
plt.ylim(0, 1)
plt.legend()
plt.show()
# sample 50000 extra samples.
# inference the posteriori according to the observation with MCMC
[
model1_probs_extended, mus_extended, sigmas_extended
], kernel_results = tfp.mcmc.sample_chain(
num_results=50000,
num_burnin_steps=0,
current_state=[model1_probs[-1], mus[-1], sigmas[-1]],
kernel=tfp.mcmc.TransformedTransitionKernel(
inner_kernel=tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=log_prob_generator(data),
num_leapfrog_steps=2,
step_size=step_size,
step_size_update_fn=tfp.mcmc.
make_simple_step_size_update_policy(num_adaptation_steps=1000),
state_gradients_are_stopped=True),
bijector=bijectors))
print('acceptance rate: %f' % tf.math.reduce_mean(
tf.cast(kernel_results.inner_results.is_accepted, dtype=tf.float32)))
print('final step size: %f' % tf.math.reduce_mean(
kernel_results.inner_results.extra.step_size_assign[-100:]))
plt.figure(figsize(12.5, 4))
# draw the first 25000 samples
x = tf.range(25000)
plt.plot(x,
mus[:, 0],
label='previous trace of center 0',
lw=1,
alpha=0.4,
c=colors[1])
plt.plot(x,
mus[:, 1],
label='previous trace of center 1',
lw=1,
alpha=0.4,
c=colors[0])
# draw the following 50000 samples
x = tf.range(25000, 75000)
plt.plot(x,
mus_extended[:, 0],
label='new trace of center 0',
lw=1,
c='#5DA5DA')
plt.plot(x,
mus_extended[:, 1],
label='new trace of center 1',
lw=1,
c='#F15854')
plt.title('Traces of unknown center parameters')
leg = plt.legend(loc='upper right')
leg.get_frame().set_alpha(0.8)
plt.xlabel('Steps')
plt.show()
plt.figure(figsize(12.5, 8))
for i in range(2):
plt.subplot(2, 2, 2 * i + 1)
plt.title('Posterior of center of cluster %d' % i)
plt.hist(mus_extended[:, i],
color=colors[i],
bins=30,
histtype='stepfilled')
plt.subplot(2, 2, 2 * i + 2)
plt.title('Posterior of standard deviation of cluster %d' % i)
plt.hist(sigmas_extended[:, 1],
color=colors[i],
bins=30,
histtype='stepfilled')
plt.tight_layout()
plt.show()
dist_0 = tfp.distributions.Normal(
loc=tf.math.reduce_mean(mus_extended[:, 0]),
scale=tf.math.reduce_mean(sigmas_extended[:, 0]))
dist_1 = tfp.distributions.Normal(
loc=tf.math.reduce_mean(mus_extended[:, 1]),
scale=tf.math.reduce_mean(sigmas_extended[:, 1]))
prob_assignment_1 = dist_0.prob(data)
prob_assignment_2 = dist_1.prob(data)
probs_assignments = 1. - (prob_assignment_1 /
(prob_assignment_1 + prob_assignment_2))
probs_assignments_inv = 1. - probs_assignments
# cluster_probs.shape = (data.shape[0], 2)
cluster_probs = tf.transpose(
tf.stack([probs_assignments, probs_assignments_inv]))
# burned_assignment_trace.shape = (300, data.shape[0])
burned_assignment_trace = tfp.distributions.Categorical(
probs=cluster_probs).sample(sample_shape=300)
plt.figure(figsize(12.5, 5))
plt.cmap = mpl.colors.ListedColormap(colors)
output = tf.stack([
tf.gather(burned_assignment_trace[i, ...], tf.argsort(data))
for i in tf.range(burned_assignment_trace.shape[0])
])
plt.imshow(output.numpy(), cmap=plt.cmap, aspect=.4, alpha=.9)
plt.xticks(
tf.range(0, data.shape[0], 40).numpy(),
["%.2f" % s for s in tf.sort(data)[::40]])
plt.ylabel('posterior sample')
plt.xlabel('value of $i$th data point')
plt.title('Posterior labels of data points')
plt.show()
plt.figure(figsize(12.5, 5))
assign_trace = tf.gather(probs_assignments, tf.argsort(data))
plt.scatter(tf.gather(data, tf.argsort(data)).numpy(),
assign_trace.numpy(),
cmap=mpl.colors.LinearSegmentedColormap.from_list(
'BMH', colors),
c=(1 - assign_trace).numpy(),
s=50)
plt.ylim(-.05, 1.05)
plt.title('Probability of data point belonging to cluster 0')
plt.ylabel('probability')
plt.xlabel('value of data point')
plt.show()
x = tf.linspace(20., 300., 500.)
mu_mean = tf.math.reduce_mean(mus_extended, axis=-1)
sigma_mean = tf.math.reduce_mean(sigmas_extended, axis=-1)
prob_mean = tf.math.reduce_mean(model1_probs_extended, axis=-1)
plt.hist(data.numpy(),
bins=20,
histtype='step',
density=True,
color='k',
lw=2,
label='histogram of data')
y = prob_mean * tfp.distributions.Normal(loc=mu_mean[0],
scale=sigma_mean[0]).prob(x)
plt.plot(x.numpy(),
y.numpy(),
label='Cluster 0 (using posterior-mean parameters)',
lw=3)
plt.fill_between(x.numpy(), y.numpy(), color=colors[1], alpha=0.3)
y = (1 - prob_mean) * tfp.distributions.Normal(loc=mu_mean[1],
scale=sigma_mean[1]).prob(x)
plt.plot(x.numpy(),
y.numpy(),
label='Cluster 1 (using posterior-mean parameters)',
lw=3)
plt.fill_between(x.numpy(), y.numpy(), color=colors[0], alpha=0.3)
plt.legend(loc='upper left')
plt.title('Visualizing Clusters using psterior-mean parameters')
plt.show()
def lat_long_grid(shape, epsilon=1.0e-12):
return tf.meshgrid(
tf.linspace(-np.pi + np.pi / shape[1], np.pi - np.pi / shape[1],
shape[1]),
tf.linspace(-np.pi / 2.0 + np.pi / (2 * shape[0]),
np.pi / 2.0 - np.pi / (2 * shape[0]), shape[0]))
def linspace(*args, **kwargs):
a = _tf.linspace(*args, **kwargs)
if a.dtype is float64:
a = cast(a, dtype=float32)
return a
def __init__(self,
sess,
num_actions,
num_atoms=51,
vmax=10.,
gamma=0.99,
update_horizon=1,
min_replay_history=20000,
update_period=4,
target_update_period=8000,
epsilon_fn=dqn_agent.linearly_decaying_epsilon,
epsilon_train=0.01,
epsilon_eval=0.001,
epsilon_decay_period=250000,
replay_scheme='prioritized',
tf_device='/cpu:*',
use_staging=True,
optimizer=tf.train.AdamOptimizer(learning_rate=0.00025,
epsilon=0.0003125),
summary_writer=None,
summary_writing_frequency=500,
hsv_color=False):
print('--------in RainbowRGBAgent------')
print('min_replay_history = ', min_replay_history)
# tf.logging.info('Creating %s agent with the following parameters:',
# self.__class__.__name__)
# tf.logging.info('\t gamma: %f', gamma)
# tf.logging.info('\t update_horizon: %f', update_horizon)
# tf.logging.info('\t min_replay_history: %d', min_replay_history)
# tf.logging.info('\t update_period: %d', update_period)
# tf.logging.info('\t target_update_period: %d', target_update_period)
# tf.logging.info('\t epsilon_train: %f', epsilon_train)
# tf.logging.info('\t epsilon_eval: %f', epsilon_eval)
# tf.logging.info('\t epsilon_decay_period: %d', epsilon_decay_period)
# tf.logging.info('\t tf_device: %s', tf_device)
# tf.logging.info('\t use_staging: %s', use_staging)
# tf.logging.info('\t optimizer: %s', optimizer)
# We need this because some tools convert round floats into ints.
vmax = float(vmax)
self._num_atoms = num_atoms
self._support = tf.linspace(-vmax, vmax, num_atoms)
self._replay_scheme = replay_scheme
# TODO(b/110897128): Make agent optimizer attribute private.
self.optimizer = optimizer
self.num_actions = num_actions
self.gamma = gamma
self.update_horizon = update_horizon
self.cumulative_gamma = math.pow(gamma, update_horizon)
self.min_replay_history = min_replay_history
self.target_update_period = target_update_period
self.epsilon_fn = epsilon_fn
self.epsilon_train = epsilon_train
self.epsilon_eval = epsilon_eval
self.epsilon_decay_period = epsilon_decay_period
self.update_period = update_period
self.eval_mode = False
self.training_steps = 0
self.optimizer = optimizer
self.summary_writer = summary_writer
self.summary_writing_frequency = summary_writing_frequency
self.hsv_color = hsv_color
with tf.device(tf_device):
state_shape = [
1, dqn_agent.OBSERVATION_SHAPE[0],
dqn_agent.OBSERVATION_SHAPE[1], dqn_agent.OBSERVATION_SHAPE[2],
dqn_agent.OBSERVATION_SHAPE[3] * dqn_agent.STACK_SIZE
]
self.state = np.zeros(state_shape)
self.state_ph = tf.placeholder(tf.uint8,
state_shape,
name='state_ph')
self._replay = self._build_replay_buffer(use_staging)
self._build_networks()
self._train_op = self._build_train_op()
self._sync_qt_ops = self._build_sync_op()
print('self.state_ph= ', self.state_ph)
if self.summary_writer is not None:
# All tf.summaries should have been defined prior to running this.
self._merged_summaries = tf.summary.merge_all()
self._sess = sess
self._saver = tf.train.Saver(max_to_keep=3)
# Variables to be initialized by the agent once it interacts with the
# environment.
self._observation = None
self._last_observation = None
def theta_y_grid(shape):
return tf.meshgrid(tf.linspace(-np.pi, np.pi, shape[1]),
tf.linspace(-1., 1., shape[0]))
def uv_grid(shape):
return tf.meshgrid(
tf.linspace(-1. + 1. / shape[1], 1. - 1. / shape[1], shape[1]),
tf.linspace(-1. + 1. / shape[0], 1. - 1. / shape[0], shape[0]))
def main(n):
cache = "set-systems/%d-%d.npy" % (n, n)
slices_np = np.load(open(cache, "rb"))
slices_np = slices_np.reshape((-1, n * n))
print(slices_np.shape)
slices = tf.constant(slices_np, dtype=tf.float32)
def constraint(x):
# x /= tf.reduce_sum(x)
x = tf.clip_by_value(x, 0., 1.)
return x
coeffs = tf.Variable(np.ones(10), dtype=tf.float32)
parametric = False
if parametric:
xvar = tf.expand_dims(tf.linspace(-1., 1., n), 0)
yvar = tf.expand_dims(tf.linspace(-1., 1., n), 1)
# these are our building blocks:
X1 = tf.abs(xvar)
X2 = xvar * xvar
Y1 = tf.abs(yvar)
Y2 = yvar * yvar
D1 = X1 + Y1
D2 = X2 + Y2
Dinf = tf.maximum(X1, Y1)
c0, c1, c2, c3, c4, c5, c6, c7, c8, c9 = coeffs[0], coeffs[1], coeffs[
2], coeffs[3], coeffs[4], coeffs[5], coeffs[6], coeffs[7], coeffs[
8], coeffs[9]
V = D1
# for n=20: poly(Dinf) ~ 13.01, poly(D1) ~ 13.23, poly(D2) ~ 13.43.
lag = c0 + c1 * V + c2 * V * V + c3 * V * V * V + c4 * V * V * V * V
lag = c0 + c1 * X2 + c2 * Y2 + c3 * X2 * Y2
# lag = c0 + c1 * R2 + c2 * R2 * R2 + c3 * R2 * R2 * R2 + c4 * R2 * R2 * R2 * R2
lag = c0 + c1 * X2 + c2 * Y2 + c3 * X2 * Y2 + c4 * X2 * X2 + c5 * Y2 * Y2 + c6 * X2 * X2 * Y2 + c7 * X2 * Y2 * Y2 + c8 * X2 * X2 * Y2 * Y2
# lag = c0 + c1 * X2 + c1 * Y2 + c3 * X2 * Y2
# lag = c0 * 0 + X2 + Y2 - 2 * X2 * Y2
lag = c0 + c1 * X1 + c2 * Y1 + c3 * X1 * Y1 + c4 * X1 * X1 + c5 * Y1 * Y1 + c6 * X1 * X1 * Y1 + c7 * X1 * Y1 * Y1 + c8 * X1 * X1 * Y1 * Y1
# lag = c0 + c1 * Dinf + c2 * tf.sqrt(D2) + c3 * D1 + c4 * X2 + c5 * Y2 + c6 * X2 * Y2
lag = tf.reshape(lag, [-1])
else:
# this is the nonparametric solution:
lag = tf.Variable(np.ones(n * n),
dtype=tf.float32,
constraint=constraint)
target = tf.reduce_max(tf.tensordot(slices, lag, axes=1)) / tf.reduce_sum(
tf.nn.relu(lag))
global_step = tf.Variable(0, trainable=False)
starter_learning_rate = 0.001
learning_rate = tf.compat.v1.train.exponential_decay(starter_learning_rate,
global_step,
10000,
0.6,
staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_step = optimizer.minimize(target, global_step=global_step)
with tf.Session() as sess:
init = tf.initialize_all_variables()
sess.run(init)
for i in range(100000):
sess.run(train_step)
if i % 1000 == 0:
target_val, lag_val = sess.run([target, lag])
print(i, 1.0 / target_val, lag_val.min(), lag_val.max(),
lag_val.sum())
best_lag = sess.run(lag).reshape((n, n))
np.save(open("lagrangian-tensorflow.%d-%d.npy" % shape, "wb"),
best_lag)
best_coeffs = sess.run(coeffs)
print("best_coeffs", best_coeffs)
plt.imshow(best_lag)
plt.show()
import matplotlib.pyplot as plt
def func(x):
"""
:param x: [b, 2]
:return:
"""
z = tf.math.sin(x[..., 0]) + tf.math.sin(x[..., 1])
return z
x = tf.linspace(0., 2 * 3.14, 500)
y = tf.linspace(0., 2 * 3.14, 500)
# [50, 50]
point_x, point_y = tf.meshgrid(x, y)
# [50, 50, 2]
points = tf.stack([point_x, point_y], axis=2)
# points = tf.reshape(points, [-1, 2])
print('points:', points.shape)
z = func(points)
print('z:', z.shape)
plt.figure('plot 2d func value')
plt.imshow(z, origin='lower', interpolation='none')
plt.colorbar()
plt.figure('plot 2d func contour')
def inference(images,
cams,
depth_num,
depth_start,
depth_interval,
network_mode,
is_master_gpu=True,
trainable=True,
inverse_depth=False):
""" infer depth image from multi-view images and cameras """
# dynamic gpu params
depth_end = depth_start + \
(tf.cast(depth_num, tf.float32) - 1) * depth_interval
# reference image
ref_image = tf.squeeze(tf.slice(images, [0, 0, 0, 0, 0],
[-1, 1, -1, -1, 3]),
axis=1)
ref_cam = tf.squeeze(tf.slice(cams, [0, 0, 0, 0, 0], [-1, 1, 2, 4, 4]),
axis=1)
# image feature extraction
reuse = not is_master_gpu
ref_tower = UNetDS2GN({'data': ref_image},
trainable=trainable,
mode=network_mode,
reuse=reuse)
view_towers = []
for view in range(1, FLAGS.view_num):
view_image = tf.squeeze(tf.slice(images, [0, view, 0, 0, 0],
[-1, 1, -1, -1, -1]),
axis=1)
view_tower = UNetDS2GN({'data': view_image},
trainable=trainable,
mode=network_mode,
reuse=True)
view_towers.append(view_tower)
"""
cam_residuals = []
for view in range(1, FLAGS.view_num):
view_cam = tf.squeeze(
tf.slice(cams, [0, view, 0, 0, 0], [-1, 1, 2, 4, 4]), axis=1)
view_image = tf.squeeze(
tf.slice(images, [0, view, 0, 0, 0], [-1, 1, -1, -1, -1]), axis=1)
cam_residual = OdometryNet(view_image, ref_image, view_cam)
cam_residuals.append(view_image, ref_image)
how should we encode the view_cam into the camera network? I could do an encoding similar
to the one used in the gqn, where you basically concatenate the images and have a few layers
with convolution and downsampling which then outputs multiple channels that are the size of
a camera pose matrix, and you concatenate those layers with the view_cam pose estimate and
then have a few densely connected layers to regress a final pose residual. Another option is to rectify the images
with the estimate and then regress the residual. If there is a clean way to do this then I think this is the best option. I might be able to do the
rectification using a homograph at a fixed depth, say 1.0 meters out.
"""
# get all homographies
view_homographies = []
for view in range(1, FLAGS.view_num):
view_cam = tf.squeeze(tf.slice(cams, [0, view, 0, 0, 0],
[-1, 1, 2, 4, 4]),
axis=1)
if inverse_depth:
homographies = get_homographies_inv_depth(ref_cam,
view_cam,
depth_num=depth_num,
depth_start=depth_start,
depth_end=depth_end)
else:
homographies = get_homographies(ref_cam,
view_cam,
depth_num=depth_num,
depth_start=depth_start,
depth_interval=depth_interval)
view_homographies.append(homographies)
# build cost volume by differentialble homography
with tf.name_scope('cost_volume_homography'):
depth_costs = []
for d in range(depth_num):
# compute cost (variation metric)
ave_feature = ref_tower.get_output()
ave_feature2 = tf.square(ref_tower.get_output())
for view in range(0, FLAGS.view_num - 1):
homography = tf.slice(view_homographies[view],
begin=[0, d, 0, 0],
size=[-1, 1, 3, 3])
homography = tf.squeeze(homography, axis=1)
# warped_view_feature = homography_warping(view_towers[view].get_output(), homography)
warped_view_feature = tf_transform_homography(
view_towers[view].get_output(), homography)
ave_feature = ave_feature + warped_view_feature
ave_feature2 = ave_feature2 + tf.square(warped_view_feature)
ave_feature = ave_feature / FLAGS.view_num
ave_feature2 = ave_feature2 / FLAGS.view_num
cost = ave_feature2 - tf.square(ave_feature)
depth_costs.append(cost)
cost_volume = tf.stack(depth_costs, axis=1)
# filtered cost volume, size of (B, D, H, W, 1)
filtered_cost_volume_tower = RegNetUS0({'data': cost_volume},
trainable=trainable,
mode=network_mode,
reuse=reuse)
filtered_cost_volume = tf.squeeze(filtered_cost_volume_tower.get_output(),
axis=-1)
# depth map by softArgmin
with tf.name_scope('soft_arg_min'):
# probability volume by soft max
probability_volume = tf.nn.softmax(tf.scalar_mul(
-1, filtered_cost_volume),
axis=1,
name='prob_volume')
# depth image by soft argmin
volume_shape = tf.shape(probability_volume)
soft_2d = []
for i in range(FLAGS.batch_size):
if inverse_depth:
inv_depth_start = tf.reshape(tf.div(1.0, depth_start[i]), [])
inv_depth_end = tf.reshape(tf.div(1.0, depth_end[i]), [])
inv_depth = tf.lin_space(inv_depth_start, inv_depth_end,
tf.cast(depth_num, tf.int32))
soft_1d = tf.div(1.0, inv_depth)
else:
soft_1d = tf.linspace(depth_start[i], depth_end[i],
tf.cast(depth_num, tf.int32))
soft_2d.append(soft_1d)
soft_2d = tf.reshape(tf.stack(soft_2d, axis=0),
[volume_shape[0], volume_shape[1], 1, 1])
soft_4d = tf.tile(soft_2d, [1, 1, volume_shape[2], volume_shape[3]])
estimated_depth_map = tf.reduce_sum(soft_4d * probability_volume,
axis=1)
estimated_depth_map = tf.expand_dims(estimated_depth_map, axis=3)
# probability map
prob_map = get_probability_map(probability_volume,
estimated_depth_map,
depth_start,
depth_interval,
inverse_depth=inverse_depth)
return estimated_depth_map, prob_map #, filtered_depth_map, probability_volume
def __init__(self,
sess,
num_actions,
num_atoms=51,
vmax=10.,
gamma=0.99,
update_horizon=1,
min_replay_history=20000,
update_period=4,
target_update_period=8000,
epsilon_fn=dqn_agent.linearly_decaying_epsilon,
epsilon_train=0.01,
epsilon_eval=0.001,
epsilon_decay_period=250000,
replay_scheme='prioritized',
tf_device='/cpu:*',
use_staging=True,
optimizer=tf.train.AdamOptimizer(learning_rate=0.00025,
epsilon=0.0003125),
summary_writer=None,
summary_writing_frequency=500):
"""Initializes the agent and constructs the components of its graph.
Args:
sess: `tf.Session`, for executing ops.
num_actions: int, number of actions the agent can take at any state.
num_atoms: int, the number of buckets of the value function distribution.
vmax: float, the value distribution support is [-vmax, vmax].
gamma: float, discount factor with the usual RL meaning.
update_horizon: int, horizon at which updates are performed, the 'n' in
n-step update.
min_replay_history: int, number of transitions that should be experienced
before the agent begins training its value function.
update_period: int, period between DQN updates.
target_update_period: int, update period for the target network.
epsilon_fn: function expecting 4 parameters:
(decay_period, step, warmup_steps, epsilon). This function should return
the epsilon value used for exploration during training.
epsilon_train: float, the value to which the agent's epsilon is eventually
decayed during training.
epsilon_eval: float, epsilon used when evaluating the agent.
epsilon_decay_period: int, length of the epsilon decay schedule.
replay_scheme: str, 'prioritized' or 'uniform', the sampling scheme of the
replay memory.
tf_device: str, Tensorflow device on which the agent's graph is executed.
use_staging: bool, when True use a staging area to prefetch the next
training batch, speeding training up by about 30%.
optimizer: `tf.train.Optimizer`, for training the value function.
summary_writer: SummaryWriter object for outputting training statistics.
Summary writing disabled if set to None.
summary_writing_frequency: int, frequency with which summaries will be
written. Lower values will result in slower training.
"""
# We need this because some tools convert round floats into ints.
vmax = float(vmax)
self._num_atoms = num_atoms
self._support = tf.linspace(-vmax, vmax, num_atoms)
self._replay_scheme = replay_scheme
# TODO(b/110897128): Make agent optimizer attribute private.
self.optimizer = optimizer
super(RainbowAgent, self).__init__(
sess=sess,
num_actions=num_actions,
gamma=gamma,
update_horizon=update_horizon,
min_replay_history=min_replay_history,
update_period=update_period,
target_update_period=target_update_period,
epsilon_fn=epsilon_fn,
epsilon_train=epsilon_train,
epsilon_eval=epsilon_eval,
epsilon_decay_period=epsilon_decay_period,
tf_device=tf_device,
use_staging=use_staging,
optimizer=self.optimizer,
summary_writer=summary_writer,
summary_writing_frequency=summary_writing_frequency)
import tensorflow as tf
a = tf.linspace(-10., 10., 10)
with tf.GradientTape() as tape:
tape.watch(a)
y = tf.sigmoid(a)
grads = tape.gradient(y, [a])
print('x:', a.numpy())
print('y:', y.numpy())
print('grad:', grads[0].numpy())
def __init__(
self,
time_step_spec,
action_spec,
categorical_q_network,
optimizer,
min_q_value=-10.0,
max_q_value=10.0,
epsilon_greedy=0.1,
n_step_update=1,
boltzmann_temperature=None,
# Params for target network updates
target_update_tau=1.0,
target_update_period=1,
# Params for training.
td_errors_loss_fn=None,
gamma=1.0,
reward_scale_factor=1.0,
gradient_clipping=None,
# Params for debugging
debug_summaries=False,
summarize_grads_and_vars=False,
train_step_counter=None,
name=None):
"""Creates a Categorical DQN Agent.
Args:
time_step_spec: A `TimeStep` spec of the expected time_steps.
action_spec: A `BoundedTensorSpec` representing the actions.
categorical_q_network: A categorical_q_network.CategoricalQNetwork that
returns the q_distribution for each action.
optimizer: The optimizer to use for training.
min_q_value: A float specifying the minimum Q-value, used for setting up
the support.
max_q_value: A float specifying the maximum Q-value, used for setting up
the support.
epsilon_greedy: probability of choosing a random action in the default
epsilon-greedy collect policy (used only if a wrapper is not provided to
the collect_policy method).
n_step_update: The number of steps to consider when computing TD error and
TD loss. Defaults to single-step updates. Note that this requires the
user to call train on Trajectory objects with a time dimension of
`n_step_update + 1`. However, note that we do not yet support
`n_step_update > 1` in the case of RNNs (i.e., non-empty
`q_network.state_spec`).
boltzmann_temperature: Temperature value to use for Boltzmann sampling of
the actions during data collection. The closer to 0.0, the higher the
probability of choosing the best action.
target_update_tau: Factor for soft update of the target networks.
target_update_period: Period for soft update of the target networks.
td_errors_loss_fn: A function for computing the TD errors loss. If None, a
default value of huber_loss is used. This function takes as input the
target and the estimated Q values and returns the loss for each element
of the batch.
gamma: A discount factor for future rewards.
reward_scale_factor: Multiplicative scale for the reward.
gradient_clipping: Norm length to clip gradients.
debug_summaries: A bool to gather debug summaries.
summarize_grads_and_vars: If True, gradient and network variable summaries
will be written during training.
train_step_counter: An optional counter to increment every time the train
op is run. Defaults to the global_step.
name: The name of this agent. All variables in this module will fall
under that name. Defaults to the class name.
Raises:
TypeError: If the action spec contains more than one action.
"""
num_atoms = getattr(categorical_q_network, 'num_atoms', None)
if num_atoms is None:
raise TypeError(
'Expected categorical_q_network to have property '
'`num_atoms`, but it doesn\'t (note: you likely want to '
'use a CategoricalQNetwork). Network is: %s' %
(categorical_q_network, ))
self._num_atoms = num_atoms
self._min_q_value = min_q_value
self._max_q_value = max_q_value
self._support = tf.linspace(min_q_value, max_q_value, num_atoms)
super(CategoricalDqnAgent,
self).__init__(time_step_spec,
action_spec,
categorical_q_network,
optimizer,
epsilon_greedy=epsilon_greedy,
n_step_update=n_step_update,
boltzmann_temperature=boltzmann_temperature,
target_update_tau=target_update_tau,
target_update_period=target_update_period,
td_errors_loss_fn=td_errors_loss_fn,
gamma=gamma,
reward_scale_factor=reward_scale_factor,
gradient_clipping=gradient_clipping,
debug_summaries=debug_summaries,
summarize_grads_and_vars=summarize_grads_and_vars,
train_step_counter=train_step_counter,
name=name)
policy = categorical_q_policy.CategoricalQPolicy(
min_q_value, max_q_value, self._q_network, self._action_spec)
if boltzmann_temperature is not None:
self._collect_policy = boltzmann_policy.BoltzmannPolicy(
policy, temperature=self._boltzmann_temperature)
else:
self._collect_policy = epsilon_greedy_policy.EpsilonGreedyPolicy(
policy, epsilon=self._epsilon_greedy)
self._policy = greedy_policy.GreedyPolicy(policy)
#scatter 有目的性的根据坐标对值进行更新
'''
tf.scatter_nd(
indices, 根据坐标改变对应底板上的值
updates,
shape shape给定底板，一维二维多维，所有值默认为0
'''
indices = tf.constant([[4], [3], [1], [7]])
updates = tf.constant([9, 10, 11, 12])
#底板上下标4的位置更新为9，下标3的位置更新为10，下标1的位置更新为11，下标7的位置更新为12
shape = tf.contant([8]) #底板是一维，值全为0、长度为8的tensor
tf.scatter_nd(indices, updates, shape)
#返回[0,11,0,10,9,0,0,12]
#tf.scatter_nd只能更新底板为0的值
#scatter使用复杂，详情看课时47、48
#meshgrid 应用在48课时，不好笔述，记得复习
'''
给定x和y的范围，生成[x1,y1],[x2,y2],[x3,y3]...等范围内的坐标
'''
y = tf.linspace(-2., 2., 5) #生成-2.到2.的五个值,均匀分布
x = tf.linspace(-2., 2., 5)
point_x, point_y = tf.meshgrid(x, y)
point_x.shape #[5,5],共25个值，每一列上的值都相等
point_y.shape #[5,5],共25个值，每一行上的值都相等
points = tf.stack([point_x, point_y], axis=2)
#合并point_x和point_y，组成坐标轴，增加一个维度
points.shape #[5,5,2]5行5列，2个通道，也就是x、y组合成一个坐标点
print(zero_tensor) ones_tensor = tf.ones([1, 1]) print(ones_tensor) fill_tensor = tf.fill([4, 4], 16) print(fill_tensor) first_constant = tf.constant([[1, 2, 3], [3, 4, 5]]) print(first_constant) mess_constant = tf.constant(['Kaiser']) print(mess_constant) lins_tensor = tf.linspace(0., 9., 6) print(lins_tensor) range_tensor = tf.range(3., 6., 0.5) print(range_tensor) mat = tf.constant([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]) slic = tf.slice(mat, [1, 1], [2, 2]) print(slic) mat = tf.constant([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]) rev = tf.reverse(mat, [0]) print(rev) x = tf.constant([1., 2., 3.])
def regDLF(y_true,
y_pred,
alpha=1,
beta=1,
gamma=0.01,
delta_v=0.5,
delta_d=1.5,
name='loss_discrim'):
def tf_norm(inputs, axis=1, epsilon=1e-7, name='safe_norm'):
squared_norm = tf.reduce_sum(tf.square(inputs),
axis=axis,
keep_dims=True)
safe_norm = tf.sqrt(squared_norm + epsilon)
return tf.identity(safe_norm, name=name)
###
lins = tf.linspace(0.0,
DIMZ * DIMY * DIMX,
DIMZ * DIMY * DIMX,
name='lins')
lins = lins / tf.reduce_max(lins) * 255
lins = cvt2tanh(lins)
lins = tf.reshape(lins, tf.shape(y_true), name='lins_3d')
print lins
y_true = tf.reshape(y_true, [DIMZ * DIMY * DIMX])
y_pred = tf.concat([y_pred, lins], axis=-1)
nDim = tf.shape(y_pred)[-1]
X = tf.reshape(y_pred, [DIMZ * DIMY * DIMX, nDim])
uniqueLabels, uniqueInd = tf.unique(y_true)
numUnique = tf.size(
uniqueLabels) # Get the number of connected component
Sigma = tf.unsorted_segment_sum(X, uniqueInd, numUnique)
# ones_Sigma = tf.ones((tf.shape(X)[0], 1))
ones_Sigma = tf.ones_like(X)
ones_Sigma = tf.unsorted_segment_sum(ones_Sigma, uniqueInd,
numUnique)
mu = tf.divide(Sigma, ones_Sigma)
Lreg = tf.reduce_mean(tf.norm(mu, axis=1, ord=1))
T = tf.norm(tf.subtract(tf.gather(mu, uniqueInd), X),
axis=1,
ord=1)
T = tf.divide(T, Lreg)
T = tf.subtract(T, delta_v)
T = tf.clip_by_value(T, 0, T)
T = tf.square(T)
ones_Sigma = tf.ones_like(uniqueInd, dtype=tf.float32)
ones_Sigma = tf.unsorted_segment_sum(ones_Sigma, uniqueInd,
numUnique)
clusterSigma = tf.unsorted_segment_sum(T, uniqueInd, numUnique)
clusterSigma = tf.divide(clusterSigma, ones_Sigma)
# Lvar = tf.reduce_mean(clusterSigma, axis=0)
Lvar = tf.reduce_mean(clusterSigma)
mu_interleaved_rep = tf.tile(mu, [numUnique, 1])
mu_band_rep = tf.tile(mu, [1, numUnique])
mu_band_rep = tf.reshape(mu_band_rep,
(numUnique * numUnique, nDim))
mu_diff = tf.subtract(mu_band_rep, mu_interleaved_rep)
# Remove zero vector
# intermediate_tensor = reduce_sum(tf.abs(x), 1)
# zero_vector = tf.zeros(shape=(1,1), dtype=tf.float32)
# bool_mask = tf.not_equal(intermediate_tensor, zero_vector)
# omit_zeros = tf.boolean_mask(x, bool_mask)
intermediate_tensor = tf.reduce_sum(tf.abs(mu_diff), 1)
zero_vector = tf.zeros(shape=(1, 1), dtype=tf.float32)
bool_mask = tf.not_equal(intermediate_tensor, zero_vector)
omit_zeros = tf.boolean_mask(mu_diff, bool_mask)
mu_diff = tf.expand_dims(omit_zeros, axis=1)
print mu_diff
mu_diff = tf.norm(mu_diff, ord=1)
# squared_norm = tf.reduce_sum(tf.square(s), axis=axis,keep_dims=True)
# safe_norm = tf.sqrt(squared_norm + epsilon)
# squared_norm = tf.reduce_sum(tf.square(omit_zeros), axis=-1,keep_dims=True)
# safe_norm = tf.sqrt(squared_norm + 1e-6)
# mu_diff = safe_norm
mu_diff = tf.divide(mu_diff, Lreg)
mu_diff = tf.subtract(2 * delta_d, mu_diff)
mu_diff = tf.clip_by_value(mu_diff, 0, mu_diff)
mu_diff = tf.square(mu_diff)
numUniqueF = tf.cast(numUnique, tf.float32)
Ldist = tf.reduce_mean(mu_diff)
# L = alpha * Lvar + beta * Ldist + gamma * Lreg
# L = tf.reduce_mean(L, keep_dims=True)
L = tf.reduce_sum([alpha * Lvar, beta * Ldist, gamma * Lreg],
keep_dims=False)
print L
print Ldist
print Lvar
print Lreg
return tf.identity(L, name=name)
my_filter = tf.constant(0.25,shape=[2,2,1,1])
my_strides = [1,2,2,1]
mov_avg_layer = tf.nn.conv2d(x_data,my_filter,my_strides,padding="SAME",name="Moving_Avg_Window")
def custom_layer(input_matrix):
input_matrix_squeezed = tf.squeeze(input_matrix)
A = tf.constant([[1.,2.],[-1.,3.]])
b = tf.constant(1.,shape=[2,2])
temp1 = tf.matmul(A,input_matrix_squeezed)
temp = tf.add(temp1,b) # Ax+b
return (tf.sigmoid(temp))
with tf.name_scope('Custom_Layer') as scope:
custom_layer1 = custom_layer(mov_avg_layer)
print(sess.run(custom_layer1,feed_dict={x_data:x_val}))
import matplotlib.pyplot as plt
x_vals = tf.linspace(-1.,1.,500)
target = tf.constant(0.0)
l2_y_vals = tf.square(target-x_vals)
l2_y_out = sess.run(l2_y_vals)
l1_y_vals = tf.abs(target-x_vals)
l1_y_out = sess.run(l1_y_vals)
x_array = sess.run(x_vals)
plt.plot(x_array,l2_y_out,'b-',label='L2 Loss')
plt.plot(x_array,l1_y_out,'g:',label='L1 Loss')
plt.ylim(-0.2,0.4)
plt.legend(loc="lower right",prop={'size':11})
plt.show()
delta1 = tf.constant(0.25)
def affine_grid_generator(height, width, theta):
"""
This function returns a sampling grid, which when
used with the bilinear sampler on the input feature
map, will create an output feature map that is an
affine transformation [1] of the input feature map.
Input
-----
- height: desired height of grid/output. Used
to downsample or upsample.
- width: desired width of grid/output. Used
to downsample or upsample.
- theta: affine transform matrices of shape (num_batch, 2, 3).
For each image in the batch, we have 6 theta parameters of
the form (2x3) that define the affine transformation T.
Returns
-------
- normalized grid (-1, 1) of shape (num_batch, 2, H, W).
The 2nd dimension has 2 components: (x, y) which are the
sampling points of the original image for each point in the
target image.
Note
----
[1]: the affine transformation allows cropping, translation,
and isotropic scaling.
"""
num_batch = tf.shape(theta)[0]
# create normalized 2D grid
x = tf.linspace(-1.0, 1.0, width)
y = tf.linspace(-1.0, 1.0, height)
x_t, y_t = tf.meshgrid(x, y)
# flatten
x_t_flat = tf.reshape(x_t, [-1])
y_t_flat = tf.reshape(y_t, [-1])
# reshape to [x_t, y_t , 1] - (homogeneous form)
ones = tf.ones_like(x_t_flat)
sampling_grid = tf.stack([x_t_flat, y_t_flat, ones])
# repeat grid num_batch times
sampling_grid = tf.expand_dims(sampling_grid, axis=0)
sampling_grid = tf.tile(sampling_grid, tf.stack([num_batch, 1, 1]))
# cast to float32 (required for matmul)
theta = tf.cast(theta, 'float32')
sampling_grid = tf.cast(sampling_grid, 'float32')
# transform the sampling grid - batch multiply
batch_grids = tf.matmul(theta, sampling_grid)
# batch grid has shape (num_batch, 2, H*W)
# reshape to (num_batch, H, W, 2)
batch_grids = tf.reshape(batch_grids, [num_batch, 2, height, width])
return batch_grids
X_train, X_test = X_train / 255.0, X_test / 255.0
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
#one-hot
Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES)
Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)
# Training the model for each combination of the hyperparameters.
#A unique number for each training session
session_num = 0
#Nested for loop training with all possible combinathon of hyperparameters
for num_units in HP_NUM_UNITS.domain.values:
for dropout_rate in tf.linspace(HP_DROPOUT.domain.min_value,
HP_DROPOUT.domain.max_value, 3):
for optimizer in HP_OPTIMIZER.domain.values:
for batchsize in HP_BATCHSIZE.domain.values:
hparams = {
HP_NUM_UNITS: num_units,
HP_DROPOUT: float(
"%.2f" % float(dropout_rate)
), # float("%.2f"%float(dropout_rate)) limits the decimal palces to 2
HP_OPTIMIZER: optimizer,
HP_BATCHSIZE: batchsize,
}
run_name = "run-%d" % session_num
print('--- Starting trial: %s' % run_name)
print({h.name: hparams[h] for h in hparams})
run('logs/hparam_tuning/' + run_name, hparams)
session_num += 1
def sin_phase(mod_rate): phase = tf.sin(tf.linspace(0.0, mod_rate * n_seconds * 2.0 * np.pi, n_samples)) phase = (phase[tf.newaxis, :, tf.newaxis] + 1.0) / 2.0 # Scale to [0, 1.0] return phase
def inference_mem(images,
cams,
depth_num,
depth_start,
depth_interval,
network_mode,
is_master_gpu=True,
training=True,
trainable=True,
inverse_depth=False):
""" inference of depth image from multi-view images and cameras """
# dynamic gpu params
depth_end = depth_start + \
(tf.cast(depth_num, tf.float32) - 1) * depth_interval
feature_c = 32
feature_h = FLAGS.height / 4
feature_w = FLAGS.width / 4
# reference image
ref_image = tf.squeeze(tf.slice(images, [0, 0, 0, 0, 0],
[-1, 1, -1, -1, 3]),
axis=1)
ref_cam = tf.squeeze(tf.slice(cams, [0, 0, 0, 0, 0], [-1, 1, 2, 4, 4]),
axis=1)
# image feature extraction
reuse = tf.app.flags.FLAGS.reuse_vars #not is_master_gpu
ref_tower = UNetDS2GN({'data': ref_image},
trainable=trainable,
training=training,
mode=network_mode,
reuse=reuse)
base_divisor = ref_tower.base_divisor
feature_c /= base_divisor
ref_feature = ref_tower.get_output()
ref_feature2 = tf.square(ref_feature)
view_features = []
for view in range(1, FLAGS.view_num):
view_image = tf.squeeze(tf.slice(images, [0, view, 0, 0, 0],
[-1, 1, -1, -1, -1]),
axis=1)
view_tower = UNetDS2GN({'data': view_image},
trainable=trainable,
training=training,
mode=network_mode,
reuse=True)
view_features.append(view_tower.get_output())
view_features = tf.stack(view_features, axis=0)
# get all homographies
view_homographies = []
for view in range(1, FLAGS.view_num):
view_cam = tf.squeeze(tf.slice(cams, [0, view, 0, 0, 0],
[-1, 1, 2, 4, 4]),
axis=1)
if inverse_depth:
homographies = get_homographies_inv_depth(ref_cam,
view_cam,
depth_num=depth_num,
depth_start=depth_start,
depth_end=depth_end)
else:
homographies = get_homographies(ref_cam,
view_cam,
depth_num=depth_num,
depth_start=depth_start,
depth_interval=depth_interval)
view_homographies.append(homographies)
view_homographies = tf.stack(view_homographies, axis=0)
# build cost volume by differentialble homography
with tf.name_scope('cost_volume_homography'):
depth_costs = []
for d in range(depth_num):
# compute cost (standard deviation feature)
ave_feature = tf.Variable(
tf.zeros([FLAGS.batch_size, feature_h, feature_w, feature_c]),
name='ave',
trainable=False,
collections=[tf.GraphKeys.LOCAL_VARIABLES])
ave_feature2 = tf.Variable(
tf.zeros([FLAGS.batch_size, feature_h, feature_w, feature_c]),
name='ave2',
trainable=False,
collections=[tf.GraphKeys.LOCAL_VARIABLES])
ave_feature = tf.assign(ave_feature, ref_feature)
ave_feature2 = tf.assign(ave_feature2, ref_feature2)
def body(view, ave_feature, ave_feature2):
"""Loop body."""
homography = tf.slice(view_homographies[view],
begin=[0, d, 0, 0],
size=[-1, 1, 3, 3])
homography = tf.squeeze(homography, axis=1)
# warped_view_feature = homography_warping(view_features[view], homography)
warped_view_feature = tf_transform_homography(
view_features[view], homography)
ave_feature = tf.assign_add(ave_feature, warped_view_feature)
ave_feature2 = tf.assign_add(ave_feature2,
tf.square(warped_view_feature))
view = tf.add(view, 1)
return view, ave_feature, ave_feature2
view = tf.constant(0)
cond = lambda view, *_: tf.less(view, FLAGS.view_num - 1)
_, ave_feature, ave_feature2 = tf.while_loop(
cond,
body, [view, ave_feature, ave_feature2],
back_prop=False,
parallel_iterations=1)
ave_feature = tf.assign(
ave_feature,
tf.square(ave_feature) / (FLAGS.view_num * FLAGS.view_num))
ave_feature2 = tf.assign(
ave_feature2, ave_feature2 / FLAGS.view_num - ave_feature)
depth_costs.append(ave_feature2)
cost_volume = tf.stack(depth_costs, axis=1)
# filtered cost volume, size of (B, D, H, W, 1)
filtered_cost_volume_tower = RegNetUS0({'data': cost_volume},
trainable=trainable,
training=training,
mode=network_mode,
reuse=reuse)
filtered_cost_volume = tf.squeeze(filtered_cost_volume_tower.get_output(),
axis=-1)
# depth map by softArgmin
with tf.name_scope('soft_arg_min'):
# probability volume by soft max
probability_volume = tf.nn.softmax(tf.scalar_mul(
-1, filtered_cost_volume),
axis=1,
name='prob_volume')
# depth image by soft argmin
volume_shape = tf.shape(probability_volume)
soft_2d = []
for i in range(FLAGS.batch_size):
if inverse_depth:
inv_depth_start = tf.reshape(tf.div(1.0, depth_start[i]), [])
inv_depth_end = tf.reshape(tf.div(1.0, depth_end[i]), [])
inv_depth = tf.lin_space(inv_depth_start, inv_depth_end,
tf.cast(depth_num, tf.int32))
soft_1d = tf.div(1.0, inv_depth)
else:
soft_1d = tf.linspace(depth_start[i], depth_end[i],
tf.cast(depth_num, tf.int32))
soft_2d.append(soft_1d)
soft_2d = tf.reshape(tf.stack(soft_2d, axis=0),
[volume_shape[0], volume_shape[1], 1, 1])
soft_4d = tf.tile(soft_2d, [1, 1, volume_shape[2], volume_shape[3]])
estimated_depth_map = tf.reduce_sum(soft_4d * probability_volume,
axis=1)
estimated_depth_map = tf.expand_dims(estimated_depth_map, axis=3)
# probability map
prob_map = get_probability_map(probability_volume,
estimated_depth_map,
depth_start,
depth_interval,
inverse_depth=inverse_depth)
# return filtered_depth_map,
return estimated_depth_map, prob_map
print(sess.run(constant_tsr))
# 2. 相似形状的张量
zeros_similar = tf.zeros_like(constant_tsr)
print(zeros_similar)
print(sess.run(zeros_similar))
ones_similar = tf.ones_like(constant_tsr)
print(ones_similar)
print(sess.run(ones_similar))
# 3. 序列张量
# Linspace in TensorFlow
linear_tsr = tf.linspace(start=0.0, stop=1.0,
num=3) # 生成 [0.0, 0.5, 1.0] ，包含stop
print(linear_tsr)
print(sess.run(linear_tsr))
print('-----------------------------')
# Range in TensorFlow
sequence_var = tf.Variable(tf.range(start=6.0, limit=15.0,
delta=3.24)) # 生成 [6, 9, 12] ，不包含limit
sess.run(sequence_var.initializer)
print(sequence_var)
print(sess.run(sequence_var))
# sequence_var在这里是一个变量， 使用tf.Variable来将张量封装成一个变量
# 声明变量之后需要初始化才能使用
# 也可以使用下边的方式来声明
# initialize_op = tf.global_variables_initializer()
# sess.run(initialize_op)
def fft_frequencies(sample_rate, n_fft):
# Equal to librosa.core.fft_frequencies
begin = 0.0
end = tf.cast(sample_rate // 2, tf.float32)
step = 1 + n_fft // 2
return tf.linspace(begin, end, step)
def call(self, inputs, training=None, mask=None):
pixels, word_indices, pattern_indices, char_indices, memory_mask, parses = inputs
# pixels: (bs, h, w)
# word_indices: (bs, h, w)
# pattern_indices: (bs, h, w)
# char_indices: (bs, h, w)
# memory_mask: (bs, h, w, m, l, d)
# parses: (bs, h, w, 4, 2)
bs = tf.shape(pixels)[0]
h, w = InvoiceData.im_size[0], InvoiceData.im_size[1]
X, Y = tf.meshgrid(tf.linspace(0.0, 1.0, InvoiceData.im_size[1]), tf.linspace(0.0, 1.0, InvoiceData.im_size[0]))
X = tf.tile(X[None, ..., None], (bs, 1, 1, 1))
Y = tf.tile(Y[None, ..., None], (bs, 1, 1, 1))
word_embeddings = tf.reshape(
self.word_embed(tf.reshape(word_indices, (bs, -1))),
(bs, h, w, self.embed_size)
)
pattern_embeddings = tf.reshape(
self.pattern_embed(tf.reshape(pattern_indices, (bs, -1))),
(bs, h, w, self.embed_size)
)
char_embeddings = tf.reshape(
self.char_embed(tf.reshape(char_indices, (bs, -1))),
(bs, h, w, self.embed_size)
)
pixels = tf.reshape(pixels, (bs, h, w, 3))
parses = tf.reshape(parses, (bs, h, w, InvoiceData.n_memories * 2))
memory_mask = tf.reshape(memory_mask, (bs, h, w, 1))
x = tf.concat([pixels, word_embeddings, pattern_embeddings, char_embeddings, parses, X, Y, memory_mask],
axis=3)
x = self.conv_block(x)
x = self.dropout(x, training=training)
pre_att_logits = x
att_logits = self.conv_att(x) # (bs, h, w, n_memories)
att_logits = memory_mask * att_logits - (
1.0 - memory_mask) * 1000 # TODO only sum the memory_mask idx, in the softmax
logits = tf.reshape(att_logits, (bs, -1)) # (bs, h * w * n_memories)
logits -= tf.reduce_max(logits, axis=1, keepdims=True)
lp = tf.math.log_softmax(logits, axis=1) # (bs, h * w * n_memories)
p = tf.math.softmax(logits, axis=1) # (bs, h * w * n_memories)
spatial_attention = tf.reshape(p, (bs, h * w * InvoiceData.n_memories, 1, 1)) # (bs, h * w * n_memories, 1, 1)
p_uniform = memory_mask / tf.reduce_sum(memory_mask, axis=(1, 2, 3), keepdims=True)
cross_entropy_uniform = -tf.reduce_sum(p_uniform * tf.reshape(lp, (bs, h, w, InvoiceData.n_memories)),
axis=(1, 2, 3)) # (bs, 1)
cp = tf.reduce_sum(tf.reshape(p, (bs, h, w, InvoiceData.n_memories)), axis=3, keepdims=True)
context = tf.reduce_sum(cp * pre_att_logits, axis=(1, 2)) # (bs, 4*n_hidden)
self.add_loss(self.frac_ce_loss * tf.reduce_mean(cross_entropy_uniform))
return spatial_attention, context
import tensorflow as tf a = tf.linspace(0., 1., 10) a = tf.expand_dims(a, 0) b = tf.transpose(a) print(tf.matmul(a, b))
var2 = tf.Variable(tf.constant(2.3), dtype=tf.float32)
# var2=tf.Variable(tf.constant([2.0,3,4,5,6]),dtype=tf.float32)
mul = tf.multiply(var4, var3)
sess = tf.Session()
print(sess.run(mul))
# print (g.as_graph_element())
# '______________________________________________________________________________________
# martrix multiply
mat1 = tf.constant([7, 8, 9, 12, 34, 21], dtype=tf.float32, shape=[2, 3])
mat2 = tf.constant([1, 2, 3, 4, 5, 6], dtype=tf.float32,
shape=[3,
2]) # shape matter a lot for matrix multiplication
mat3 = tf.linspace(start=1.0, stop=10,
num=6) # to create you own list of constant
mul = tf.matmul(mat1, mat2)
new_dat = tf.range(10) # print range of value just like in python
shuffle = tf.random_shuffle(new_dat)
sess = tf.Session()
print(sess.run(mul))
print(sess.run(mat3))
print(sess.run(new_dat))
print(sess.run(shuffle))
# '______________________________________________________________________________________
# further function on martrix
identy = tf.eye(3) # create idendity matrix
b = tf.Variable(tf.random_uniform(
[5, 10], 0, 2,
