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] # (M samples, dimension per image) # 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.substract(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.substract(anchor, negative)), axis=-1) # Step 3: subtract the two previous distances and add alpha. # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples. loss = tf.reduce_sum(basic_loss) return loss
def _smmoth_l1(sigma, box_pred, box_targets, box_inside_weights, box_outside_weights): """ loss = bbox_outside_weights*smoothL1(inside_weights * (box_pred - box_targets)) smoothL1(x) = 0.5*(sigma*x)^2, if |x| < 1 / sigma^2 |x| - 0.5 / sigma^2, otherwise """ sigma2 = sigma * sigma inside_mul = tf.multiply(box_inside_weights, tf.substract(box_pred, box_targets)) smooth_l1_sign = tf.cast(tf.less(tf.abs(inside_mul), 1.0 / sigma2), tf.float32) smooth_l1_option1 = tf.multiply(tf.multiply(inside_mul, inside_mul), 0.5 * sigma2) smooth_l1_option2 = tf.substract(tf.abs(inside_mul), 0.5 * sigma2) smooth_l1_result = tf.add( tf.multiply(smooth_l1_option1, smooth_l1_sign), tf.multiply(smooth_l1_option2, tf.abs(tf.substract(smooth_l1_sign, 1.0)))) outside_mul = tf.multiply(box_outside_weights, smooth_l1_result) return outside_mul
def __init__(self, sequence_length, batch_size, embedding_size, epoch, filter_sizes, num_filters): self.sequence_length, self.batch_size, self.embedding_size, self.epoch, self.filter_sizes, self.num_filters = \ sequence_length, batch_size, embedding_size, epoch, filter_sizes, num_filters self.q, self.qp = self.load_data() self.qn = random.shuffle(self.qp) self.dropout_keep_prob = 0.2 self.margin = 0.02 x_qp = tf.placeholder( tf.float32, [self.batch_size, self.sequence_length, self.embedding_size]) x_qn = tf.plecaholder( tf.float32, [self.batch_size, self.sequence_length, self.embedding_size]) x_a = tf.placeholder( tf.float32, [self.batch_size, self.sequence_length, self.embedding_size]) qp_conv = self.conv(x_qp) qn_conv = self.conv(x_qn) a_conv = self.conv(x_a) cosin_q_qp = self.coscin(qp_conv, a_conv) cosin_q_qn = self.coscin(qn_conv, a_conv) zeros = tf.constant(0, shape=[self.batch_size]) margins = tf.constant(self.margin, shape=[self.batch_size]) losses = tf.maximum( tf.substract(margins, tf.sunstract(cosin_q_qp, cosin_q_qn))) self.loss = tf.reduce_sum(losses)
def triplet_loss_gor(anchor, positive, negative, alpha, gor_alfa, embedding_dim): """Calculate the triplet loss according to the FaceNet paper Args: anchor: the embeddings for the anchor images. positive: the embeddings for the positive images. negative: the embeddings for the negative images. Returns: the triplet loss according to the FaceNet paper as a float tensor. """ 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) m1 = tf.pow(tf.reduce_sum(tf.multiply(anchor, negative), 1), 2) mean = tf.pow( tf.reduce_mean(tf.reduce_sum(tf.multiply(anchor, negative), 1)), 2) gor = mean + tf.sqrt( tf.abs(tf.substract(tf.reduce_mean(m1), 1 / embedding_dim))) basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha) loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0) + gor * gor_alfa return loss
def build_graph(): with tf.variable_scope("linear_layer"): w = tf.get_variable( "w", shape=[self.feature_size, self.class_num], initializer=tf.truncated_normal_initializer(mean=0, stddev=1e-2)) b = tf.get_variable("b", shape=[self.class_num], initializer=tf.zeros_initializer()) self.linear_output = tf.matmul(self.X, w) + b with tf.variable_scope("interaction_layer"): v = tf.get_variable( "v", shape=[self.feature_size, self.hidden_size], initializer=tf.truncated_normal_initializer(mean=0, stddev=1e-2)) # ∑_{i=1}^n∑_{j=i+1}^n<V_i,V_j>x_ix_j = # = 1/2 ∑{f=1}^k(( ∑{i=1}^n*v_if*xi)2−∑{i=1}^n*v_{if}^2*x_i^2)) # self.interaction_terms = tf.multiply(0.5, # tf.reduce_sum( # tf.subtract( # tf.pow(tf.sparse_tensor_dense_matmul(self.X, v), 2), # tf.sparse_tensor_dense_matmul(tf.pow(self.X, 2), tf.pow(v, 2))), # 1, keep_dims=True)) pow_part = tf.pow(tf.sparse_tensor_dense_matmul(self.X, v), 2) square_mul_part = tf.sparse_tensor_dense_matmul( tf.pow(self.X, 2), tf.pow(v, 2)) subtract_v = tf.substract(pow_part, square_mul_part) self.interaction_terms = tf.multiply( 0.5, tf.reduce_sum(subtract_v, axis=1, keep_dims=True))
def __init__(self, scope, globalAC=None): if scope == GLOBAL_NET_SCOPE: with tf.variable_scope(scope): self.s = tf.placeholder(tf.float32, [None, N_S], 'S') self.a_params, self.c_params = self._build_net(scope)[-2:] else: with tf.variable_scope(scope): self.s = tf.placeholder(tf.float32, [None, N_S], 'S') self.a_his = tf.placeholder(tf.float32, [None, N_A], 'A') self.v_target = tf.placeholder(tf.float32, [None, 1], 'Vtarget') mu, sigma, self.v, self.a_params, self.c_params = self._build_net( scope) td = tf.substract(self.v_target, self.v, name='TD_error') with tf.name_scope('c_loss'): self.c_loss = tf.reduce_mean(tf.sqaure(td)) with tf.name_scope('wrap_a_out'): mu, sigma = mu * A_bound[1], sigma + 1e-4 normal_dist = tf.distributions.Normal(mu, sigma) with tf.name_scope('a_loss'): log_prob = normal_dist.log_prob(self.a_his) exp_v = log_prob * td entropy = normal_dist.entropy() self.exp_v = ENTROPY_BETA * entropy + exp_v self.a_loss = tf.reduce_mean(-self.exp_v) with tf.name_scope('choose_a'): self.A = tf.clip_by_value( tf.squeeze(normal_dist.sample(1), axis=0), A_BOUND[0], A_BOUND[1]) with tf.name_scope('local_grad'): self.a_grads = tf.gradients(self.a_loss, self.a_params) self.c_grads = tf.gradients(self.c_loss, self.c_params) with tf.name_scope('sync'): with tf.name_scope('pull'): self.pull_a_params_op = [ l_p.assign(g_p) for l_p, g_p in zip(self.a_params, globalAC.a_params) ] self.pull_c_params_op = [ l_p.assign(g_p) for l_p, g_p in zip(self.c_params, globalAC.c_params) ] with tf.name_scope('push'): self.update_a_op = OPT_A.apply_gradients( zip(self.a_grads, globalAC.a_params)) self.update_c_op = OPT_C.apply_gradients( zip(self.c_grads, globalAC.c_params))
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] distance_1 = tf.reduce_sum(tf.square(tf.substract(anchor,postive))) distance_2 = tf.reduce_sum(tf.square(tf.substract(anchor,negative))) dis = tf.add(tf.substract(distance1,distance2),alpha)
def __init__(self,n_input,n_hidden,transfer_function=tf.nn.softplus,optimizer=tf.train.AdamOptimizer(),scale=0.1): self.n_input=n_input self.n_hidden=n_hidden self.transfer=transfer_function self.scale=tf.placeholder(tf.float32) self.training_scale=scale network_weights=self._initialize_dweights() self.weights=network_weights self.x=tf.placeholder(tf.float32,[None,self.n_input]) self.hidden=self.transfer(tf.add(tf.matmul(self.x+scale*tf.random_normal((n_input)), self.weights['w1']),self.weights['b1'])) self.reconstruction=tf.add(tf.matmul(self.hidden,self.weights['w2']),self.weights['b2']) #定义自编码器的损失函数 self.cost=0.5*tf.reduce_sum(tf.pow(tf.substract(self.reconstruction,self.x),2.0)) self.optimizer=optimizer.minimize(self.cost) init=tf.global_variables_initializer() self.sess=tf.Session() self.sess.run(init)
def loss( self ): #logits logits_class = tf.reshape( self.logits[ :,:self.boundary1 ], [self.batchsize, self.cell, self.cell, self.object_classes] ) #batchsize*7*7*20 logits_p = tf.reshape( self.logits[ :, self.boundary1:self.boundary2 ], [self.batchsize, self.cell, self.cell, self.cell_boxes] ) #batchsize*7*7*2, object exist or not logits_boxes = tf.reshape( self.logits[ :,self.boundary2: ], [self.batchsize, self.cell, self.cell, self.cell_boxes, 4] ) #batchsize*7*7*2*4 #labels labels_response = tf.reshape( self.labels[...,0], [self.batchsize, self.cell, self.cell, 1] ) #exist or not exist label_boxes = tf.reshape( self.labels[..., 1:4], [self.batchsize, self.cell, self.cell, 1, 4] ) label_boxes = tf.tile( labels, [1,1,1,2,1] ) #every cell has two boxes label_classes = tf.reshape( self.labels[..., 5:], [self.batchsize, self.cell, self.cell, self.object_classes] ) #boxes loss box_loss_square = tf.square( tf.sqrt( label_boxes[...,2:3] ) - tf.sqrt( logits_boxes[...,2:3] ) ) box_loss_delta = tf.reduce_sum( tf.multiply( box_loss_square, labels_response ) ) box_loss = self.lambda_coord * box_loss_delta #confidence loss iou = self.calc_iou( label_classes, logits_boxes ) # 7*7*2 conf_obj_loss = tf.multiply( iou, logits_p ) conf_obj_loss_tmp = tf.square( tf.substract( labels_response - conf_obj_loss ) ) conf_obj_loss = tf.multiply( labels_response, conf_obj_loss_tmp ) conf_obj_loss = tf.reduce_sum( conf_obj_loss ) mask = tf.subtract( 1 - tf.ones_like( labels_response ) ) # no object is 1, or is 0 conf_noobj_loss = tf.multiply( mask, conf_obj_loss_tmp ) conf_noobj_loss = tf.reduce_sum( conf_noobj_loss ) conf_noobj_loss = self.lambda_noobj*conf_noobj_loss conf_loss = conf_obj_loss + conf_noobj_loss #class loss class_loss = tf.sbutract( label_classes - logits_class ) class_loss = tf.reduce_sum( tf.square( class_loss ), 4 ) class_loss = tf.multiply( labels_response, class_loss ) class_loss = tf.reduce_sum( class_loss ) self.loss = box_loss + conf_loss + class_loss return self.loss
def ConstructSVM(self, column_number, value, batch_size, constant_epsilon = 0.5, learning_rate = 0.075): ops.reset_default_graph() self.session = tf.Session() self.batch_size = batch_size self.placeholder_data = tf.placeholder(dtype = tf.float32, shape = [None, column_number]) self.placeholder_value = tf.placeholder(dtype = tf.float32, shape = [None, 1]); self.A = tf.Variable(tf.random_normal(shape = [len(data.columns_), 1]), name = 'A') self.B = tf.Variable(tf. random_normal(shape = [1, 1]), name = 'B') self.epsilon = tf.constant(constant_epsilon) self.model = tf.add(tf.matmul(placeholder_data, self.A), self.B) self.loss = tf.reduce_mean(tf.maximum(0., tf.subtract(tf.abs(tf.substract(self.model, self.placeholder_value)), self.epsilon))) self.optimizer = tf.train.GradientDescentOptimizer(learning_rate)
def __init__(self,h_size): self.scalarInput = tf.placeholder(shape=[None, 21168], dtype = tf.float32) self.imageIn = tf.reshape(self.scalarInput, shape=[-1, 84, 84, 3]) self.conv1 = tf.contrib.layers.convolution2d( inputs=self.imageIn, num_outputs = 32, kernel_size = [8,8], stride = [4,4], padding = 'VALID', biases_initializer = None) self.conv2 = tf.contrib.layers.convolution2d( inputs = self.conv1, num_outputs = 64, kernel_size = [4,4], stride = [2,2], padding = 'VALID', biases_initializer = None) self.conv3 = tf.contrib.layers.convolution2d( inputs=self.conv2, num_outputs=64, kernel_size=[3,3], stride=[1,1], padding='VALID', biases_initializer=None) self.conv4 = tf.contrib.layers.convolution2d( inputs=self.conv3, num_outputs=512, kernel_size=[7,7], stride=[1,1], padding='VALID', biases_initializer=None) self.streamAC, self.streamVC = tf.split(self.conv4,2,3) self.streamA = tf.contrib.layers.flatten(self.streamAC) self.streamV = tf.contrib.layers.flatten(self.streamVC) self.AW = tf.Variable(tf.random_normal([h_size//2, env.actions])) self.VW = tf.Variable(tf.random_normal([h_size//2, 1])) self.Advantage = tf.matmul(self.streamA, self.AW) self.Value = tf.matmul(self.streamV, self.VW) self.Qout = self.Value + tf.substract(self.Advantage,tf.reduce_mean(self.Advantage, reduction_indices = 1, keep_dims = True)) self.predict = tf.argmax(self.Qout, 1) self.targetQ = tf.placeholder(shape=[None], dtype=tf.float32) self.actions = tf.placeholder(shape=[None], dtype=tf.int32) self.actions_onehot = tf.one_hot(self.actions,env.actions, dtype=tf.float32) self.Q = tf.reduce_sum(tf.multiply(self.Qout, self.actions_onehot), reduction_indices=1) self.td_error = tf.square(self.targetQ - self.Q) self.loss = tf.reduce_mean(self.td_error) self.trainer = tf.train.AdamOptimizer(learning_rate=0.0001) self.updateModel = self.trainer.minimize(self.loss)
class2_x = [x[0] for i, x in enumerate(x_vals) if y_vals[i] == -1] class2_y = [x[1] for i, x in enumerate(x_vals) if y_vals[i] == -1] batch_size = 350 x_data = tf.placeholder(shape=[None, 2], dtype=tf.float32) y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32) prediction_grid = tf.placeholder(shape=[None, 2], dtype=tf.float32) b = tf.Variable(tf.random_normal(shape=[1, batch_size])) gamma = tf.constant(-50, 0) dist = tf.reduce_sum(tf.square(x_data), 1) dist = tf.reshape(dist, [-1, 1]) sq_dists = tf.add( tf.substract(dist, tf.multiply(2, tf.matmul(x_data, tf.transpose(x_data)))), tf.transpose(dist)) my_kernel = tf.exp(tf.multiply(gamma, tf.abs(sq_dists))) first_term = tf.reduce_mean(b) b_vec_cross = tf.matmul(tf.transpose(b), b) y_target_cross = tf.matmul(y_target, tf.transpose(y_target)) second_term = tf.reduce_sum( tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_target_cross))) loss = tf.negative(tf.subtract(first_term, second_term)) rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1), [-1, 1]) rB = tf.reshape(tf.reduce_sum(tf.square(prediction_grid), 1), [-1, 1]) pred_sq_dist = tf.add( tf.subtract( rA, tf.multiply(2., tf.matmul(x_data, tf.transpose(prediction_grid)))),
def _init_graph(self): ''' Init a tensorflow Graph containing: input data, variables, model, loss, optimizer ''' self.graph = tf.Graph() with self.graph.as_default(): # , tf.device('/cpu:0'): # Set graph level random seed tf.set_random_seed(self.random_seed) # Input data. self.train_features = tf.placeholder(tf.int32, shape=[None, None ]) # None * features_M self.train_labels = tf.placeholder(tf.float32, shape=[None, 1]) # None * 1 self.dropout_keep = tf.placeholder(tf.float32, shape=[None]) self.train_phase = tf.placeholder(tf.bool) # Variables. self.weights = self._initialize_weights() # Model. # _________ sum_square part _____________ # get the summed up embeddings of features. nonzero_embeddings = tf.nn.embedding_lookup( self.weights['feature_embeddings'], self.train_features) self.summed_features_emb = tf.reduce_sum(nonzero_embeddings, 1) # None * K # get the element-multiplication self.summed_features_emb_square = tf.square( self.summed_features_emb) # None * K # _________ square_sum part _____________ self.squared_features_emb = tf.square(nonzero_embeddings) self.squared_sum_features_emb = tf.reduce_sum( self.squared_features_emb, 1) # None * K # ________ FM __________ self.FM = 0.5 * tf.substract( self.summed_features_emb_square, self.squared_sum_features_emb) # None * K if self.batch_norm: self.FM = self.batch_norm_layer(self.FM, train_phase=self.train_phase, scope_bn='bn_fm') self.FM = tf.nn.dropout( self.FM, self.dropout_keep[-1] ) # dropout at the bilinear interactin layer # ________ Deep Layers __________ for i in range(0, len(self.layers)): self.FM = tf.add( tf.matmul(self.FM, self.weights['layer_%d' % i]), self.weights['bias_%d' % i]) # None * layer[i] * 1 if self.batch_norm: self.FM = self.batch_norm_layer( self.FM, train_phase=self.train_phase, scope_bn='bn_%d' % i) # None * layer[i] * 1 self.FM = self.activation_function(self.FM) self.FM = tf.nn.dropout( self.FM, self.dropout_keep[i]) # dropout at each Deep layer self.FM = tf.matmul(self.FM, self.weights['prediction']) # None * 1 # _________out _________ Bilinear = tf.reduce_sum(self.FM, 1, keep_dims=True) # None * 1 self.Feature_bias = tf.reduce_sum( tf.nn.embedding_lookup(self.weights['feature_bias'], self.train_features), 1) # None * 1 Bias = self.weights['bias'] * tf.ones_like( self.train_labels) # None * 1 self.out = tf.add_n([Bilinear, self.Feature_bias, Bias]) # None * 1 # Compute the loss. if self.loss_type == 'square_loss': if self.lamda_bilinear > 0: self.loss = tf.nn.l2_loss( tf.substract(self.train_labels, self.out) ) + tf.contrib.layers.l2_regularizer(self.lamda_bilinear)( self.weights['feature_embeddings']) # regulizer else: self.loss = tf.nn.l2_loss( tf.substract(self.train_labels, self.out)) elif self.loss_type == 'log_loss': self.out = tf.sigmoid(self.out) if self.lamda_bilinear > 0: self.loss = tf.contrib.losses.log_loss( self.out, self.train_labels, weights=1.0, epsilon=1e-07, scope=None ) + tf.contrib.layers.l2_regularizer(self.lamda_bilinear)( self.weights['feature_embeddings']) # regulizer else: self.loss = tf.contrib.losses.log_loss(self.out, self.train_labels, weights=1.0, epsilon=1e-07, scope=None) # Optimizer. if self.optimizer_type == 'AdamOptimizer': self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize(self.loss) elif self.optimizer_type == 'AdagradOptimizer': self.optimizer = tf.train.AdagradOptimizer( learning_rate=self.learning_rate, initial_accumulator_value=1e-8).minimize(self.loss) elif self.optimizer_type == 'GradientDescentOptimizer': self.optimizer = tf.train.GradientDescentOptimizer( learning_rate=self.learning_rate).minimize(self.loss) elif self.optimizer_type == 'MomentumOptimizer': self.optimizer = tf.train.MomentumOptimizer( learning_rate=self.learning_rate, momentum=0.95).minimize(self.loss) # init self.saver = tf.train.Saver() init = tf.global_variables_initializer() self.sess = tf.Session() self.sess.run(init) # number of params total_parameters = 0 for variable in self.weights.values(): shape = variable.get_shape( ) # shape is an array of tf.Dimension variable_parameters = 1 for dim in shape: variable_parameters *= dim.value total_parameters += variable_parameters if self.verbose > 0: print "#params: %d" % total_parameters
out = tf.cond(tf.greater(x, y), lambda: tf.add(x, y), lambda: tf.subtract(x, y)) ############################################################################### # 1b: Create two 0-d tensors x and y randomly selected from the range [-1, 1). # Return x + y if x < y, x - y if x > y, 0 otherwise. # Hint: Look up tf.case(). ############################################################################### # YOUR CODE x = tf.random_uniform([], -1, 1) y = tf.random_uniform([], -1, 1) out = tf.case( { tf.less(x, y): lambda: tf.add(x, y), tf.greater(x, y): lambda: tf.substract(x, y) }, default=lambda: tf.constant(0, 0), exclusive=True) ############################################################################### # 1c: Create the tensor x of the value [[0, -2, -1], [0, 1, 2]] # and y as a tensor of zeros with the same shape as x. # Return a boolean tensor that yields Trues if x equals y element-wise. # Hint: Look up tf.equal(). ############################################################################### # YOUR CODE ############################################################################### # 1d: Create the tensor x of value # [29.05088806, 27.61298943, 31.19073486, 29.35532951,
def compute_z(a, b, c): r1 = tf.substract(a, b) r2 = tf.multiply(2, r1) z = tf.add(r2, c) return z
def main(): # define dataset object train_set = dataset(train_path, batch_size) # define input train_input = tf.placeholder( tf.float32, shape=(image_size,image_size,batch_size) ) train_label = tf.placeholder( tf.float32, shape=(image_size,image_size,batch_size) ) # the model and loss shared_model = tf.make_template('shared_model', model) train_output, weights = shared_model(train_input) loss = tf.reduce_sum(tf.nn.l2_loss(tf.substract(train_output, train_label))) # normlization weight. for w in weights: loss += tf.nn.l2_loss(w)*1e-4 # record loss tf.summary.scalar("loss", loss) # training step and learning rate global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay( base_learning_rate, global_step*batch_size, train_set.instance_num*lr_step_size, lr_decay, staircase=True ) tf.summary.scalar("learning_rate", learning_rate) # Optimizer optimizer = tf.train.AdamOptimizer(learning_rate) opt = optimizer.minimize(loss, global_step=global_step) saver = tf.train.Saver(weights, max_to_keep=0) config = tf.ConfigProto() # training with tf.Session(config=config) as sess: #TensorBoard open log with "tensorboard --logdir=logs" if not os.path.exists('logs'): os.mkdir('logs') merged = tf.summary.merge_all() file_writer = tf.summary.FileWriter('logs',sess.graph) # var initializaion tf.initialize_all_variables().run() if model_path: print "restore model..." saver.restore(sess,model_path) print "successfully restore previous model." # train for epoch in xrange(0,max_epoch): for step in range(train_set.instance_num//batch_size): data, label = train_set.next_batch() feed_dict = {train_input : data, train_label : label} _,l,output,lr,g_step = sess.run([opt, loss, train_output, learning_rate, global_step],feed_dict=feed_dict) print "[epoch %2.4f] loss %.4f\t lr %.5f" % (epoch+(float(step)*batch_size/train_set.instance_num), np.sum(l)/batch_size, lr) del data, label saver.save(sess, "./checkpoints/VDSR_const_clip_0.01_epoch_%03d.ckpt" % epoch ,global_step=global_step)
data3 = tf.constant(2.5, dtype=tf.int32) print(data1) print(data2) sess = tf.session() print(sess.run(data1)) init = tf.global_variables_initializer() sess.run(init) print(sess.run(data3)) ###############################################33 init = tf.global_variables_initializer() sess = tf.session() with sess: sess.run(init) ############################################### import tensorflow as tf data1 = tf.constant(2, dtype=tf.int32) data2 = tf.constant(4, dtype=tf.int32) dataAdd = tf.add(data1, data2) dataMul = tf.multiply(data1, data2) dataMinus = tf.substract(data1, data2) dataDiv = tf.divide(data1, data2) with tf.session() as sess: print(sess.run(dataAdd)) print(sess.run(dataMul)) print(sess.run(dataMinus)) print(sess.run(dataDiv))
import matplotlib.pyplot as plt import tensorflow as tf import numpy as np from sklearn.utils import shuffle from sklearn.model_selection import train_test_split a = tf.constant(5.5) b = tf.constant(8.6) sess = tf.InteractiveSession() print(sess.run(a)) print("sub a from b:", sess.run(tf.substract(b, a))) ## tf.add, multiply, or divide ## matrices #matrices ops, like numpy #tf.random_normal() #tf.random_uniform() #tf.ones() #tf.zeros() #tf.ones_like() generate a matrix of ones with the same shape as the matrix passed in #### variable needs to be initialized upon using them by # tf.global_variables_initializer() ### dot product / multiplication # sess.run(tf.matmul(matrix11, matrix2)) ### placeholders
def ms_error(labels, logits): return tf.square(tf.substract(labels, logits))
def _init_graph(self): self.graph = tf.Graph() with self.graph.as_default(): tf.set_random_seed(self.random_seed) # 1. for input data self.feat_index = tf.placeholder(tf.int32, shape=[None, None], name='feat_index') self.feat_value = tf.placeholder(tf.float32, shape=[None, None], name='feat_value') self.numeric_value = tf.placeholder(tf.float32, shape=[None, None], name='numeric_value') self.label = tf.placeholder(tf.float32, shape=[None, 1], name='label') self.dropout_keep_deep = tf.placeholder(tf.float32, shape=[None], name='dropout_keep_deep') self.train_phase = tf.placeholder(tf.bool, name='train_phase') # 2. weights self.weights = self._initialize_weights() # 3. define the computing graph self.embeddings = tf.nn.embedding_lookup( self.weights['feature_embeddings'], self.feat_index) feat_value = tf.reshape(self.feat_value, shape=[-1, self.field_size, 1]) self.embeddings = tf.multiply(self.embeddings, feat_value) self.x0 = tf.concat([ self.numeric_value, tf.reshape(self.embeddings, shape=[-1, self.field_size * self.embedding_size]) ], axis=1) with tf.name_scope('deep_part'): self.y_deep = self.x0 # x0需要进行dropout? for i in range(len(self.deep_layers)): self.y_deep = tf.add( tf.matmul(self.y_deep, self.weights['deep_layer_%d' % i]), self.weights['deep_bias_%d' % i]) self.y_deep = self.deep_layers_activation(self.y_deep) self.y_deep = tf.nn.dropout(self.y_deep, self.dropout_keep_deep[i]) # with tf.name_scope('cross_part'): self._x0 = tf.reshape(self.x0, (-1, self.total_size, 1)) x_l = self._x0 for l in range(self.cross_layer_num): # cross_layer: x_l+1 = x_0 * x_l.T * W_l + b_l + x_l # 默认为列向量 # x_l = tf.tensordot(tf.matmul(self._x0, x_l, transpose_b=True), # self.weights['cross_layer_%d' % l], 1) + self.weights['cross_bias_%d' % l] + x_l # 上式可以简化运算,先算x_l.T * w_l 得到一个实数,然后再和前面的x_0进行计算 xlT_w = tf.tensordot(x_l, self.weights['cross_layer_%d' % l], axes=(1, 0)) print(xlT_w) print(self.weights['cross_layer_%d' % l]) x_l = tf.matmul(self._x0, xlT_w) + \ self.weights['cross_bias_%d' % l] + x_l self.cross_part_out = tf.reshape(x_l, (-1, self.total_size)) ## concat_part concat_input = tf.concat([self.cross_part_out, self.y_deep], axis=1) ## last layer self.out = tf.add( tf.matmul(concat_input, self.weights['concat_projection']), self.weights['concat_bias']) # 4. loss function if self.loss_type == "logloss": self.out = tf.nn.sigmoid(self.out) self.loss = tf.losses.log_loss(self.label, self.out) elif self.loss_type == "mse": self.loss = tf.nn.l2_loss(tf.substract(self.label, self.out)) ## regularization if self.l2_reg > 0.0: self.loss += tf.contrib.layers.l2_regularizer(self.l2_reg)( self.weights['concat_projection']) for i in range(len(self.deep_layers)): self.loss += tf.contrib.layers.l2_regularizer(self.l2_reg)( self.weights['deep_layer_%d' % i]) for i in range(self.cross_layer_num): self.loss += tf.contrib.layers.l2_regularizer(self.l2_reg)( self.weights['cross_layer_%d' % i]) # 5 optimizer if self.optimizer_type == "adam": self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize(self.loss) elif self.optimizer_type == 'adagrad': self.optimizer = tf.train.AdagradOptimizer( learning_rate=self.learning_rate, initial_accumulator=1e-8).minimize(self.loss) elif self.optimizer_type == 'gd': self.optimizer = tf.train.GradientDescentOptimizer( learning_rate=self.learning_rate).minimize(self.loss) elif self.optimizer_type == 'momentum': self.optimizer = tf.train.MomentumOptimizer( learning_rate=self.learning_rate, momentum=0.5).minimize(self.loss) # init init = tf.global_variables_initializer() self.sess = tf.Session() self.sess.run(init) ## 算一下参数数量 total_parameters = 0 for variable in self.weights.values(): shape = variable.shape temp = 1 for dim in shape: temp *= dim total_parameters += temp if self.verbose > 0: print("#params: %d" % total_parameters)
def # 39 二叉树的深度 def getHeight(root): if root is None: return 0 lh = getHeight(root.left) lr = getHeight(root.right) return max(lh, lr) + 1 # 52 构建乘积数组 def productExceptSelf(nums): res, right = [1 for _ in range(len(nums))], 1 for i in range(1, len(nums)): res[i] = res[i-1] * nums[i-1] for i in range(len(nums)-1, 0, -1): res[i] = res[i] * right right = right * nums[i] return res # 53 正则表达式匹配, 初始条件与匹配零次以上的条件最复杂 def isMatch(s, p): dp = [[False for _ in range(len(p) + 1)] for _ in range(len(s)+1)] dp[0][0] = True for i in range(2, len(p) + 1): if p[i-1] == "*": dp[0][i] = dp[0][i-2] for i in range(1, len(s)+1): for j in range(1, len(p) + 1): if s[i-1] == p[j-1]: dp[i][j] = dp[i-1][j-1] elif p[j-1] == ".": dp[i][j] = dp[i-1][j-1] elif p[j-1] == "*": # dp[i][j-1]匹配一次dp[i][j-2] 匹配零次, dp[i][j] = dp[i][j-1] or dp[i][j-2] or (s[i-1] == p[j-2] or p[j-2] == ".") return dp[len(s)][len(p)] # 56 链表中环的入口结点 def detectCycle(head): slow, fast = head, head while fast and fast.next: slow, fast = slow.next, fast.next.next if slow == fast: break if fast is None or fast.next is None: return None slow = head while slow != fast: slow, fast = slow.next, fast.next return slow # 57 删除链表中重复的节点 def deleteDuplicates(head): if head is None: return None dumpy = ListNode(0) dumpy.next = head cur1, cur2 = dumpy.next, head.next while cur2: if cur2.val != cur1.val: cur1.next = cur2 cur1 = cur1.next cur2 = cur2.next cur1.next = None return dumpy.next # 60 把二叉树打印成多行 def levelOrder(root): res, queue = [], [] if root is None: return res queue.append(root) while queue: out, new_queue = [], [] for node in queue: out.append(node.val) if node.left: new_queue.append(node.left) if node.right: new_queue.append(node.right) res.append(out) queue = new_queue return res # 61 按之字形顺序打印二叉树 def zigZag(root): res, queue, level = [], [], 0 if root is None: return res queue.append(root) while queue: new_queue, out = [], [] for node in queue: out.append(node.val) if node.left: new_queue.append(node.left) if node.right: new_queue.append(node.right) res.append(out[::-1]) if level % 2 else res.append(out) queue = new_queue return res # 62 序列化二叉树 class Codec: def serialize(self, root): res = [] if root is None: res.append("#") return res res.append(str(root.val)) self.serialize(root.left) self.serialize(root.right) return ",".join(res) def deserialize(self, data): data = iter(data.split(",")) def build(): val = next(data) if val == "#": return None root = TreeNode(val) root.left = self.deserialize(data) root.right = self.deserialize(data) return root return build() # 63 二叉搜索树的第 k 个节点 def kthSmallest(root): st, p, cnt = [], root, 1 while st or p: while p: st.append(p) p = p.left p = st.pop() if cnt == k: return p.val p, cnt = p.right, cnt + 1 # Kmeans 算法 def kmeans(data, k): m = len(data) # 数据点个数 n = len(data[0]) # 数据维度 cluster_center = np.zeros((k, n)) # 每行表示一个聚类中心 init_list = np.random.randomint(low=0, high=m, size=k) for index, j in enumerate(init_list): cluster_center[index] = data[j][:] # 随机选取 k 个点做聚类中心 # 聚类 cluster = np.zeros(m, dtype=np.int) - 1 cc = np.zeros((k, n)) # 下一轮聚类中心 c_number = np.zeros(k) # 每个聚类中心上样本的数目 for times in range(1000): for i in range(m): c = nearest(data[i], cluster_center) # 计算每个数据点和所有聚类中心的距离,返回属于哪个聚类中心 cluster[i] = c # 第 i 个点属于 第 c 个聚类中心 c_number[c] += 1 # 第 c 个聚类中心的个数加一 cc[c] += data[i] for i in range(k): cluster_center[i] = cc[c] / c_number[i] cc.flat, c_number.flat = 0, 0 return cluster def nearest(data, cluster_center): nearest_center_index = 0 distance = float("inf") for index, cluster_center_one in enumerate(cluster_center): dis = np.sum((data - center) ** 2) if dis < distance: nearest_center_index = index distance = dis return nearest_center_index # 两个有序数组找中位数 def topK(A, s1, e1, B, s2, e2, k): l1, l2 = e1- s1 + 1, e2 - s2 + 1 i, j = s1 + min(k//2, l1) - 1, s2 + min(k//2, l2) - 1 if l1 == 0 and l2 > 0: return B[s2 + k - 1] if l2 == 0 and l1 > 0: return A[s1 + k - 1] if k == 1: return min(A[s1], B[s2]) if A[i] > B[j]: return topK(A, s1, e1, B, j+1, e2, k-(j-s2+1)) else: return topK(A, i+1, e1, B, s2, e2, k-(i-s1+1)) def findMedianSortedArrays(nums1, nums2): if len(num1) > len(nums2): nums1, nums2 = nums2, nums1 m, n = len(nums1), len(nums2) if (m + n) % 2 == 0: return (topK(nums1, 0, m-1, nums2, 0, n-1, (m+n)/2) + topK(nums1, 0, m-1, nums2, 0, n-1, (m+n)/2+1))/2.0 else: return topK(nums1, 0, m-1, nums2, 0, n-1, (m+n+1)/2) # KNN tensorflow实现 import tensorflow as tf import numpy as np # Build Graph tr = tf.placeholder(tf.float32, [None, 784]) te = tf.placeholder(tf.float32, [784]) distance = tf.reduce_sum(tf.square(tf.substract(te, tr)), axis=1) pred = tf.nn.top_k(distance, k) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for i in range(len(testdata)): nn_index = sess.run(pred, feed_dict={tr:traindata, te:testdata[i, :]}) # 链表的快排 def sortList(head): if head is None or head.next is None: return head small, large, cur = ListNode(0), ListNode(0), head.next sp, lp = small, large while cur: if cur.val <= head.val: sp.next = cur sp = sp.next else: lp.next = cur lp = lp.next cur = cur.next sp.next, lp.next = None, None small, large = self.sortList(small.next), self.sortList(large.next) sp = small if sp: while sp.next: sp = sp.next sp.next = head head.next = large return small else: head.next = large return head def maxPooling(nums, k): from collections import deque q = deque() for i, x in enumerate(nums): if q and i - q[0] >= k: q.popleft() while q and nums[q[-1]] <= x: q.pop() q.append(i) if i >= k - 1: res.append(nums[q[0]]) return res
######################################################### ## TF v2 style a = tf.constant(1, name='a') b = tf.constant(2, name='b') c = tf.constant(3, name='c') z = 2 * (a - b) + c tf.print("my result: ", z) ''' tf.substract(a, b) tf.multiply(2, r1) ## elementwise tf.add(a, b) ''' ######################################################### ## function decorators ## autograph - transforms python code into tensorflow graph code @tf.function def compute_z(a, b, c):