def triplet_loss(y_true, y_pred, alpha=0.2):
"""
Implementation of the triplet loss as defined by formula (3)
Arguments:
y_true -- true labels, required when you define a loss in Keras, you don't need it in this function.
y_pred -- python list containing three objects:
anchor -- the encodings for the anchor images, of shape (None, 128)
positive -- the encodings for the positive images, of shape (None, 128)
negative -- the encodings for the negative images, of shape (None, 128)
Returns:
loss -- real number, value of the loss
"""
anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]
### START CODE HERE ### (≈ 4 lines)
# Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)
# Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)
# Step 3: subtract the two previous distances and add alpha.
basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)
# Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.
loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))
### END CODE HERE ###
return loss
def custom_my_loss(y_true, y_pred):
m1 = mod1(y_true)
m2 = mod2(y_true)
m3 = mod3(y_true)
m4 = mod4(y_true)
n1 = mod1(y_pred)
n2 = mod2(y_pred)
n3 = mod3(y_pred)
n4 = mod4(y_pred)
l1 = tf.square(tf.subtract(m1, n1))
l2 = tf.square(tf.subtract(m2, n2))
l3 = tf.square(tf.subtract(m3, n3))
l4 = tf.square(tf.subtract(m4, n4))
_, a1, b1, c1 = m1.shape
_, a2, b2, c2 = m2.shape
_, a3, b3, c3 = m3.shape
_, a4, b4, c4 = m4.shape
m1 = a1 * b1 * c1
m2 = a2 * b2 * c2
m3 = a3 * b3 * c3
m4 = a4 * b4 * c4
m1 = tf.cast(m1, tf.float32)
m2 = tf.cast(m2, tf.float32)
m3 = tf.cast(m3, tf.float32)
m4 = tf.cast(m4, tf.float32)
loss = tf.sqrt(
tf.reduce_sum(l1 / m1) + tf.reduce_sum(l2 / m2) +
tf.reduce_sum(l3 / m3) + tf.reduce_sum(l4 / m4))
return loss
def make_relu6(output_name, input_name, const6_name='const6'):
graph = tf.Graph()
with graph.as_default():
tf_x = tf.placeholder(tf.float32, [10, 10], name=input_name)
tf_6 = tf.constant(dtype=tf.float32, value=6.0, name=const6_name)
with tf.name_scope(output_name):
tf_y1 = tf.nn.relu(tf_x, name='relu1')
tf_y2 = tf.nn.relu(tf.subtract(tf_x, tf_6, name='sub1'), name='relu2')
#tf_y = tf.nn.relu(tf.subtract(tf_6, tf.nn.relu(tf_x, name='relu1'), name='sub'), name='relu2')
#tf_y = tf.subtract(tf_6, tf_y, name=output_name)
tf_y = tf.subtract(tf_y1, tf_y2, name=output_name)
graph_def = graph.as_graph_def()
graph_def.node[-1].name = output_name
# remove unused nodes
for node in graph_def.node:
if node.name == input_name:
graph_def.node.remove(node)
for node in graph_def.node:
if node.name == const6_name:
graph_def.node.remove(node)
for node in graph_def.node:
if node.op == '_Neg':
node.op = 'Neg'
return graph_def
def _link(self, pre_states, x, **kwargs):
self._check_state(pre_states, 2)
h, c = pre_states
# Get neuron activations
if self.lottery_activated:
f_tilde, i_tilde_bar, f, i, o, c_hat = self._get_neurons(x, h)
else:
f_tilde, i_tilde_bar, f, i, o, c_hat = self._get_neurons_fast(x, h)
f_tilde_bar = tf.subtract(1., f_tilde)
i_tilde = tf.subtract(1., i_tilde_bar)
# Update
# omega = tf.multiply(f_tilde, i_tilde)
f_hat = tf.multiply(f_tilde,
tf.add(tf.multiply(f, i_tilde), i_tilde_bar))
i_hat = tf.multiply(i_tilde,
tf.add(tf.multiply(f_tilde, i), f_tilde_bar))
new_c = tf.add(tf.multiply(f_hat, c), tf.multiply(i_hat, c_hat))
new_h = tf.multiply(o, tf.tanh(new_c))
# Register gates and return
self._gate_dict['master_forget_gate'] = f_tilde
self._gate_dict['master_input_gate'] = i_tilde
self._gate_dict['forget_gate'] = f
self._gate_dict['input_gate'] = i
self._gate_dict['output_gate'] = o
return new_h, (new_h, new_c)
def triplet_loss(y_true, y_pred, alpha=0.5):
anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)
basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)
loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))
return loss
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 create_logistic(m, optimize_model):
batch_size = 1
model_name = f"logistic{m}"
with tf.Session() as sess:
x = tf.placeholder(tf.float32, shape=(m,), name='x')
y = tf.placeholder(tf.float32, shape=(1,), name='y')
w = tf.placeholder(tf.float32, shape=(m,), name='W')
input_shapes = {"x:0": x.shape, "W:0": w.shape, "y:0": y.shape}
mu = tf.constant(1, dtype=tf.float32, name="mu")
h = tf.reduce_sum(tf.multiply(w, x))
h = tf.math.sigmoid(h)
d = tf.subtract(h, y)
g = tf.multiply(d, x)
g = tf.multiply(mu, g)
w = tf.subtract(w, g, name='w_out')
input_names = ['x:0', 'y:0']
output_names = ['w_out:0']
onnx_graph = tf2onnx.tfonnx.process_tf_graph(sess.graph, input_names=input_names, output_names=output_names)
model_proto = onnx_graph.make_model(model_name)
model_proto = optimizer.optimize(model_proto, ['eliminate_identity'])
if optimize_model:
model_proto, check = simplify(model_proto, input_shapes=input_shapes)
assert check
with open(f"./{model_name}.onnx", "wb") as f:
f.write(model_proto.SerializeToString())
def z_q_neighbors(self):
"""Aggregates the respective neighbors in the SOM for every embedding in z_q."""
k_1 = self.k // self.som_dim[1]
k_2 = self.k % self.som_dim[1]
k_stacked = tf.stack([k_1, k_2], axis=1)
k1_not_top = tf.less(k_1, tf.constant(self.som_dim[0]-1, dtype=tf.int64))
k1_not_bottom = tf.greater(k_1, tf.constant(0, dtype=tf.int64))
k2_not_right = tf.less(k_2, tf.constant(self.som_dim[1]-1, dtype=tf.int64))
k2_not_left = tf.greater(k_2, tf.constant(0, dtype=tf.int64))
k1_up = tf.where(k1_not_top, tf.add(k_1, 1), k_1)
k1_down = tf.where(k1_not_bottom, tf.subtract(k_1, 1), k_1)
k2_right = tf.where(k2_not_right, tf.add(k_2, 1), k_2)
k2_left = tf.where(k2_not_left, tf.subtract(k_2, 1), k_2)
z_q_up = tf.where(k1_not_top, tf.gather_nd(self.embeddings, tf.stack([k1_up, k_2], axis=1)),
tf.zeros([self.batch_size, self.latent_dim]))
z_q_down = tf.where(k1_not_bottom, tf.gather_nd(self.embeddings, tf.stack([k1_down, k_2], axis=1)),
tf.zeros([self.batch_size, self.latent_dim]))
z_q_right = tf.where(k2_not_right, tf.gather_nd(self.embeddings, tf.stack([k_1, k2_right], axis=1)),
tf.zeros([self.batch_size, self.latent_dim]))
z_q_left = tf.where(k2_not_left, tf.gather_nd(self.embeddings, tf.stack([k_1, k2_left], axis=1)),
tf.zeros([self.batch_size, self.latent_dim]))
z_q_neighbors = tf.stack([self.z_q, z_q_up, z_q_down, z_q_right, z_q_left], axis=1)
return z_q_neighbors
def _flip_boxes_left_right(boxes):
ymin, xmin, ymax, xmax = tf.split(value=boxes,
num_or_size_splits=4,
axis=1)
flipped_xmin = tf.subtract(1.0, xmax)
flipped_xmax = tf.subtract(1.0, xmin)
flipped_boxes = tf.concat([ymin, flipped_xmin, ymax, flipped_xmax], 1)
return flipped_boxes
def loss_som(self):
"""Computes the SOM loss."""
k = tf.range(self.som_dim[0] * self.som_dim[1])
k_1 = k // self.som_dim[0]
k_2 = k % self.som_dim[1]
k1_not_top = tf.less(k_1,
tf.constant(self.som_dim[0] - 1, dtype=tf.int32))
k1_not_bottom = tf.greater(k_1, tf.constant(0, dtype=tf.int32))
k2_not_right = tf.less(
k_2, tf.constant(self.som_dim[1] - 1, dtype=tf.int32))
k2_not_left = tf.greater(k_2, tf.constant(0, dtype=tf.int32))
k1_up = tf.where(k1_not_top, tf.add(k_1, 1),
tf.zeros(tf.shape(k_1), dtype=tf.dtypes.int32))
k1_down = tf.where(
k1_not_bottom, tf.subtract(k_1, 1),
tf.ones(tf.shape(k_1), dtype=tf.dtypes.int32) *
(self.som_dim[0] - 1))
k2_right = tf.where(k2_not_right, tf.add(k_2, 1),
tf.zeros(tf.shape(k_2), dtype=tf.dtypes.int32))
k2_left = tf.where(
k2_not_left, tf.subtract(k_2, 1),
tf.ones(tf.shape(k_2), dtype=tf.dtypes.int32) *
(self.som_dim[0] - 1))
k_up = k1_up * self.som_dim[0] + k_2
k_down = k1_down * self.som_dim[0] + k_2
k_right = k_1 * self.som_dim[0] + k2_right
k_left = k_1 * self.som_dim[0] + k2_left
q_t = tf.transpose(self.q_ng)
q_up = tf.transpose(
tf.gather_nd(
q_t, tf.reshape(k_up, [self.som_dim[0] * self.som_dim[1], 1])))
q_down = tf.transpose(
tf.gather_nd(
q_t, tf.reshape(k_down,
[self.som_dim[0] * self.som_dim[1], 1])))
q_right = tf.transpose(
tf.gather_nd(
q_t, tf.reshape(k_right,
[self.som_dim[0] * self.som_dim[1], 1])))
q_left = tf.transpose(
tf.gather_nd(
q_t, tf.reshape(k_left,
[self.som_dim[0] * self.som_dim[1], 1])))
q_neighbours = tf.stack([q_up, q_down, q_right, q_left], axis=2)
q_neighbours = tf.reduce_sum(tf.math.log(q_neighbours), axis=-1)
# threshold
#maxx = 0.1
#mask = tf.greater_equal(self.q, maxx * tf.ones_like(self.q))
#new_q = tf.multiply(self.q, tf.cast(mask, tf.float32))
new_q = self.q
q_n = tf.math.multiply(q_neighbours, tf.stop_gradient(new_q))
q_n = tf.reduce_sum(q_n, axis=-1)
qq = -tf.reduce_mean(q_n)
return qq
def triplet_loss(anchor, positive, negative, alpha):
with tf.variable_scope('triplet_loss'):
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)
basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)
loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)
return loss
def _softmax_cross_entropy_mme(logits, label):
"""Helper function to compute softmax cross entropy loss."""
with tf.name_scope("softmax_cross_entropy"):
batch_size = tf.shape(logits)[0]
num_boxes = tf.shape(logits)[1]
num_classes = tf.shape(logits)[2]
reduce_sum_filter = tf.fill([1, 1, num_classes, 1],
1.0,
name="reduce_sum_filter")
logits = tf.reshape(logits, [1, batch_size, num_boxes, num_classes])
logits_t = tf.transpose(logits, perm=(0, 1, 3, 2), name="logits_t")
reduce_max = tf.reduce_max(logits_t, 2, name="reduce_max")
max_logits = tf.reshape(reduce_max, [1, batch_size, num_boxes, 1],
name="max_logits")
shifted_logits = tf.subtract(logits, max_logits, name="shifted_logits")
exp_shifted_logits = tf.math.exp(shifted_logits,
name="exp_shifted_logits")
# MME was idle during classification_loss computation.
# In this case, conv2d is equvalent to reduce_sum but reduce_sum is executed on TPC while conv2d on MME.
sum_exp = tf.nn.conv2d(exp_shifted_logits,
reduce_sum_filter,
strides=1,
padding="VALID",
name="sum_exp")
log_sum_exp = tf.math.log(sum_exp, name="log_sum_exp")
one_hot_label = tf.one_hot(label, num_classes, name="one_hot_label")
# MME was idle during classification_loss computation.
# In this case, conv2d is equvalent to reduce_sum but reduce_sum is executed on TPC while conv2d on MME.
shifted_logits2 = tf.nn.conv2d(shifted_logits * one_hot_label,
reduce_sum_filter,
strides=1,
padding="VALID",
name="shifted_logits2")
loss = tf.subtract(log_sum_exp, shifted_logits2, name="loss/sub")
loss = tf.reshape(loss, [batch_size, -1], name="loss")
def grad(dy):
with tf.name_scope("gradients/softmax_cross_entropy"):
dy_reshaped = tf.reshape(dy, [1, batch_size, num_boxes, 1],
name="dy/Reshape")
div = tf.math.truediv(exp_shifted_logits, sum_exp, name="div")
sub = tf.math.subtract(div, one_hot_label, name="sub")
ret = tf.math.multiply(sub, dy_reshaped, name="mul")
reshaped_ret = tf.reshape(ret,
[batch_size, num_boxes, num_classes],
name="Reshape")
return reshaped_ret, dy
return loss, grad
def _read_and_decode(filename_queue, image_pixel=96, distort=0):
"""Read a norb tf record file."""
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
features = tf.parse_single_example(
serialized_example,
# Defaults are not specified since both keys are required.
features={
'image_raw': tf.FixedLenFeature([], tf.string),
'label': tf.FixedLenFeature([], tf.int64),
'height': tf.FixedLenFeature([], tf.int64),
'width': tf.FixedLenFeature([], tf.int64),
'depth': tf.FixedLenFeature([], tf.int64),
'meta': tf.FixedLenFeature([4], tf.int64),
})
# Convert from a scalar string tensor (whose single string has
# length image_pixels) to a uint8 tensor with shape
# [image_pixels].
image = tf.decode_raw(features['image_raw'], tf.uint8)
height = tf.cast(features['height'], tf.int32)
depth = tf.cast(features['depth'], tf.int32)
image = tf.reshape(image, tf.stack([depth, height, height]))
image = tf.transpose(image, [1, 2, 0])
image = tf.cast(image, tf.float32)
if image_pixel < 96:
print('image resizing to {}'.format(image_pixel))
image = tf.image.resize_images(image, [image_pixel, image_pixel])
orig_images = image
if image_pixel == 48:
new_dim = 32
elif image_pixel == 32:
new_dim = 22
if distort == 1:
image = tf.image.random_brightness(image, max_delta=63)
image = tf.image.random_contrast(image, lower=0.2, upper=1.8)
image = tf.random_crop(image, tf.stack([new_dim, new_dim, depth]))
# 0.26179938779 is 15 degress in radians
image = tf.image.per_image_standardization(image)
image_pixel = new_dim
elif distort == 2:
image = tf.image.resize_image_with_crop_or_pad(image, new_dim, new_dim)
image = tf.image.per_image_standardization(image)
image_pixel = new_dim
else:
image = image * (1.0 / 255.0)
image = tf.div(
tf.subtract(image, tf.reduce_min(image)),
tf.subtract(tf.reduce_max(image), tf.reduce_min(image)))
# Convert label from a scalar uint8 tensor to an int32 scalar.
label = tf.cast(features['label'], tf.int32)
return image, label, image_pixel, orig_images
def cindex_score(y_true, y_pred):
g = tf.subtract(tf.expand_dims(y_pred, -1), y_pred)
g = tf.cast(g == 0.0, tf.float32) * 0.5 + tf.cast(g > 0.0, tf.float32)
f = tf.subtract(tf.expand_dims(y_true, -1), y_true) > 0.0
f = tf.matrix_band_part(tf.cast(f, tf.float32), -1, 0)
g = tf.reduce_sum(tf.multiply(g, f))
f = tf.reduce_sum(f)
return tf.where(tf.equal(g, 0), 0.0, g / f) #select
def rescale_input(x):
"""Rescales image input to be in range [0,1]."""
current_min = tf.reduce_min(x)
current_max = tf.reduce_max(x)
# we add an epsilon value to prevent division by zero
epsilon = 1e-5
rescaled_x = tf.div(
tf.subtract(x, current_min),
tf.maximum(tf.subtract(current_max, current_min), epsilon))
return rescaled_x
def tf_2d_normal(x1, x2, mu1, mu2, s1, s2, rho):
"""Returns result of eq # 24 of http://arxiv.org/abs/1308.0850."""
norm1 = tf.subtract(x1, mu1)
norm2 = tf.subtract(x2, mu2)
s1s2 = tf.multiply(s1, s2)
# eq 25
z = (tf.square(tf.div(norm1, s1)) + tf.square(tf.div(norm2, s2)) -
2 * tf.div(tf.multiply(rho, tf.multiply(norm1, norm2)), s1s2))
neg_rho = 1 - tf.square(rho)
result = tf.exp(tf.div(-z, 2 * neg_rho))
denom = 2 * np.pi * tf.multiply(s1s2, tf.sqrt(neg_rho))
result = tf.div(result, denom)
return result
def _gast(self, pre_s, s_bar, update_gate=None, forget_gate=None):
"""Gated Additive State Transition."""
assert not all([update_gate is None, forget_gate is None])
# Couple gates if necessary
if forget_gate is None: forget_gate = tf.subtract(1.0, update_gate)
elif update_gate is None: update_gate = tf.subtract(1.0, forget_gate)
# Apply recurrent dropout without memory loss if necessary
if self._dropout_rate > 0:
s_bar = self.dropout(s_bar, self._dropout_rate)
# Update states
with tf.name_scope('GAST'):
return tf.add(tf.multiply(forget_gate, pre_s),
tf.multiply(update_gate, s_bar))
def contastiveLoss(self, margin = 5.0):# not used in triplet
with tf.variable_scope("triplet") as scope:
labels = self.tf_Y
# Euclidean distance squared
dist = tf.pow(tf.subtract(self.outputA, self.outputB), 2, name = 'Dw')
Dw = tf.reduce_sum(dist, 1)
# add 1e-6 to increase the stability of calculating the gradients
Dw2 = tf.sqrt(Dw + 1e-6, name = 'Dw2')
# Loss function
lossSimilar = tf.multiply(labels, tf.pow(Dw2,2), name = 'constrastiveLoss_1')
lossDissimilar = tf.multiply(tf.subtract(1.0, labels), tf.pow(tf.maximum(tf.subtract(margin, Dw2), 0), 2), name = 'constrastiveLoss_2')
loss = tf.reduce_mean(tf.add(lossSimilar, lossDissimilar), name = 'constrastiveLoss')
return loss
def loss_with_step(self):
margin = 5.0
labels_t = self.y_
labels_f = tf.subtract(1.0, self.y_, name="1-yi") # labels_ = !labels;
eucd2 = tf.pow(tf.subtract(self.o1, self.o2), 2)
eucd2 = tf.reduce_sum(eucd2, 1)
eucd = tf.sqrt(eucd2 + 1e-6, name="eucd")
C = tf.constant(margin, name="C")
pos = tf.multiply(labels_t, eucd, name="y_x_eucd")
neg = tf.multiply(labels_f,
tf.maximum(0.0, tf.subtract(C, eucd)),
name="Ny_C-eucd")
losses = tf.add(pos, neg, name="losses")
loss = tf.reduce_mean(losses, name="loss")
return loss
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 __init__(self, name, input_size, output_size, size_layer,
learning_rate):
with tf.variable_scope(name):
self.X = tf.placeholder(tf.float32, (None, None, input_size))
self.Y = tf.placeholder(tf.float32, (None, output_size))
self.hidden_layer = tf.placeholder(tf.float32,
(None, 2 * size_layer))
self.REWARD = tf.placeholder(tf.float32, (None, 1))
feed_critic = tf.layers.dense(self.X,
size_layer,
activation=tf.nn.relu)
cell = tf.nn.rnn_cell.LSTMCell(size_layer, state_is_tuple=False)
self.rnn, self.last_state = tf.nn.dynamic_rnn(
inputs=self.X,
cell=cell,
dtype=tf.float32,
initial_state=self.hidden_layer)
tensor_action, tensor_validation = tf.split(self.rnn[:, -1], 2, 1)
feed_action = tf.layers.dense(tensor_action, output_size)
feed_validation = tf.layers.dense(tensor_validation, 1)
feed_critic = feed_validation + tf.subtract(
feed_action, tf.reduce_mean(
feed_action, axis=1, keep_dims=True))
feed_critic = tf.nn.relu(feed_critic) + self.Y
feed_critic = tf.layers.dense(feed_critic,
size_layer // 2,
activation=tf.nn.relu)
self.logits = tf.layers.dense(feed_critic, 1)
self.cost = tf.reduce_mean(tf.square(self.REWARD - self.logits))
self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(
self.cost)
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 _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 _build_model(self):
self.graph_built = True
tf.set_random_seed(self.seed)
self.labels = tf.placeholder(tf.float32, shape=[None])
self.is_training = tf.placeholder_with_default(False, shape=[])
self.linear_embed, self.pairwise_embed, self.deep_embed = [], [], []
self._build_user_item()
if self.sparse:
self._build_sparse()
if self.dense:
self._build_dense()
linear_embed = tf.concat(self.linear_embed, axis=1)
pairwise_embed = tf.concat(self.pairwise_embed, axis=1)
deep_embed = tf.concat(self.deep_embed, axis=1)
linear_term = tf.layers.dense(linear_embed, units=1, activation=None)
pairwise_term = 0.5 * tf.subtract(
tf.square(tf.reduce_sum(pairwise_embed, axis=1)),
tf.reduce_sum(tf.square(pairwise_embed), axis=1)
)
deep_term = dense_nn(deep_embed,
self.hidden_units,
use_bn=self.use_bn,
dropout_rate=self.dropout_rate,
is_training=self.is_training)
concat_layer = tf.concat(
[linear_term, pairwise_term, deep_term], axis=1)
self.output = tf.squeeze(
tf.layers.dense(concat_layer, units=1, activation=None))
count_params()
def hinge_loss(self, aff, neg_aff):
"""Maximum-margin optimization using the hinge loss."""
diff = tf.nn.relu(tf.subtract(neg_aff,
tf.expand_dims(aff, 0) - self.margin),
name='diff')
loss = tf.reduce_sum(diff)
return loss
def cifar_process(image, augmentation=True):
"""Map function for cifar dataset.
Args:
image: An image tensor.
augmentation: If True, process train images.
Returns:
A processed image tensor.
"""
# label = tf.cast(label, dtype=tf.int32)
image = tf.math.divide(tf.cast(image, dtype=tf.float32), 255.0)
if augmentation:
image = tf.image.resize_image_with_crop_or_pad(image, 32 + 4, 32 + 4)
# Randomly crop a [HEIGHT, WIDTH] section of the image.
image = tf.image.random_crop(image, [32, 32, 3])
# Randomly flip the image horizontally.
image = tf.image.random_flip_left_right(image)
image = tf.clip_by_value(image, 0, 1)
image = tf.subtract(image, 0.5)
image = tf.multiply(image, 2.0)
return image
def preprocess_image(image,
output_height,
output_width,
is_training=False,
resize_side_min=_RESIZE_SIDE_MIN,
resize_side_max=_RESIZE_SIDE_MAX):
"""Preprocesses the given image.
Args:
image: A `Tensor` representing an image of arbitrary size.
output_height: The height of the image after preprocessing.
output_width: The width of the image after preprocessing.
is_training: `True` if we're preprocessing the image for training and
`False` otherwise.
resize_side_min: The lower bound for the smallest side of the image for
aspect-preserving resizing. If `is_training` is `False`, then this value
is used for rescaling.
resize_side_max: The upper bound for the smallest side of the image for
aspect-preserving resizing. If `is_training` is `False`, this value is
ignored. Otherwise, the resize side is sampled from
[resize_size_min, resize_size_max].
Returns:
A preprocessed image.
"""
if is_training:
image = preprocess_for_train(image, output_height, output_width,
resize_side_min, resize_side_max)
else:
image = preprocess_for_eval(image, output_height, output_width,
resize_side_min)
image = tf.subtract(image, 0.5)
image = tf.multiply(image, 2.0)
return image
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 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 _hinge_loss(self, inputs1, inputs2, neg_samples, hard_neg_samples=None):
aff = self.affinity(inputs1, inputs2)
neg_aff = self.neg_cost(inputs1, neg_samples, hard_neg_samples)
diff = tf.nn.relu(tf.subtract(neg_aff, tf.expand_dims(aff, 1) - self.margin), name='diff')
loss = tf.reduce_sum(diff)
self.neg_shape = tf.shape(neg_aff)
return loss
