def compute_nats_and_bits_per_dim(data_dim, latent_dim, average_reconstruction,
average_prior):
"""Computes negative ELBO, which is an upper bound on the negative likelihood.
Args:
data_dim: int-like indicating data dimensionality.
latent_dim: int-like indicating latent dimensionality.
average_reconstruction: Scalar Tensor indicating the reconstruction cost
averaged over all data dimensions and any data batches.
average_prior: Scalar Tensor indicating the negative log-prior probability
averaged over all latent dimensions and any data batches.
Returns:
Tuple of scalar Tensors, representing the nats and bits per data dimension
(e.g., subpixels) respectively.
"""
with tf.name_scope(None, default_name="compute_nats_per_dim"):
data_dim = tf.cast(data_dim, average_reconstruction.dtype)
latent_dim = tf.cast(latent_dim, average_prior.dtype)
negative_log_likelihood = data_dim * average_reconstruction
negative_log_prior = latent_dim * average_prior
negative_elbo = negative_log_likelihood + negative_log_prior
nats_per_dim = tf.divide(negative_elbo, data_dim, name="nats_per_dim")
bits_per_dim = tf.divide(nats_per_dim, tf.log(2.), name="bits_per_dim")
return nats_per_dim, bits_per_dim
def TSS(y_true, y_pred):
"""
TSS
import tensorflow as tf
sess = tf.Session()
a=tf.contrib.metrics.confusion_matrix([1, 0, 0, 0, 0], [1, 0, 1, 0, 0])
a.eval(session=sess)
array([[3, 1],
[0, 1]], dtype=int32)
a[0][0].eval(session=sess)
3 -> tn
a[0][1].eval(session=sess)
1 -> fp
"""
confusion_matrix = tf.confusion_matrix(labels=tf.argmax(y_true, 1),
predictions=tf.argmax(y_pred, 1),
num_classes=2,
dtype=tf.float32)
tp = confusion_matrix[1][1]
fn = confusion_matrix[1][0]
fp = confusion_matrix[0][1]
tn = confusion_matrix[0][0]
tmp1 = tf.divide(tp, tf.add(tp, fn))
tmp2 = tf.divide(fp, tf.add(fp, tn))
tss = tf.subtract(tmp1, tmp2)
return tss
def dpp_style(self, submethod):
"""Computes the DPP of a matrix."""
det_entries = []
if submethod == "inverse_dist":
for i in range(self.total_CFs):
for j in range(self.total_CFs):
det_temp_entry = tf.divide(
1.0,
tf.add(
1.0,
self.compute_dist(self.cfs_frozen[i],
self.cfs_frozen[j])))
if i == j:
det_temp_entry = tf.add(det_temp_entry, 0.0001)
det_entries.append(det_temp_entry)
elif submethod == "exponential_dist":
for i in range(self.total_CFs):
for j in range(self.total_CFs):
det_temp_entry = tf.divide(
1.0,
tf.exp(
self.compute_dist(self.cfs_frozen[i],
self.cfs_frozen[j])))
det_entries.append(det_temp_entry)
det_entries = tf.reshape(det_entries, [self.total_CFs, self.total_CFs])
loss_part3 = tf.matrix_determinant(det_entries)
return loss_part3
def clip_eta(eta, ord, eps):
"""
Helper function to clip the perturbation to epsilon norm ball.
:param eta: A tensor with the current perturbation.
:param ord: Order of the norm (mimics Numpy).
Possible values: np.inf, 1 or 2.
:param eps: Epsilon, bound of the perturbation.
"""
# Clipping perturbation eta to self.ord norm ball
if ord not in [np.inf, 1, 2]:
raise ValueError('ord must be np.inf, 1, or 2.')
reduc_ind = list(xrange(1, len(eta.get_shape())))
avoid_zero_div = 1e-12
if ord == np.inf:
eta = clip_by_value(eta, -eps, eps)
elif ord == 1:
# Implements a projection algorithm onto the l1-ball from
# (Duchi et al. 2008) that runs in time O(d*log(d)) where d is the
# input dimension.
# Paper link (Duchi et al. 2008): https://dl.acm.org/citation.cfm?id=1390191
eps = tf.cast(eps, eta.dtype)
dim = tf.reduce_prod(tf.shape(eta)[1:])
eta_flat = tf.reshape(eta, (-1, dim))
abs_eta = tf.abs(eta_flat)
if 'sort' in dir(tf):
mu = -tf.sort(-abs_eta, axis=-1)
else:
# `tf.sort` is only available in TF 1.13 onwards
mu = tf.nn.top_k(abs_eta, k=dim, sorted=True)[0]
cumsums = tf.cumsum(mu, axis=-1)
js = tf.cast(tf.divide(1, tf.range(1, dim + 1)), eta.dtype)
t = tf.cast(tf.greater(mu - js * (cumsums - eps), 0), eta.dtype)
rho = tf.argmax(t * cumsums, axis=-1)
rho_val = tf.reduce_max(t * cumsums, axis=-1)
theta = tf.divide(rho_val - eps, tf.cast(1 + rho, eta.dtype))
eta_sgn = tf.sign(eta_flat)
eta_proj = eta_sgn * tf.maximum(abs_eta - theta[:, tf.newaxis], 0)
eta_proj = tf.reshape(eta_proj, tf.shape(eta))
norm = tf.reduce_sum(tf.abs(eta), reduc_ind)
eta = tf.where(tf.greater(norm, eps), eta_proj, eta)
elif ord == 2:
# avoid_zero_div must go inside sqrt to avoid a divide by zero
# in the gradient through this operation
norm = tf.sqrt(
tf.maximum(avoid_zero_div,
reduce_sum(tf.square(eta), reduc_ind, keepdims=True)))
# We must *clip* to within the norm ball, not *normalize* onto the
# surface of the ball
factor = tf.minimum(1., div(eps, norm))
eta = eta * factor
return eta
def _create_variables(self):
"""
Creates/instantiates variables for model such that we can look them up when learning and making predictions
"""
# Weights to map uid into embeddings representing shared knowledge in item and social domains (u^c in paper)
self.uw_c = tf.Variable(tf.random.truncated_normal(shape=[self.n_users, self.embedding_size],
mean=0.0, stddev=0.01, dtype = tf.float32, name='uc'))
# Weights to map uid into embeddings representing shared knowledge in item and question domains
self.uw_c2 = tf.Variable(tf.random.truncated_normal(shape=[self.n_users, self.embedding_size],
mean=0.0, stddev=0.01, dtype=tf.float32, name='uc2'))
# Weights to map uid into embeddings representing preferences to items (u^i in paper)
self.uw_i = tf.Variable(tf.random.truncated_normal(shape=[self.n_users, self.embedding_size],
mean=0.0, stddev=0.01, dtype=tf.float32, name='ui'))
# Weights to map uid into embeddings preferences to items (u^s in paper)
self.uw_s = tf.Variable(tf.random.truncated_normal(shape=[self.n_users, self.embedding_size],
mean=0.0, stddev=0.01, dtype=tf.float32, name='us'))
# Weights to map uid into embeddings for questionnaires
self.uw_q = tf.Variable(tf.random.truncated_normal(shape=[self.n_users, self.embedding_size],
mean=0.0, stddev=0.01, dtype=tf.float32, name='uq'))
# TODO: figure out why they +1 in sizes
# Embeddings for items (M x D)
self.Q = tf.Variable(tf.random.truncated_normal(shape=[self.n_items + 1, self.embedding_size],
mean=0.0, stddev=0.01, dtype=tf.float32, name='Q'))
# Embeddings for social interactions (N x D)
self.G = tf.Variable(tf.random.truncated_normal(shape=[self.n_users + 1, self.embedding_size],
mean=0.0, stddev=0.01, dtype=tf.float32, name='G'))
# Embeddings for questionnaires (M x D)
self.V = tf.Variable(tf.random.truncated_normal(shape=[self.n_items + 1, self.embedding_size],
mean=0.0, stddev=0.01, dtype=tf.float32, name='V'))
# Weights used in item domain prediction layer
self.H_i = tf.Variable(tf.constant(0.01, shape=[self.embedding_size, 1]), name='hi')
# Weights used in social domain prediction layer
self.H_s = tf.Variable(tf.constant(0.01, shape=[self.embedding_size, 1]), name='hf')
# Weights used in questionnaire domain prediction layer
self.H_q = tf.Variable(tf.constant(0.01, shape=[self.embedding_size, 1]), name='hq')
# Item domain attention network parameters
self.W_item = tf.Variable(
tf.random.truncated_normal(shape=[self.embedding_size, self.attention_size], mean=0.0, stddev=tf.sqrt(
tf.divide(2.0, self.attention_size + self.embedding_size))), dtype=tf.float32, name='Witem')
self.B_item = tf.Variable(tf.constant(0.00, shape=[self.attention_size]), name='Bitem') # 1 x k
self.H_item = tf.Variable(tf.constant(0.01, shape=[self.attention_size, 1], name='Hitem')) # k x 1
# Social domain attention network parameters
self.W_social = tf.Variable(
tf.random.truncated_normal(shape=[self.embedding_size, self.attention_size], mean=0.0, stddev=tf.sqrt(
tf.divide(2.0, self.attention_size + self.embedding_size))), dtype=tf.float32, name='Wsocial')
self.B_social = tf.Variable(tf.constant(0.00, shape=[self.attention_size]), name='Bsocial') # 1 x k
self.H_social = tf.Variable(tf.constant(0.01, shape=[self.attention_size, 1], name='Hsocial')) # k x 1
# Questionnaire domain attention network parameters
self.W_question = tf.Variable(
tf.random.truncated_normal(shape=[self.embedding_size, self.attention_size], mean=0.0, stddev=tf.sqrt(
tf.divide(2.0, self.attention_size + self.embedding_size))), dtype=tf.float32, name='Wquestion')
self.B_question = tf.Variable(tf.constant(0.00, shape=[self.attention_size]), name='Bquestion') # 1 x k
self.H_question = tf.Variable(tf.constant(0.01, shape=[self.attention_size, 1], name='Hquestion')) # k x 1
def read_record(data_path, batch_size=1, size=512):
feature = {'image': tf.FixedLenFeature(shape=(), dtype=tf.string),
'wall': tf.FixedLenFeature(shape=(), dtype=tf.string),
'close': tf.FixedLenFeature(shape=(), dtype=tf.string),
'room': tf.FixedLenFeature(shape=(), dtype=tf.string),
'close_wall': tf.FixedLenFeature(shape=(), dtype=tf.string)}
# Create a list of filenames and pass it to a queue
filename_queue = tf.train.string_input_producer([data_path], num_epochs=None, shuffle=False, capacity=batch_size*128)
# Define a reader and read the next record
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
# Decode the record read by the reader
features = tf.parse_single_example(serialized_example, features=feature)
# Convert the image data from string back to the numbers
image = tf.decode_raw(features['image'], tf.uint8)
wall = tf.decode_raw(features['wall'], tf.uint8)
close = tf.decode_raw(features['close'], tf.uint8)
room = tf.decode_raw(features['room'], tf.uint8)
close_wall = tf.decode_raw(features['close_wall'], tf.uint8)
# Cast data
image = tf.cast(image, dtype=tf.float32)
wall = tf.cast(wall, dtype=tf.float32)
close = tf.cast(close, dtype=tf.float32)
# room = tf.cast(room, dtype=tf.float32)
close_wall = tf.cast(close_wall, dtype=tf.float32)
# Reshape image data into the original shape
image = tf.reshape(image, [size, size, 3])
wall = tf.reshape(wall, [size, size, 1])
close = tf.reshape(close, [size, size, 1])
room = tf.reshape(room, [size, size])
close_wall = tf.reshape(close_wall, [size, size, 1])
# Any preprocessing here ...
# normalize
image = tf.divide(image, tf.constant(255.0))
wall = tf.divide(wall, tf.constant(255.0))
close = tf.divide(close, tf.constant(255.0))
close_wall = tf.divide(close_wall, tf.constant(255.0))
# Genereate one hot room label
room_one_hot = tf.one_hot(room, 9, axis=-1)
# Creates batches by randomly shuffling tensors
images, walls, closes, rooms, close_walls = tf.train.shuffle_batch([image, wall, close, room_one_hot, close_wall],
batch_size=batch_size, capacity=batch_size*128, num_threads=1, min_after_dequeue=batch_size*32)
# images, walls = tf.train.shuffle_batch([image, wall],
# batch_size=batch_size, capacity=batch_size*128, num_threads=1, min_after_dequeue=batch_size*32)
return {'images': images, 'walls': walls, 'closes': closes, 'rooms': rooms, 'close_walls': close_walls}
def _attention(sent1, sent2):
"""
Compute attention of sentences, positional encoding
"""
with tf.variable_scope('attend_scope') as self.attend_scope:
num_units = self.attend_layer_sizes
repr1 = _feedforwad(sent1, self.attend_scope, num_units)
repr2 = _feedforwad(sent2,
self.attend_scope,
num_units,
reuse_weights=True)
m1_m2 = tf.multiply(tf.expand_dims(self.s1_m, 2),
tf.expand_dims(self.s2_m, 1))
repr2 = tf.transpose(repr2, [0, 2, 1])
origin_attention = tf.matmul(repr1, repr2)
origin_attention = tf.multiply(origin_attention, m1_m2)
attention1 = tf.exp(
origin_attention -
tf.reduce_max(origin_attention, axis=2, keep_dims=True))
attention2 = tf.exp(
origin_attention -
tf.reduce_max(origin_attention, axis=1, keep_dims=True))
attention1 = tf.multiply(attention1,
tf.expand_dims(self.s2_m, 1))
attention2 = tf.multiply(attention2,
tf.expand_dims(self.s1_m, 2))
attention1 = tf.divide(
attention1,
tf.reduce_sum(attention1, axis=2, keep_dims=True))
attention2 = tf.divide(
attention2,
tf.reduce_sum(attention2, axis=1, keep_dims=True))
attention1 = tf.multiply(attention1, m1_m2)
attention2 = tf.multiply(attention2, m1_m2)
alpha = tf.matmul(attention1, sent2, name='alpha')
beta = tf.matmul(tf.transpose(attention2, [0, 2, 1]),
sent1,
name='beta')
return alpha, beta
def weighted_r2_op(predictions, targets, inputs):
""" weighted_r2_op.
An op that calculates the standard error.
Examples:
```python
input_data = placeholder(shape=[None, 784])
y_pred = my_network(input_data) # Apply some ops
y_true = placeholder(shape=[None, 10]) # Labels
stderr_op = weighted_r2_op(y_pred, y_true, input_data)
# Calculate standard error by feeding data X and labels Y
std_error = sess.run(stderr_op, feed_dict={input_data: X, y_true: Y})
```
Arguments:
predictions: `Tensor`.
targets: `Tensor`.
inputs: `Tensor`.
Returns:
`Float`. The standard error.
"""
with tf.name_scope('WeightedStandardError'):
if hasattr(inputs, '__len__'):
inputs = tf.add_n(inputs)
if inputs.get_shape().as_list() != targets.get_shape().as_list():
raise Exception(
"Weighted R2 metric requires Inputs and Targets to "
"have same shape.")
a = tf.reduce_sum(tf.square(predictions - inputs))
b = tf.reduce_sum(tf.square(targets - inputs))
return tf.divide(a, b)
def r2_op(predictions, targets):
""" r2_op.
An op that calculates the standard error.
Examples:
```python
input_data = placeholder(shape=[None, 784])
y_pred = my_network(input_data) # Apply some ops
y_true = placeholder(shape=[None, 10]) # Labels
stderr_op = r2_op(y_pred, y_true)
# Calculate standard error by feeding data X and labels Y
std_error = sess.run(stderr_op, feed_dict={input_data: X, y_true: Y})
```
Arguments:
predictions: `Tensor`.
targets: `Tensor`.
Returns:
`Float`. The standard error.
"""
with tf.name_scope('StandardError'):
a = tf.reduce_sum(tf.square(tf.subtract(targets, predictions)))
b = tf.reduce_sum(
tf.square(tf.subtract(targets, tf.reduce_mean(targets))))
return tf.subtract(1.0, tf.divide(a, b))
def update_fisher_diag(self, n_task):
# Reset is mandatory
print('Mandatory fisher diagonal reset')
self.reset_fisher_diag()
print("Reset fishers computed")
reset_ops = []
for fdc in self.objs['fisher_diagcs']:
reset_ops += [tf.assign(fdc, tf.zeros_like(fdc))]
self.objs['sess'].run(reset_ops)
n_minibatches = self.it.n // self.fisher_batch_size
self.it.i = 0
orig = self.objs['sess'].run(utils.sum_up(self.objs['fisher_diagcs']))
# imgs_sum = []
for batch in range(n_minibatches):
# print("Batch %d" % batch)
nX, nY = next(self.it)
# imgs_sum += [np.sum(nY)]
train_data = {self.phs['fisher_X']: nX, self.phs['fisher_Y']: nY}
self.objs['sess'].run(self.objs['fisher_sum_up_ops'],
feed_dict=train_data)
# print(self.objs['sess'].run(self.objs['fisher_diagcs'][0])[0][0])
newv = self.objs['sess'].run(utils.sum_up(self.objs['fisher_diagcs']))
# print(orig, newv, n_minibatches, self.fisher_batch_size)
# print(imgs_sum)
print('Ran fisher_sum_up_ops (examples: %d)' %
(n_minibatches * self.fisher_batch_size))
division_ops = []
for fdc in self.objs['fisher_diagcs']:
division_ops += [
tf.assign(
fdc, tf.divide(fdc,
n_minibatches * self.fisher_batch_size))
]
self.objs['sess'].run(division_ops)
shown_vars = self.objs['fisher_diags']
orig = self.objs['sess'].run(utils.sum_up(self.objs['fisher_diags']))
origs = ["%.2f" % orig]
assign_ops = []
for fdc, fd in zip(self.objs['fisher_diagcs'],
self.objs['fisher_diags']):
assign_ops += [tf.assign_add(fd, fdc)]
self.objs['sess'].run(assign_ops)
newv = self.objs['sess'].run(utils.sum_up(self.objs['fisher_diags']))
newvs = ["%.2f" % newv]
print("changed %s => %s" % (" , ".join(origs), " , ".join(newvs)))
# print("SHOWN:")
# self.print_vars(shown_vars)
self.saved_fishers[n_task - 1] = [] # say task 0
save_ops = []
for fd in self.objs['fisher_diags']:
self.saved_fishers[n_task - 1] += [tf.Variable(tf.zeros_like(fd))]
save_ops += [tf.assign(self.saved_fishers[n_task - 1][-1], fd)]
self.objs['sess'].run(save_ops)
print("Saved fishers for task %d" % (n_task - 1))
def create_similarity_model(self):
this = self._this_mem
target = self._target_mem
feed_dict = self._feed_dict
_main_norm = tf.norm(this, name='this_norm')
_row_norm = tf.norm(target, name='target_norm')
expr_dot = tf.tensordot(this, target, 1, name='member_dot')
expr_div = tf.divide(this, target, name='member_div')
with tf.Session() as sess:
_ = tf.Variable(initial_value='fake_variable')
sess.run(tf.global_variables_initializer())
main_m = sess.run(_main_norm, {this: feed_dict['this_member']})
row_mem = sess.run(_row_norm, {target: feed_dict['target_member']})
print(f'main_m: {main_m}')
print(f'row_mem: {row_mem}')
prod = sess.run(expr_dot, {this: feed_dict['this_member'], target: feed_dict['target_member']})
print(f'PROD: {prod}')
similarity = sess.run(expr_div, {this: prod, target: (main_m*row_mem)})
print(f'SIMILARITY: {similarity}')
checkpoint_path = os.path.join(self.path, 'recommend_stock_checkpoint', 'similarity.ckpt')
saver = tf.train.Saver()
saver.save(sess, checkpoint_path, global_step=1000)
def _questionnaire_attentive_transfer(self):
"""
Transferring knowledge from questionnaires. Our contribution.
Works the same way, as the attentive networks in paper.
"""
# eq. 3 for computing attentions
q_attention = tf.exp(
tf.matmul(
tf.nn.relu(
tf.matmul(self.u_q, self.W_question) + self.B_question),
self.H_question))
common_attention = tf.exp(
tf.matmul(
tf.nn.relu(
tf.matmul(self.u_c, self.W_question) + self.B_question),
self.H_question))
# eq. 4 for computing weights
q_weight = tf.divide(q_attention, q_attention + common_attention)
common_weight = 1.0 - q_weight
# eq. 5 for computing transferred user embedding
user_embedding = q_weight * self.u_q + common_weight * self.u_c
# returning user embedding, so that we can make predictions. Social weight such that we can analyse,
# when it's low or high
return user_embedding, q_weight
def _make_activity_op(self, input_tensor):
""" Creates the op for calculating the activity of a SOM
:param input_tensor: A tensor to calculate the activity of. Must be of shape `[batch_size, dim]` where `dim` is
the dimensionality of the SOM's weights.
:return A handle to the newly created activity op:
"""
with self._graph.as_default():
with tf.name_scope("Activity"):
# This constant controls the width of the gaussian.
# The closer to 0 it is, the wider it is.
c = tf.constant(self._c, dtype="float32")
# Get the euclidean distance between each neuron and the input vectors
dist = tf.norm(tf.subtract(
tf.expand_dims(self._weights, axis=0),
tf.expand_dims(input_tensor, axis=1)),
name="Distance",
axis=2) # [batch_size, neurons]
# Calculate the Gaussian of the activity. Units with distances closer to 0 will have activities
# closer to 1.
activity = tf.exp(tf.multiply(tf.pow(dist, 2), c),
name="Gaussian")
# Convert the activity into a softmax probability distribution
if self._softmax_activity:
activity = tf.divide(tf.exp(activity),
tf.expand_dims(tf.reduce_sum(
tf.exp(activity), axis=1),
axis=-1),
name="Softmax")
return tf.identity(activity, name="Output")
def lnlike_ellflatpriormarginalized(
F_obs, # (nobj, ..., numBands)
F_obs_var, # (nobj, ..., numBands)
F_mod, # (nobj, ..., numBands)
):
"""
Fit linear model to one Gaussian data set (formulation 3)
Parameters
----------
F_obs, F_obs_var : ndarray (nobj, ..., n_pix_y)
data and data variances
F_mod : ndarray (..., n_components, n_pix_y)
design matrix of linear model
Returns
-------
logfml : ndarray (nobj, )
log likelihood values with parameters marginalised and at best fit
ellML : ndarray (nobj, ndim)
Best fit MAP parameters
"""
FOT = tf.reduce_sum(F_mod * F_obs / F_obs_var, axis=-1) # (nobj, ..., )
FOO = tf.reduce_sum(tf.square(F_obs) / F_obs_var, axis=-1) # (nobj, ..., )
FTT = tf.reduce_sum(tf.square(F_mod) / F_obs_var, axis=-1) # (nobj, ..., )
LogSigma_det = tf.reduce_sum(tf.math.log(F_obs_var), axis=-1) # (nobj, ..., )
Chi2 = FOO - tf.multiply(tf.divide(FOT, FTT), FOT) # (nobj, ..., )
LogDenom = LogSigma_det + tf.math.log(FTT)
LnMarglike = -0.5 * Chi2 - 0.5 * LogDenom # (nobj, ..., )
ellML = FOT / FTT
return LnMarglike, ellML
def masked_softmax_cross_entropy(preds, labels, mask):
"""Softmax cross-entropy loss with masking."""
loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)
mask = tf.cast(mask, dtype=tf.float32)
mask = tf.divide(mask, tf.reduce_mean(mask))
loss = tf.multiply(loss, mask)
return tf.reduce_mean(loss)
def compute_x(self, param_name, param, m, prev_w_norm, prev_eta,
prev_beta):
"""Compute prev x value on the fly.
Alternatively, we can store this as a slot but that would double the
memory usage of our parameters. We don't like that!
Args:
param_name: Name of the parameter. Used to check whether to normalize the
gradients for this layer.
param: The parameter `Tensor`.
m: Accumulated momentum `Tensor` of shape same as param.
prev_w_norm: Scalar tracking norm of the param tensor at previous
iteration.
prev_eta: Scalar tracking the learning rate applied at previous iteration.
prev_beta: Scalar tracking momentum applied at previous iteration.
Returns:
x: An intermediate `Tensor` of shape same as param. Will be used for the
final update.
"""
prev_ratio = 1.0
if self._do_layer_adaptation(param_name):
prev_g_norm = tf.norm(m, ord=2)
prev_ratio = self.gamma * tf.where(
tf.math.greater(prev_w_norm, 0),
tf.where(tf.math.greater(prev_g_norm, 0),
(prev_w_norm / prev_g_norm), 1.0), 1.0)
prev_normalized_m_with_lr = prev_ratio * prev_eta * m
x = param - tf.divide(
tf.multiply(prev_beta, prev_normalized_m_with_lr), prev_beta - 1.0)
return x
def mask_logits(logits, mask):
"""Masks logits and writes them to predictions dict.
Args:
logits: Float tensor with shape [batch_size, num_classes].
mask: Boolean tensor with shape [batch_size, num_classes].
Returns:
Dict of tensors. It contains keys
'unmasked_probabilities' and 'masked_probabilities'. Both of them are float
tensor with shape [batch_size, num_classes].
"""
with tf.variable_scope('mask_logits'):
unmasked_probabilities = tf.nn.softmax(logits,
name='unmasked_probabilities')
unnormalized_masked_probabilities = tf.multiply(
unmasked_probabilities, tf.cast(mask,
unmasked_probabilities.dtype))
masked_probabilities = tf.divide(unnormalized_masked_probabilities,
tf.reduce_sum(
unnormalized_masked_probabilities,
axis=1,
keepdims=True),
name='masked_probabilities')
return {
'unmasked_probabilities': unmasked_probabilities,
'masked_probabilities': masked_probabilities,
}
def read_tensor_from_image_file(self,
file_name,
input_height=299,
input_width=299,
input_mean=0,
input_std=255):
input_name = "file_reader"
output_name = "normalized"
file_reader = tf.read_file(file_name, input_name)
if file_name.endswith(".png"):
image_reader = tf.image.decode_png(file_reader,
channels=3,
name='png_reader')
elif file_name.endswith(".gif"):
image_reader = tf.squeeze(
tf.image.decode_gif(file_reader, name='gif_reader'))
elif file_name.endswith(".bmp"):
image_reader = tf.image.decode_bmp(file_reader, name='bmp_reader')
else:
image_reader = tf.image.decode_jpeg(file_reader,
channels=3,
name='jpeg_reader')
float_caster = tf.cast(image_reader, tf.float32)
dims_expander = tf.expand_dims(float_caster, 0)
resized = tf.image.resize_bilinear(dims_expander,
[input_height, input_width])
normalized = tf.divide(tf.subtract(resized, [input_mean]), [input_std])
sess = tf.Session()
result = sess.run(normalized)
return result
def read_tensor_from_image_file(self,
url,
input_height=299,
input_width=299,
input_mean=0,
input_std=255):
input_name = "file_reader"
output_name = "normalized"
imageData = requests.get(url).content
if ".png" in url:
image_reader = tf.image.decode_png(imageData,
channels=3,
name='png_reader')
elif ".gif" in url:
image_reader = tf.squeeze(
tf.image.decode_gif(imageData, name='gif_reader'))
elif ".bmp" in url:
image_reader = tf.image.decode_bmp(imageData, name='bmp_reader')
else:
image_reader = tf.image.decode_jpeg(imageData,
channels=3,
name='jpeg_reader')
float_caster = tf.cast(image_reader, tf.float32)
dims_expander = tf.expand_dims(float_caster, 0)
resized = tf.image.resize_bilinear(dims_expander,
[input_height, input_width])
normalized = tf.divide(tf.subtract(resized, [input_mean]), [input_std])
sess = tf.Session()
result = sess.run(normalized)
return result
def _compute_loss(self, prediction_tensor, target_tensor, weights):
"""Compute loss function.
Args:
prediction_tensor: A float tensor of shape [batch_size, num_anchors,
num_classes] representing the predicted logits for each class
target_tensor: A float tensor of shape [batch_size, num_anchors,
num_classes] representing logit classification targets
weights: a float tensor of shape, either [batch_size, num_anchors,
num_classes] or [batch_size, num_anchors, 1]. If the shape is
[batch_size, num_anchors, 1], all the classses are equally weighted.
Returns:
loss: a float tensor of shape [batch_size, num_anchors]
representing the value of the loss function.
"""
weights = tf.reduce_mean(weights, axis=2)
num_classes = prediction_tensor.get_shape().as_list()[-1]
target_tensor = self._scale_and_softmax_logits(target_tensor)
prediction_tensor = tf.divide(prediction_tensor,
self._logit_scale,
name='scale_logits')
per_row_cross_ent = (tf.nn.softmax_cross_entropy_with_logits(
labels=tf.reshape(target_tensor, [-1, num_classes]),
logits=tf.reshape(prediction_tensor, [-1, num_classes])))
return tf.reshape(per_row_cross_ent, tf.shape(weights)) * weights
def ls(x):
# 0.8
threshold = 1 / 256 / 2
x_coef = 2 / threshold
a = tf.constant(-0.001)
# a = tf.constant(1.0)
nom = tf.abs(tf.subtract(tf.constant(2.0), a))
mul1 = tf.divide(nom, a)
x = tf.multiply(x, tf.constant(x_coef))
x = tf.multiply(x, x)
mul2 = tf.subtract(
tf.pow(tf.add(tf.divide(tf.multiply(x, x), nom), tf.constant(1.0)),
tf.div(a, tf.constant(2.0))), tf.constant(1.0))
return tf.multiply(mul1, mul2)
def contrast_normalize(self, I):
dist = tf.distributions.Normal(loc=0., scale=self.sigma)
W = (self.kernel_size - 1) / 2.0
box_x = tf.lin_space(-W, W, self.kernel_size)
box_y = tf.lin_space(-W, W, self.kernel_size)
prob_x = dist.prob(box_x)
prob_y = dist.prob(box_y)
gaussian_box = tf.matmul(tf.reshape(prob_x, [self.kernel_size, 1]),
tf.reshape(prob_y, [1, self.kernel_size]))
gaussian_box = tf.reshape(gaussian_box,
[self.kernel_size, self.kernel_size, 1, 1])
gaussian_box = tf.divide(gaussian_box, tf.reduce_sum(gaussian_box))
avg_I = tf.nn.conv2d(I,
gaussian_box,
strides=[1, 1, 1, 1],
padding='SAME')
normalized_I = I - avg_I
img_H = tf.shape(I)[1]
img_W = tf.shape(I)[2]
normalized_I = tf.slice(
normalized_I, [0, self.border, self.border, 0],
[-1, img_H - 2 * self.border, img_W - 2 * self.border, -1])
return [normalized_I]
def get_D(l, u, Ip, I):
# D matrix for each layer
D = Ip + tf.where(tf.greater(I, 0.5), tf.divide(u, u - l),
tf.zeros_like(I))
return D
def attention_func(Q, K, V):
Z = tf.matmul(Q, K, transpose_b=True)
dk = tf.cast(tf.shape(K)[-1], dtype=tf.float32)
Z = tf.divide(Z, tf.sqrt(dk))
Z = tf.nn.softmax(Z, dim=-1)
res = tf.matmul(Z, V)
res = tf.reduce_mean(res, axis=0)
return res
def _item_attentive_transfer(self):
"""
Item attentive transfer (eq. 5)
"""
# eq. 3 for computing attentions
item_attention = tf.exp(tf.matmul(tf.nn.relu(tf.matmul(self.u_i, self.W_item) + self.B_item), self.H_item))
common_attention = tf.exp(tf.matmul(tf.nn.relu(tf.matmul(self.u_c, self.W_item) + self.B_item), self.H_item))
common2_attention = tf.exp(tf.matmul(tf.nn.relu(tf.matmul(self.u_c2, self.W_item) + self.B_item), self.H_item))
# eq. 4 for computing weights
item_weight = tf.divide(item_attention, item_attention + common_attention + common2_attention)
common_weight = tf.divide(common_attention, item_attention + common_attention + common2_attention)
common2_weight = tf.divide(common2_attention, item_attention + common_attention + common2_attention)
# eq. 5 for computing transferred user embedding
user_embedding = item_weight * self.u_i + common_weight * self.u_c + common2_weight * self.u_c2
# returning user embedding, so that we can make predictions. Item weight such that we can analyse,
# when it's low or high
return user_embedding, item_weight
def file_to_tensor(file_path):
image_string = tf.read_file(file_path)
image = tf.image.decode_image(image_string, channels=3)
image.set_shape([None, None, None])
image = tf.image.resize_images(image, [image_size, image_size])
image = tf.divide(tf.subtract(image, [0]), [255])
image.set_shape([image_size, image_size, num_channel])
return image
def _link(self, x, **kwargs):
y = x
if self._mu is not None:
self._mu = tf.constant(self._mu, dtype=hub.dtype)
y = tf.subtract(x, self._mu)
if self._sigma is not None:
self._sigma = tf.constant(self._sigma, dtype=hub.dtype)
y = tf.divide(y, self._sigma)
return y
def compute_second_part_of_loss(self):
"""Compute the second part (distance from x1) of the loss function."""
loss_part2 = 0.0
for i in range(self.total_CFs):
loss_part2 = tf.add(loss_part2,
self.compute_dist(self.cfs_frozen[i], self.x1))
return tf.divide(
loss_part2,
tf.cast(tf.multiply(len(self.minx[0]), self.total_CFs),
dtype=tf.float32))
def net_NS(self, P_back, x):
P_U1_U2_U3 = self.neural_net(tf.concat([P_back, x], 1), self.weights, self.biases)
P = P_U1_U2_U3[:,0:1]
U1 = P_U1_U2_U3[:,1:2]
U2 = P_U1_U2_U3[:,2:3]
U3 = P_U1_U2_U3[:,3:4]
# autodiff gradient #1
mass_flow_grad = tf.gradients(U2, x)[0]
# autodiff gradient #2
S = 1 + 2.2*(x-1.5)*(x-1.5)
momentum_grad = tf.add(tf.gradients(U2*U2/U1 + P*S, x)[0], - tf.multiply(tf.gradients(S, x)[0], P))
# autodiff gradient #3
rho_u_E_S = tf.divide(tf.multiply(U2, U3), U1)
p_u_S = tf.divide(tf.multiply(tf.multiply(P, S), U2), U1)
net_energy_expression = tf.add(rho_u_E_S, p_u_S)
energy_grad = tf.gradients(net_energy_expression, x)[0]
return P, U1, U2, U3, mass_flow_grad, momentum_grad, energy_grad
def compute_first_part_of_loss(self, method):
"""Computes the first part (y-loss) of the loss function."""
loss_part1 = 0.0
for i in range(self.total_CFs):
if method == "l2_loss":
temp_loss = tf.square(
tf.subtract(self.model.get_output(self.cfs_frozen[i]),
self.target_cf))
elif method == "log_loss":
temp_logits = tf.log(
tf.divide(
tf.abs(
tf.subtract(
self.model.get_output(self.cfs_frozen[i]),
0.000001)),
tf.subtract(
1.0,
tf.abs(
tf.subtract(
self.model.get_output(self.cfs_frozen[i]),
0.000001)))))
temp_loss = tf.nn.sigmoid_cross_entropy_with_logits(
logits=temp_logits, labels=self.target_cf)
elif method == "hinge_loss":
temp_logits = tf.log(
tf.divide(
tf.abs(
tf.subtract(
self.model.get_output(self.cfs_frozen[i]),
0.000001)),
tf.subtract(
1.0,
tf.abs(
tf.subtract(
self.model.get_output(self.cfs_frozen[i]),
0.000001)))))
temp_loss = tf.losses.hinge_loss(logits=temp_logits,
labels=self.target_cf)
loss_part1 = tf.add(loss_part1, temp_loss)
return tf.divide(loss_part1, tf.cast(self.total_CFs, dtype=tf.float32))
