我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tensorflow.div()。
def calculate_loss(self, predictions, labels, **unused_params): bound = FLAGS.softmax_bound vocab_size_1 = bound with tf.name_scope("loss_softmax"): epsilon = 10e-8 float_labels = tf.cast(labels, tf.float32) labels_1 = float_labels[:,:vocab_size_1] predictions_1 = predictions[:,:vocab_size_1] cross_entropy_loss = CrossEntropyLoss().calculate_loss(predictions_1,labels_1) lables_2 = float_labels[:,vocab_size_1:] predictions_2 = predictions[:,vocab_size_1:] # l1 normalization (labels are no less than 0) label_rowsum = tf.maximum( tf.reduce_sum(lables_2, 1, keep_dims=True), epsilon) label_append = 1.0-tf.reduce_max(lables_2, 1, keep_dims=True) norm_float_labels = tf.concat((tf.div(lables_2, label_rowsum),label_append),axis=1) predictions_append = 1.0-tf.reduce_sum(predictions_2, 1, keep_dims=True) softmax_outputs = tf.concat((predictions_2,predictions_append),axis=1) softmax_loss = norm_float_labels * tf.log(softmax_outputs + epsilon) + ( 1 - norm_float_labels) * tf.log(1 - softmax_outputs + epsilon) softmax_loss = tf.negative(tf.reduce_sum(softmax_loss, 1)) return tf.reduce_mean(softmax_loss) + cross_entropy_loss
def discriminator(self, image, reuse=False): with tf.variable_scope("discriminator") as scope: if reuse: scope.reuse_variables() image_norm = tf.div(image, 255.) h0 = lrelu(conv2d(image_norm, self.df_dim, name='d_h0_conv')) h1 = lrelu(self.d_bn1(conv2d(h0, self.df_dim*2, name='d_h1_conv'))) h2 = lrelu(self.d_bn2(conv2d(h1, self.df_dim*4, name='d_h2_conv'))) h3 = lrelu(self.d_bn3(conv2d(h2, self.df_dim*8, name='d_h3_conv'))) h4 = linear(tf.reshape(h3, [self.batch_size, -1]), 1, 'd_h3_lin') # Prevent NAN h4 += 1e-5 h4_ = tf.nn.sigmoid(h4) + 1e-5 return h4_, h4
def compute_cost(self): losses = tf.nn.seq2seq.sequence_loss_by_example( [tf.reshape(self.pred, [-1], name='reshape_pred')], [tf.reshape(self.ys, [-1], name='reshape_target')], [tf.ones([self.batch_size * self.n_steps], dtype=tf.float32)], average_across_timesteps=True, softmax_loss_function=self.ms_error, name='losses' ) with tf.name_scope('average_cost'): self.cost = tf.div( tf.reduce_sum(losses, name='losses_sum'), self.batch_size, name='average_cost') tf.summary.scalar('cost', self.cost)
def compute_cost(self): losses = tf.nn.seq2seq.sequence_loss_by_example( [tf.reshape(self.pred, [-1], name='reshape_pred')], [tf.reshape(self.ys, [-1], name='reshape_target')], [tf.ones([self.batch_size * self.n_steps], dtype=tf.float32)], average_across_timesteps=True, softmax_loss_function=self.ms_error, name='losses' ) with tf.name_scope('average_cost'): self.cost = tf.div( tf.reduce_sum(losses, name='losses_sum'), self.batch_size, name='average_cost') tf.scalar_summary('cost', self.cost)
def fixed_dropout(xs, keep_prob, noise_shape, seed=None): """ Apply dropout with same mask over all inputs Args: xs: list of tensors keep_prob: noise_shape: seed: Returns: list of dropped inputs """ with tf.name_scope("dropout", values=xs): noise_shape = noise_shape # uniform [keep_prob, 1.0 + keep_prob) random_tensor = keep_prob random_tensor += tf.random_uniform(noise_shape, seed=seed, dtype=xs[0].dtype) # 0. if [keep_prob, 1.0) and 1. if [1.0, 1.0 + keep_prob) binary_tensor = tf.floor(random_tensor) outputs = [] for x in xs: ret = tf.div(x, keep_prob) * binary_tensor ret.set_shape(x.get_shape()) outputs.append(ret) return outputs
def __init__(self, name, shape, initial_stdev = 2.0, initial_prec_a = 5.0, initial_prec_b = 1.0, a0 = 1.0, b0 = 1.0, fixed_prec = False, mean_init_std = None): if mean_init_std is None: mean_init_std = 1.0 / np.sqrt(shape[-1]) with tf.variable_scope(name) as scope: #self.mean = tf.get_variable(name="mean", shape=shape, initializer=tf.contrib.layers.xavier_initializer(), dtype = tf.float32) #self.var = tf.Variable(initial_var * np.ones(shape), name = name + ".var", dtype = tf.float32) self.mean = tf.Variable(tf.random_uniform(shape, minval=-mean_init_std, maxval=mean_init_std)) self.logvar = tf.Variable(np.log(initial_stdev**2.0) * np.ones(shape), name = "logvar", dtype = tf.float32) if fixed_prec: self.prec_a = tf.constant(initial_prec_a * np.ones(shape[-1]), name = "prec_a", dtype = tf.float32) self.prec_b = tf.constant(initial_prec_b * np.ones(shape[-1]), name = "prec_b", dtype = tf.float32) else: self.prec_a = tf.Variable(initial_prec_a * np.ones(shape[-1]), name = "prec_a", dtype = tf.float32) self.prec_b = tf.Variable(initial_prec_b * np.ones(shape[-1]), name = "prec_b", dtype = tf.float32) self.prec = tf.div(self.prec_a, self.prec_b, name = "prec") self.var = tf.exp(self.logvar, name = "var") self.a0 = a0 self.b0 = b0 self.shape = shape
def tune(self, acceptance_rate, fresh_start): def adapt_stepsize(): new_step = tf.assign(self.step, (1 - fresh_start) * self.step + 1) rate1 = tf.div(1.0, new_step + self.t0) new_h_bar = tf.assign( self.h_bar, (1 - fresh_start) * (1 - rate1) * self.h_bar + rate1 * (self.delta - acceptance_rate)) log_epsilon = self.mu - tf.sqrt(new_step) / self.gamma * new_h_bar rate = tf.pow(new_step, -self.kappa) new_log_epsilon_bar = tf.assign( self.log_epsilon_bar, rate * log_epsilon + (1 - fresh_start) * (1 - rate) * self.log_epsilon_bar) with tf.control_dependencies([new_log_epsilon_bar]): new_log_epsilon = tf.identity(log_epsilon) return tf.exp(new_log_epsilon) c = tf.cond(self.adapt_step_size, adapt_stepsize, lambda: tf.exp(self.log_epsilon_bar)) return c
def test_binary_ops_combined(self): # computation a = tf.placeholder(tf.float32, shape=(2, 3)) b = tf.placeholder(tf.float32, shape=(2, 3)) c = tf.add(a, b) d = tf.mul(c, a) e = tf.div(d, b) f = tf.sub(a, e) g = tf.maximum(a, f) # value a_val = np.random.rand(*tf_obj_shape(a)) b_val = np.random.rand(*tf_obj_shape(b)) # test self.run(g, tf_feed_dict={a: a_val, b: b_val})
def __declare_variables(self): # Bias variables self.bias = self.__bias_variables([self.num_features], 'bias') self.cias = self.__bias_variables([self.depth], 'cias') # Visible (input) units with tf.name_scope('visible') as _: self.x = self._input if self._input is not None \ else tf.placeholder(tf.float32, shape=self.input_shape, name='x') self.vis_0 = tf.div(self.x, 255, 'vis_0') # Weight variables with tf.name_scope('weights') as _: self.weights = self.__weight_variable(self.weight_shape, 'weights_forward') self.weights_flipped = tf.transpose( tf.reverse(self.weights, [True, True, False, False]), perm=[0, 1, 3, 2], name='weight_back') self.variables = [self.bias, self.cias, self.weights]
def __gibbs_sampling(self): # Gibbs sampling # Sample visible units with tf.name_scope('visible') as _: signal_back = self.__conv2d(self.hid_state0, self.weights_flipped) + self.cias if self.is_continuous: # Visible units are continuous normal_dist = tf.contrib.distributions.Normal( mu=signal_back, sigma=1.) self.vis_1 = tf.reshape( tf.div(normal_dist.sample_n(1), self.weight_size * self.weight_size), self.input_shape, name='vis_1') else: # Visible units are binary vis1_prob = tf.sigmoid(signal_back, name='vis_1') self.vis_1 = self.__sample(vis1_prob, 'vis_1') # Sample hidden units with tf.name_scope('hidden') as _: self.hid_prob1 = tf.sigmoid(self.__conv2d(self.vis_1, self.weights) + self.bias, name='hid_prob_1')
def _impute2D(self, X_2D): r"""Mean impute a rank 2 tensor.""" # Fill zeros in for missing data initially data_zeroed_missing_tf = X_2D * self.real_val_mask # Sum the real values in each column col_tot = tf.reduce_sum(data_zeroed_missing_tf, 0) # Divide column totals by the number of non-nan values num_values_col = tf.reduce_sum(self.real_val_mask, 0) num_values_col = tf.maximum(num_values_col, tf.ones(tf.shape(num_values_col))) col_nan_means = tf.div(col_tot, num_values_col) # Make an vector of the impute values for each missing point imputed_vals = tf.gather(col_nan_means, self.missing_ind[:, 1]) # Fill the imputed values into the data tensor of zeros shape = tf.cast(tf.shape(data_zeroed_missing_tf), dtype=tf.int64) missing_imputed = tf.scatter_nd(self.missing_ind, imputed_vals, shape) X_with_impute = data_zeroed_missing_tf + missing_imputed return X_with_impute
def linear_mapping_weightnorm(inputs, out_dim, in_dim=None, dropout=1.0, var_scope_name="linear_mapping"): with tf.variable_scope(var_scope_name): input_shape = inputs.get_shape().as_list() # static shape. may has None input_shape_tensor = tf.shape(inputs) # use weight normalization (Salimans & Kingma, 2016) w = g* v/2-norm(v) V = tf.get_variable('V', shape=[int(input_shape[-1]), out_dim], dtype=tf.float32, initializer=tf.random_normal_initializer(mean=0, stddev=tf.sqrt(dropout*1.0/int(input_shape[-1]))), trainable=True) V_norm = tf.norm(V.initialized_value(), axis=0) # V shape is M*N, V_norm shape is N g = tf.get_variable('g', dtype=tf.float32, initializer=V_norm, trainable=True) b = tf.get_variable('b', shape=[out_dim], dtype=tf.float32, initializer=tf.zeros_initializer(), trainable=True) # weightnorm bias is init zero assert len(input_shape) == 3 inputs = tf.reshape(inputs, [-1, input_shape[-1]]) inputs = tf.matmul(inputs, V) inputs = tf.reshape(inputs, [input_shape_tensor[0], -1, out_dim]) #inputs = tf.matmul(inputs, V) # x*v scaler = tf.div(g, tf.norm(V, axis=0)) # g/2-norm(v) inputs = tf.reshape(scaler,[1, out_dim])*inputs + tf.reshape(b,[1, out_dim]) # x*v g/2-norm(v) + b return inputs
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): self.history = StateProcessorSetting.history_length self.dims = StateProcessorSetting.observation_dims pass #get current,prev frame, set by env with tf.variable_scope('input', reuse =True): self.cur_frame = tf.get_variable('cur_frame',dtype = tf.uint8) self.prev_frame = tf.get_variable('prev_frame',dtype = tf.uint8) with tf.variable_scope('input'): maxOf2 = tf.maximum(tf.to_float(self.cur_frame), tf.to_float(self.prev_frame)) toGray = tf.expand_dims(tf.image.rgb_to_grayscale(maxOf2), 0) resize = tf.image.resize_bilinear(toGray, self.dims, align_corners=None, name='observation') self.observe = tf.div(tf.squeeze(resize), 255.0) self.state = tf.get_variable(name = 'state', shape = [self.dims[0],self.dims[1],self.history], dtype = tf.float32,initializer = tf.constant_initializer(0.0),trainable = False) self.to_stack = tf.expand_dims(self.observe, 2) self.f3, self.f2, self.f1, _ = tf.split(2, self.history, self.state) # each is 84x84x1 self.concat = tf.concat(2, [self.to_stack, self.f3, self.f2, self.f1], name='concat') self.updateState = self.state.assign(self.concat)
def style_loss(self, layers): activations = [self.activations_for_layer(i) for i in layers] gramians = [self.gramian_for_layer(x) for x in layers] # Slices are for style and synth image gramian_diffs = [ tf.sub( tf.tile(tf.slice(g, [0, 0, 0], [self.num_style, -1, -1]), [self.num_synthesized - self.num_style + 1, 1, 1]), tf.slice(g, [self.num_style + self.num_content, 0, 0], [self.num_synthesized, -1, -1])) for g in gramians] Ns = [g.get_shape().as_list()[2] for g in gramians] Ms = [a.get_shape().as_list()[1] * a.get_shape().as_list()[2] for a in activations] scaled_diffs = [tf.square(g) for g in gramian_diffs] style_loss = tf.div( tf.add_n([tf.div(tf.reduce_sum(x), 4 * (N ** 2) * (M ** 2)) for x, N, M in zip(scaled_diffs, Ns, Ms)]), len(layers)) return style_loss
def classification_costs(logits, labels, name=None): """Compute classification cost mean and classification cost per sample Assume unlabeled examples have label == -1. For unlabeled examples, cost == 0. Compute the mean over all examples. Note that unlabeled examples are treated differently in error calculation. """ with tf.name_scope(name, "classification_costs") as scope: applicable = tf.not_equal(labels, -1) # Change -1s to zeros to make cross-entropy computable labels = tf.where(applicable, labels, tf.zeros_like(labels)) # This will now have incorrect values for unlabeled examples per_sample = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels) # Retain costs only for labeled per_sample = tf.where(applicable, per_sample, tf.zeros_like(per_sample)) # Take mean over all examples, not just labeled examples. labeled_sum = tf.reduce_sum(per_sample) total_count = tf.to_float(tf.shape(per_sample)[0]) mean = tf.div(labeled_sum, total_count, name=scope) return mean, per_sample
def _init_clusters_random(data, num_clusters, random_seed): """Does random initialization of clusters. Args: data: a list of Tensors with a matrix of data, each row is an example. num_clusters: an integer with the number of clusters. random_seed: Seed for PRNG used to initialize seeds. Returns: A Tensor with num_clusters random rows of data. """ assert isinstance(data, list) num_data = tf.add_n([tf.shape(inp)[0] for inp in data]) with tf.control_dependencies([tf.assert_less_equal(num_clusters, num_data)]): indices = tf.random_uniform([num_clusters], minval=0, maxval=tf.cast(num_data, tf.int64), seed=random_seed, dtype=tf.int64) indices = tf.cast(indices, tf.int32) % num_data clusters_init = embedding_lookup(data, indices, partition_strategy='div') return clusters_init
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.sub(image, 128.0) image = tf.div(image, 128.0) return image
def instance_norm(x): with tf.variable_scope("instance_norm"): epsilon = 1e-5 mean, var = tf.nn.moments(x, [1, 2], keep_dims=True) scale = tf.get_variable('scale', [x.get_shape()[-1]], initializer=tf.truncated_normal_initializer( mean=1.0, stddev=0.02 )) offset = tf.get_variable( 'offset', [x.get_shape()[-1]], initializer=tf.constant_initializer(0.0) ) out = scale * tf.div(x - mean, tf.sqrt(var + epsilon)) + offset return out
def tf_2d_normal(x1, x2, mu1, mu2, s1, s2, rho): """ 2D normal distribution input - x,mu: input vectors - s1,s2: standard deviances over x1 and x2 - rho: correlation coefficient in x1-x2 plane """ # eq # 24 and 25 of http://arxiv.org/abs/1308.0850 norm1 = tf.sub(x1, mu1) norm2 = tf.sub(x2, mu2) s1s2 = tf.mul(s1, s2) z = tf.square(tf.div(norm1, s1))+tf.square(tf.div(norm2, s2))-2.0*tf.div(tf.mul(rho, tf.mul(norm1, norm2)), s1s2) negRho = 1-tf.square(rho) result = tf.exp(tf.div(-1.0*z,2.0*negRho)) denom = 2*np.pi*tf.mul(s1s2, tf.sqrt(negRho)) px1x2 = tf.div(result, denom) return px1x2
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.sub(image, 128.0) image = tf.div(image, 128.0) return image
def _get_loss(self, name): return tf.reduce_mean(tf.multiply(self.target/tf.reduce_mean(self.target), tf.div(tf.log1p(self.target), tf.log1p(self.output))), name=name) ''' return tf.reduce_mean(tf.multiply(tf.log1p(self.target/tf.reduce_mean(self.target)), tf.abs(tf.subtract(self.target, self.output))), name=name) return tf.reduce_mean(tf.multiply(self.target/tf.reduce_mean(self.target), tf.abs(tf.subtract(self.target, self.output))), name=name) return tf.reduce_mean(tf.multiply(1.0, tf.abs(tf.subtract(self.target, self.output))), name=name) '''
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 __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 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
