def iou(bbox_1, bbox_2):
"""Compute iou of a box with another box. Box format '[y_min, x_min, y_max, x_max]'.
Args:
bbox_1: 1-D with shape `[4]`.
bbox_2: 1-D with shape `[4]`.
Returns:
IOU
"""
lr = tf.minimum(bbox_1[3], bbox_2[3]) - tf.maximum(bbox_1[1], bbox_2[1])
tb = tf.minimum(bbox_1[2], bbox_2[2]) - tf.maximum(bbox_1[0], bbox_2[0])
lr = tf.maximum(lr, lr * 0)
tb = tf.maximum(tb, tb * 0)
intersection = tf.multiply(tb, lr)
union = tf.subtract(
tf.multiply((bbox_1[3] - bbox_1[1]), (bbox_1[2] - bbox_1[0])) +
tf.multiply((bbox_2[3] - bbox_2[1]), (bbox_2[2] - bbox_2[0])),
intersection
)
iou = tf.div(intersection, union)
return iou
python类div()的实例源码
def iou(bbox_1, bbox_2):
"""Compute iou of a box with another box. Box format '[y_min, x_min, y_max, x_max]'.
Args:
bbox_1: 1-D with shape `[4]`.
bbox_2: 1-D with shape `[4]`.
Returns:
IOU
"""
lr = tf.minimum(bbox_1[3], bbox_2[3]) - tf.maximum(bbox_1[1], bbox_2[1])
tb = tf.minimum(bbox_1[2], bbox_2[2]) - tf.maximum(bbox_1[0], bbox_2[0])
lr = tf.maximum(lr, lr * 0)
tb = tf.maximum(tb, tb * 0)
intersection = tf.multiply(tb, lr)
union = tf.subtract(
tf.multiply((bbox_1[3] - bbox_1[1]), (bbox_1[2] - bbox_1[0])) +
tf.multiply((bbox_2[3] - bbox_2[1]), (bbox_2[2] - bbox_2[0])),
intersection
)
iou = tf.div(intersection, union)
return iou
def preprocess_image(image, output_height, output_width, is_training):
"""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.
Returns:
A preprocessed image.
"""
image = tf.to_float(image)
image = tf.image.resize_image_with_crop_or_pad(
image, output_width, output_height)
image = tf.subtract(image, 128.0)
image = tf.div(image, 128.0)
return image
def __init__(self, action_bounds):
self.graph = tf.Graph()
with self.graph.as_default():
self.sess = tf.Session()
self.action_size = len(action_bounds[0])
self.action_input = tf.placeholder(tf.float32, [None, self.action_size])
self.pmax = tf.constant(action_bounds[0], dtype = tf.float32)
self.pmin = tf.constant(action_bounds[1], dtype = tf.float32)
self.prange = tf.constant([x - y for x, y in zip(action_bounds[0],action_bounds[1])], dtype = tf.float32)
self.pdiff_max = tf.div(-self.action_input+self.pmax, self.prange)
self.pdiff_min = tf.div(self.action_input - self.pmin, self.prange)
self.zeros_act_grad_filter = tf.zeros([self.action_size])
self.act_grad = tf.placeholder(tf.float32, [None, self.action_size])
self.grad_inverter = tf.select(tf.greater(self.act_grad, self.zeros_act_grad_filter), tf.mul(self.act_grad, self.pdiff_max), tf.mul(self.act_grad, self.pdiff_min))
def __init__(self, lin, lout, iniRange, graph= None):
if graph!=None:
with graph.as_default():
self.v = tf.Variable(tf.random_uniform([lin, lout], iniRange[0], iniRange[1]))
self.g = tf.Variable(tf.random_uniform([lout], -1.0,1.0))
self.pow2 = tf.fill([lin, lout],2.0)
self.v_norm = tf.sqrt(tf.reduce_sum(tf.pow(self.v, self.pow2),0))
self.tile_div = tf.tile(tf.expand_dims(tf.div(self.g, self.v_norm),0),[lin, 1])
self.w = tf.mul(self.tile_div, self.v)
else:
self.v = tf.Variable(tf.random_uniform([lin, lout], -1/math.sqrt(lin), 1/math.sqrt(lin)))
self.g = tf.Variable(tf.random_uniform([lout], -1.0,1.0))
self.pow2 = tf.fill([lin, lout],2.0)
self.v_norm = tf.sqrt(tf.reduce_sum(tf.pow(self.v, self.pow2),0))
self.tile_div = tf.tile(tf.expand_dims(tf.div(self.g, self.v_norm),0),[lin, 1])
self.w = tf.mul(self.tile_div, self.v)
def my_clustering_loss(net_out,feature_map):
net_out_vec = tf.reshape(net_out,[-1,1])
pix_num = net_out_vec.get_shape().as_list()[0]
feature_vec = tf.reshape(feature_map,[pix_num,-1])
net_out_vec = tf.div(net_out_vec, tf.reduce_sum(net_out_vec,keep_dims=True))
not_net_out_vec = tf.subtract(tf.constant(1.),net_out_vec)
mean_fg_var = tf.get_variable('mean_bg',shape = [feature_vec.get_shape().as_list()[1],1], trainable=False)
mean_bg_var = tf.get_variable('mean_fg',shape = [feature_vec.get_shape().as_list()[1],1], trainable=False)
mean_bg = tf.matmul(not_net_out_vec,feature_vec,True)
mean_fg = tf.matmul(net_out_vec,feature_vec,True)
feature_square = tf.square(feature_vec)
loss = tf.add(tf.matmul(net_out_vec, tf.reduce_sum(tf.square(tf.subtract(feature_vec, mean_fg_var)), 1, True), True),
tf.matmul(not_net_out_vec, tf.reduce_sum(tf.square(tf.subtract(feature_vec,mean_bg_var)), 1, True), True))
with tf.control_dependencies([loss]):
update_mean = tf.group(tf.assign(mean_fg_var,mean_fg),tf.assign(mean_bg_var,mean_bg))
tf.add_to_collection(tf.GraphKeys.UPDATE_OPS, update_mean)
return loss
def instance_norm(inputs):
epsilon = 1e-9 # ??0??
# ? [1, 2]?????feature map??????&??
mean, var = tf.nn.moments(inputs, [1, 2], keep_dims=True)
return tf.div(inputs - mean, tf.sqrt(tf.add(var, epsilon)))
def calculate_loss(self, predictions, labels, **unused_params):
with tf.name_scope("loss_softmax"):
epsilon = 10e-8
float_labels = tf.cast(labels, tf.float32)
# l1 normalization (labels are no less than 0)
label_rowsum = tf.maximum(
tf.reduce_sum(float_labels, 1, keep_dims=True),
epsilon)
norm_float_labels = tf.div(float_labels, label_rowsum)
softmax_outputs = tf.nn.softmax(predictions)
softmax_loss = tf.negative(tf.reduce_sum(
tf.multiply(norm_float_labels, tf.log(softmax_outputs)), 1))
return tf.reduce_mean(softmax_loss)
def calculate_loss(self, predictions, labels, **unused_params):
with tf.name_scope("loss_softmax"):
epsilon = 10e-8
float_labels = tf.cast(labels, tf.float32)
# l1 normalization (labels are no less than 0)
label_rowsum = tf.maximum(
tf.reduce_sum(float_labels, 1, keep_dims=True),
epsilon)
norm_float_labels = tf.div(float_labels, label_rowsum)
softmax_outputs = tf.nn.softmax(predictions)
softmax_loss = tf.negative(tf.reduce_sum(
tf.multiply(norm_float_labels, tf.log(softmax_outputs)), 1))
return tf.reduce_mean(softmax_loss)
def length_penalty(sequence_lengths, penalty_factor):
"""Calculates the length penalty according to
https://arxiv.org/abs/1609.08144
Args:
sequence_lengths: The sequence length of all hypotheses, a tensor
of shape [beam_size, vocab_size].
penalty_factor: A scalar that weights the length penalty.
Returns:
The length penalty factor, a tensor fo shape [beam_size].
"""
return tf.div((5. + tf.to_float(sequence_lengths))**penalty_factor, (5. + 1.)
**penalty_factor)
def GaussianLogDensity(x, mu, log_var, name='GaussianLogDensity'):
with tf.name_scope(name):
c = tf.log(2. * PI)
var = tf.exp(log_var)
x_mu2 = tf.square(x - mu) # [Issue] not sure the dim works or not?
x_mu2_over_var = tf.div(x_mu2, var + EPSILON)
log_prob = -0.5 * (c + log_var + x_mu2_over_var)
log_prob = tf.reduce_sum(log_prob, -1) # keep_dims=True,
return log_prob
def GaussianKLD(mu1, lv1, mu2, lv2):
''' Kullback-Leibler divergence of two Gaussians
*Assuming that each dimension is independent
mu: mean
lv: log variance
Equation: http://stats.stackexchange.com/questions/7440/kl-divergence-between-two-univariate-gaussians
'''
with tf.name_scope('GaussianKLD'):
v1 = tf.exp(lv1)
v2 = tf.exp(lv2)
mu_diff_sq = tf.square(mu1 - mu2)
dimwise_kld = .5 * (
(lv2 - lv1) + tf.div(v1 + mu_diff_sq, v2 + EPSILON) - 1.)
return tf.reduce_sum(dimwise_kld, -1)
# Verification by CMU's implementation
# http://www.cs.cmu.edu/~chanwook/MySoftware/rm1_Spk-by-Spk_MLLR/rm1_PNCC_MLLR_1/rm1/python/sphinx/divergence.py
# def gau_kl(pm, pv, qm, qv):
# """
# Kullback-Liebler divergence from Gaussian pm,pv to Gaussian qm,qv.
# Also computes KL divergence from a single Gaussian pm,pv to a set
# of Gaussians qm,qv.
# Diagonal covariances are assumed. Divergence is expressed in nats.
# """
# if (len(qm.shape) == 2):
# axis = 1
# else:
# axis = 0
# # Determinants of diagonal covariances pv, qv
# dpv = pv.prod()
# dqv = qv.prod(axis)
# # Inverse of diagonal covariance qv
# iqv = 1./qv
# # Difference between means pm, qm
# diff = qm - pm
# return (0.5 *
# (np.log(dqv / dpv) # log |\Sigma_q| / |\Sigma_p|
# + (iqv * pv).sum(axis) # + tr(\Sigma_q^{-1} * \Sigma_p)
# + (diff * iqv * diff).sum(axis) # + (\mu_q-\mu_p)^T\Sigma_q^{-1}(\mu_q-\mu_p)
# - len(pm))) # - N
def regretion_loss(outputs,target_y,batch_size=BATCHSIZE,n_steps=TIMESTEP):
target_y=tf.reshape(target_y, [-1,LONGITUDE, WIDTH])
outputs=tf.reshape(outputs,[-1,LONGITUDE, WIDTH])
losses = tf.contrib.legacy_seq2seq.sequence_loss_by_example(
[tf.reshape(outputs, [-1], name='reshape_pred')],
[tf.reshape(target_y, [-1], name='reshape_target')],
[tf.ones([batch_size * n_steps], dtype=tf.float32)],
average_across_timesteps=True,
softmax_loss_function=tf.square(tf.subtract(target_y, outputs)),
name='losses')
with tf.name_scope('average_cost'):
cost = tf.div(
tf.reduce_sum(losses, name='losses_sum'),batch_size,name='average_cost')
return cost
def pixel_wise_softmax(output_map):
exponential_map = tf.exp(output_map)
evidence = tf.add(exponential_map,tf.reverse(exponential_map,[False,False,False,True]))
return tf.div(exponential_map,evidence, name="pixel_wise_softmax")
def pixel_wise_softmax_2(output_map):
exponential_map = tf.exp(output_map)
sum_exp = tf.reduce_sum(exponential_map, 3, keep_dims=True)
tensor_sum_exp = tf.tile(sum_exp, tf.stack([1, 1, 1, tf.shape(output_map)[3]]))
return tf.div(exponential_map,tensor_sum_exp)
def resizeToGlimpse(image):
finalShape = tf.constant(glimpseBandwidth, shape=[3])
currentShape = tf.cast(image.get_shape().as_list(), tf.float32)
zoomFactor = tf.div(finalShape, currentShape)
return scipy.ndarray.interpolation.zoom(image, zoom=zoomFactor)
def __init__(self, action_bounds):
self.sess = tf.InteractiveSession()
self.action_size = len(action_bounds[0])
self.action_input = tf.placeholder(tf.float32, [None, self.action_size])
self.pmax = tf.constant(action_bounds[0], dtype = tf.float32)
self.pmin = tf.constant(action_bounds[1], dtype = tf.float32)
self.prange = tf.constant([x - y for x, y in zip(action_bounds[0],action_bounds[1])], dtype = tf.float32)
self.pdiff_max = tf.div(-self.action_input+self.pmax, self.prange)
self.pdiff_min = tf.div(self.action_input - self.pmin, self.prange)
self.zeros_act_grad_filter = tf.zeros([self.action_size])
self.act_grad = tf.placeholder(tf.float32, [None, self.action_size])
self.grad_inverter = tf.select(tf.greater(self.act_grad, self.zeros_act_grad_filter), tf.mul(self.act_grad, self.pdiff_max), tf.mul(self.act_grad, self.pdiff_min))
def gumbel_softmax_sample(logits, temperature):
""" Draw a sample from the Gumbel-Softmax distribution"""
y = tf.add(logits,sample_gumbel(tf.shape(logits)))
return tf.nn.softmax( tf.div(y, temperature))
def weighted_binary_crossentropy(feature_weights):
def loss(y_true, y_pred):
# try:
# x = K.binary_crossentropy(y_pred, y_true)
# # y = tf.Variable(feature_weights.astype('float32'))
# # z = K.dot(x, y)
# y_true = tf.pow(y_true + 1e-5, .75)
# y2 = tf.div(y_true, tf.reshape(K.sum(y_true, 1), [-1, 1]))
# z = K.sum(tf.mul(x, y2), 1)
# except Exception as e:
# print e
# import pdb;pdb.set_trace()
# return z
return K.dot(K.binary_crossentropy(y_pred, y_true), K.variable(feature_weights.astype('float32')))
return loss
def __call__(self, prev_output):
""" Use TODO formula
Args:
prev_output (tf.Tensor): the ouput on which applying the transformation
Return:
tf.Ops: the processing operator
"""
# prev_output size: [batch_size, nb_labels]
nb_labels = prev_output.get_shape().as_list()[-1]
if False: # TODO: Add option to control argmax
#label_draws = tf.argmax(prev_output, 1)
label_draws = tf.multinomial(tf.log(prev_output), 1) # Draw 1 sample from the distribution
label_draws = tf.squeeze(label_draws, [1])
self.chosen_labels.append(label_draws)
next_input = tf.one_hot(label_draws, nb_labels)
return next_input
# Could use the Gumbel-Max trick to sample from a softmax distribution ?
soft_values = tf.exp(tf.div(prev_output, self.temperature)) # Pi = exp(pi/t)
# soft_values size: [batch_size, nb_labels]
normalisation_coeff = tf.expand_dims(tf.reduce_sum(soft_values, 1), -1)
# normalisation_coeff size: [batch_size, 1]
probs = tf.div(soft_values, normalisation_coeff + 1e-8) # = Pi / sum(Pk)
# probs size: [batch_size, nb_labels]
label_draws = tf.multinomial(tf.log(probs), 1) # Draw 1 sample from the log-probability distribution
# probs label_draws: [batch_size, 1]
label_draws = tf.squeeze(label_draws, [1])
# label_draws size: [batch_size,]
self.chosen_labels.append(label_draws)
next_input = tf.one_hot(label_draws, nb_labels) # Reencode the next input vector
# next_input size: [batch_size, nb_labels]
return next_input
