def get_top_nearest_neigbors(num_generated, nearneig, real_features_hdf5, gen_features_hdf5, maximum=False, random_select=False, save_path=None): real_img_hdf5 = real_features_hdf5.replace('_features_', '_images_') gen_img_hdf5 = gen_features_hdf5.replace('_features_', '_images_') real_features_file = h5py.File(real_features_hdf5, 'r') gen_features_file = h5py.File(gen_features_hdf5, 'r') real_img_file = h5py.File(real_img_hdf5, 'r') gen_img_file = h5py.File(gen_img_hdf5, 'r') real_features = real_features_file['features'] gen_features = gen_features_file['features'] real_img = real_img_file['images'] gen_img = gen_img_file['images'] with tf.Session() as sess: real_features = tf.constant(np.array(real_features), dtype=tf.float32) gen_features = tf.constant(np.array(gen_features), dtype=tf.float32) # Get Nearest Neighbors for all generated images. gen_real_distances = tf.sqrt(tf.abs(euclidean_distance(gen_features, real_features))) neg = tf.negative(gen_real_distances) neg_s_distances, s_indices = tf.math.top_k(input=neg, k=nearneig, sorted=True) s_distances = tf.negative(neg_s_distances) # Getting the top smallest distances between Generated and Real images. neg_s_distances1, s_indices1 = tf.math.top_k(input=neg, k=1, sorted=True) neg_s_distances1 = tf.transpose(neg_s_distances1) if not random_select: if maximum: neg_s_distances1 = tf.negative(neg_s_distances1) neg_s_distances1, s_indices1 = tf.math.top_k(input=neg_s_distances1, k=num_generated, sorted=True) s_indices1 = tf.transpose(s_indices1) s_indices1 = s_indices1.eval() else: lin = list(range(int(gen_real_distances.shape[0]))) random.shuffle(lin) s_indices1 = np.zeros((num_generated,1), dtype=np.int8) s_indices1[:, 0] = lin[:num_generated] s_indices = s_indices.eval() s_distances = s_distances.eval() # For the images with top smallest distances, show nearest neighbors. height, width, channels = real_img.shape[1:] neighbors = dict() grid = np.zeros((num_generated*height, (nearneig+1)*width, channels)) for i, ind in enumerate(s_indices1): ind = ind[0] total = gen_img[ind] neighbors[ind] = list() for j in range(nearneig): neighbors[ind].append((s_indices[ind,j], s_distances[ind,j])) real = real_img[s_indices[ind,j]]/255. total = np.concatenate([total, real], axis=1) grid[i*height:(i+1)*height, :, :] = total plt.imshow(grid) if save_path is not None: plt.imsave(save_path, grid) return neighbors
def logG(x, y, theta): fv = tff(theta,y) gv = tfg(theta,y) mu = tf.add(y,tf.multiply(fv,gl.h)) pr = tf.subtract(x,mu) pr2 = tf.square(pr) gv2 = tf.square(gv) my2 = tf.constant(2.0,dtype=gl.myftype) mypi = tf.constant(np.pi,dtype=gl.myftype) lgp1 = tf.negative(tf.divide(tf.log(tf.multiply(my2*mypi*gl.h,gv2)),my2)) lgp2 = tf.negative(tf.divide(pr2,tf.multiply(my2*gl.h,gv2))) lg = tf.add(lgp1,lgp2) return lg
def test_all(self): with self.test_context() as session: models = self.prepare() likelihoods = [] for m in models: opt = gpflow.train.ScipyOptimizer() opt.minimize(m, maxiter=300) neg_obj = tf.negative(m.objective) likelihoods.append(session.run(neg_obj).squeeze()) assert_allclose(likelihoods, likelihoods[0], rtol=1e-6) variances, lengthscales = [], [] for m in models: if hasattr(m.kern, 'rbf'): variances.append(m.kern.rbf.variance.read_value()) lengthscales.append(m.kern.rbf.lengthscales.read_value()) else: variances.append(m.kern.variance.read_value()) lengthscales.append(m.kern.lengthscales.read_value()) variances, lengthscales = np.array(variances), np.array(lengthscales) assert_allclose(variances, variances[0], 1e-5) assert_allclose(lengthscales, lengthscales.mean(), 1e-4) mu0, var0 = models[0].predict_y(self.Xtest) for i, m in enumerate(models[1:]): mu, var = m.predict_y(self.Xtest) assert_allclose(mu, mu0, 1e-3) assert_allclose(var, var0, 1e-4)
def __init__(self, product_size, embedding_size, batch_size): self.batch_size = batch_size self.graph = tf.Graph() with self.graph.as_default(): self.train_inputs = tf.placeholder(tf.int32, shape=[batch_size]) self.train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1]) with tf.device('/cpu:0'): embeddings = tf.Variable(tf.random_uniform([product_size, embedding_size], -1.0, 1.0)) embed = tf.nn.embedding_lookup(embeddings, self.train_inputs) output_embed = tf.nn.embedding_lookup(embeddings, self.train_labels) weights = tf.Variable(tf.random_normal([embedding_size, embedding_size])) bias = tf.Variable(tf.random_normal([embedding_size])) output_layer = tf.matmul(embed, weights) + bias self.loss = tf.reduce_sum(tf.abs(tf.add(output_layer, tf.negative(output_embed))), reduction_indices=1) self.optimizer = tf.train.GradientDescentOptimizer(learning_rate=1.0).minimize(self.loss) norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims=True)) self.normalized_embeddings = embeddings / norm self.init = tf.initialize_all_variables()
def build_graph(self, image_pos): image_pos = image_pos / 128.0 - 1 z = tf.random_normal([self.batch, self.zdim], name='z_train') z = tf.placeholder_with_default(z, [None, self.zdim], name='z') with argscope([Conv2D, Conv2DTranspose, FullyConnected], kernel_initializer=tf.truncated_normal_initializer(stddev=0.02)): with tf.variable_scope('gen'): image_gen = self.generator(z) tf.summary.image('generated-samples', image_gen, max_outputs=30) alpha = tf.random_uniform(shape=[self.batch, 1, 1, 1], minval=0., maxval=1., name='alpha') interp = image_pos + alpha * (image_gen - image_pos) with tf.variable_scope('discrim'): vecpos = self.discriminator(image_pos) vecneg = self.discriminator(image_gen) vec_interp = self.discriminator(interp) # the Wasserstein-GAN losses self.d_loss = tf.reduce_mean(vecneg - vecpos, name='d_loss') self.g_loss = tf.negative(tf.reduce_mean(vecneg), name='g_loss') # the gradient penalty loss gradients = tf.gradients(vec_interp, [interp])[0] gradients = tf.sqrt(tf.reduce_sum(tf.square(gradients), [1, 2, 3])) gradients_rms = symbolic_functions.rms(gradients, 'gradient_rms') gradient_penalty = tf.reduce_mean(tf.square(gradients - 1), name='gradient_penalty') add_moving_summary(self.d_loss, self.g_loss, gradient_penalty, gradients_rms) self.d_loss = tf.add(self.d_loss, 10 * gradient_penalty) self.collect_variables()
def disable_some_fgs(): # We want to delete a randomly-selected subset of fg_inds of # size `fg_inds.shape[0] - max_fg`. # We shuffle along the dimension 0 and then we get the first # num_fg_inds - max_fg indices and we disable them. shuffled_inds = tf.random_shuffle(fg_inds, seed=self._seed) disable_place = (tf.shape(fg_inds)[0] - max_fg) # This function should never run if num_fg_inds <= max_fg, so we # add an assertion to catch the wrong behaviour if it happens. integrity_assertion = tf.assert_positive( disable_place, message="disable_place in disable_some_fgs is negative." ) with tf.control_dependencies([integrity_assertion]): disable_inds = shuffled_inds[:disable_place] is_disabled = tf.sparse_to_dense( sparse_indices=disable_inds, sparse_values=True, default_value=False, output_shape=tf.cast(proposals_label_shape, tf.int64), # We are shuffling the indices, so they may not be ordered. validate_indices=False ) return tf.where( condition=is_disabled, # We set it to -label for debugging purposes. x=tf.negative(proposals_label), y=proposals_label )
def cross_entropy_loss(y, yhat): """ Compute the cross entropy loss in tensorflow. The loss should be summed over the current minibatch. y is a one-hot tensor of shape (n_samples, n_classes) and yhat is a tensor of shape (n_samples, n_classes). y should be of dtype tf.int32, and yhat should be of dtype tf.float32. The functions tf.to_float, tf.reduce_sum, and tf.log might prove useful. (Many solutions are possible, so you may not need to use all of these functions). Note: You are NOT allowed to use the tensorflow built-in cross-entropy functions. Args: y: tf.Tensor with shape (n_samples, n_classes). One-hot encoded. yhat: tf.Tensorwith shape (n_sample, n_classes). Each row encodes a probability distribution and should sum to 1. Returns: out: tf.Tensor with shape (1,) (Scalar output). You need to construct this tensor in the problem. """ ### YOUR CODE HERE l_yhat = tf.log(yhat) # log yhat product = tf.multiply(tf.to_float(y), l_yhat) # multiply element-wise out = tf.negative(tf.reduce_sum(product)) # negative summation to scalar ### END YOUR CODE return out
def gabor(n_values=32, sigma=1.0, mean=0.0): x = tf.linspace(-3.0, 3.0, n_values) z = (tf.exp(tf.negative(tf.pow(x - mean, 2.0)/ (2.0 * tf.pow(sigma, 2.0)))) * (1.0 / (sigma * tf.sqrt(2.0 * 3.145)))) gauss_kernel = tf.matmul(tf.reshape(z, [n_values, 1]), tf.reshape(z,[1, n_values])) x = tf.reshape(tf.sin(tf.linspace(-3.0, 3.0, n_values)), [n_values, 1]) y = tf.reshape(tf.ones_like(x), [1, n_values]) gabor_kernel = tf.multiply(tf.matmul(x ,y), gauss_kernel) return gabor_kernel
def build_graph(self, graph): self.xtr = tf.placeholder(dtype=tf.float32, shape=[None, 784]) self.xte = tf.placeholder(dtype=tf.float32, shape=[784]) # one vector compares with all in self.xtr self.distance = tf.reduce_sum(tf.abs(tf.add(self.xtr, tf.negative(self.xte))), reduction_indices=1) self.pred = tf.argmin(self.distance, 0) self.global_step_t = tf.Variable(0, trainable=False, name='global_step_t') return graph
def integrandmat(inx, iny, th): my2 = tf.constant(2.0,gl.myftype) tfmu = tf.add(iny,tf.multiply(tff(theta=th,x=iny),gl.h)) tfsig = tf.multiply(tf.sqrt(gl.h),tfg(theta=th,x=iny)) tfc0 = tf.reciprocal(tf.multiply(tf.sqrt(tf.multiply(my2,tf.constant(np.pi,dtype=gl.myftype))),tfsig)) tfnumer = tf.negative(tf.square(tf.subtract(inx,tfmu))) tfdenom = tf.multiply(my2,tf.square(tfsig)) tfprop = tf.multiply(tfc0,tf.exp(tf.divide(tfnumer,tfdenom))) return tfprop
def calculate_loss(self, predictions, labels, **unused_params): with tf.name_scope("loss_xent"): epsilon = 10e-6 alpha = FLAGS.alpha float_labels = tf.cast(labels, tf.float32) cross_entropy_loss = 2*(alpha*float_labels * tf.log(predictions + epsilon) + (1-alpha)*( 1 - float_labels) * tf.log(1 - predictions + epsilon)) cross_entropy_loss = tf.negative(cross_entropy_loss) return tf.reduce_mean(tf.reduce_sum(cross_entropy_loss, 1))
def find_top_nearest_neigbors(generated_list, nearneig, real_features_hdf5, gen_features_hdf5, maximum=False, save_path=None): real_img_hdf5 = real_features_hdf5.replace('_features_', '_images_') gen_img_hdf5 = gen_features_hdf5.replace('_features_', '_images_') real_features_file = h5py.File(real_features_hdf5, 'r') gen_features_file = h5py.File(gen_features_hdf5, 'r') real_img_file = h5py.File(real_img_hdf5, 'r') gen_img_file = h5py.File(gen_img_hdf5, 'r') real_features = real_features_file['features'] gen_features = gen_features_file['features'] real_img = real_img_file['images'] gen_img = gen_img_file['images'] with tf.Session() as sess: real_features = tf.constant(np.array(real_features), dtype=tf.float32) gen_features = tf.constant(np.array(gen_features), dtype=tf.float32) # Get Nearest Neighbors for all generated images. gen_real_distances = tf.sqrt(tf.abs(euclidean_distance(gen_features, real_features))) neg = tf.negative(gen_real_distances) neg_s_distances, s_indices = tf.math.top_k(input=neg, k=nearneig, sorted=True) s_distances = tf.negative(neg_s_distances) s_indices = s_indices.eval() s_distances = s_distances.eval() # For the images with top smallest distances, show nearest neighbors. height, width, channels = real_img.shape[1:] neighbors = dict() grid = np.zeros((len(generated_list)*height, (nearneig+1)*width, channels)) for i, ind in enumerate(generated_list): total = gen_img[ind] neighbors[ind] = list() for j in range(nearneig): neighbors[ind].append((s_indices[ind,j], s_distances[ind,j])) real = real_img[s_indices[ind,j]]/255. total = np.concatenate([total, real], axis=1) grid[i*height:(i+1)*height, :, :] = total plt.imshow(grid) if save_path is not None: plt.imsave(save_path, grid) return neighbors
def create_network(self): networks = {} with tf.variable_scope('q_net'): # Input parameters x = networks['x'] = tf.placeholder(tf.float32, \ shape=[None, self.states], name='states') u = networks['u'] = tf.placeholder(tf.float32, \ shape=[None, self.actions], name='actions') # hidden layers init = 1./self.hidden_nodes/self.actions hid = tf.concat([x, u], axis=1) hid = fully_connected(hid, self.hidden_nodes, \ weights_initializer=tf.random_normal_initializer(init, init/5), \ biases_initializer=tf.random_normal_initializer(init, init/5), \ activation_fn=tf.tanh) for i in range(self.hidden_layers-1): hid = fully_connected(hid, self.hidden_nodes, \ weights_initializer=tf.random_normal_initializer(init, init/5), \ biases_initializer=tf.random_normal_initializer(init, init/5), \ activation_fn=tf.nn.relu) # Output parameters pos_layer = fully_connected(hid, 1, \ weights_initializer=tf.random_normal_initializer(1./self.actions, 0.1), \ biases_initializer=tf.random_normal_initializer(1./self.actions, 0.1)) neg_layer = tf.negative(fully_connected(hid, 1, \ weights_initializer=tf.random_normal_initializer(1./self.actions, 0.1), \ biases_initializer=tf.random_normal_initializer(1./self.actions, 0.1))) Q = networks['Q'] = pos_layer + neg_layer # Describe loss functions. y_ = networks['y_'] = tf.placeholder(tf.float32, [None, 1], name='y_i') # Tensor outputs to calculate y_i values networks['reward'] = tf.placeholder(tf.float32, [None, 1], name='reward') networks['y_calc'] = tf.add(networks['reward'], tf.multiply(Q, self.gamma)) networks['mse'] = tf.reduce_mean(tf.squared_difference(y_, \ Q), name='mse') networks['cross_entropy'] = -tf.reduce_sum(y_ * tf.log(Q), name='cross_entropy') networks['optimize'] = tf.train.AdamOptimizer(\ learning_rate=self.alpha) \ .minimize(networks['mse']) self.tensors = networks return
def _GradientReversalGrad(_, grad): """The gradients for `gradient_reversal`. Args: _: The `gradient_reversal` `Operation` that we are differentiating, which we can use to find the inputs and outputs of the original op. grad: Gradient with respect to the output of the `gradient_reversal` op. Returns: Gradient with respect to the input of `gradient_reversal`, which is simply the negative of the input gradient. """ return tf.negative(grad)
def k_nearest_neighbor_tf_part(x, y, k): x_samples = tf.shape(x)[0] y_samples = tf.shape(y)[0] xx_d = euclidean_distance(x, x) yy_d = euclidean_distance(y, y) xy_d = euclidean_distance(x, y) labels = tf.concat([tf.ones((x_samples,1)), tf.zeros((y_samples,1))], axis=0) x_dist = tf.concat([xx_d, xy_d], axis=-1) y_dist = tf.concat([tf.transpose(xy_d), yy_d], axis=-1) total_dist = tf.concat([x_dist, y_dist], axis=0) ''' x1x1 x1x2 ... x1x100 | x1y1 x1xy2 ... x1y200 ... | ... x100x1 x100x2 ... x100x100 | x100y1 x100xy2 ... x100y200 ________________________________________________________ y1x1 y1x2 ... y1x100 | y1y1 y1xy2 ... y1y200 ... | ... y100x1 y100x2 ... y100x100 | y100y1 y1xy2 ... y100y100 ... | ... y200x1 y200x2 ... y200x100 | y200y1 y200xy2 ... y200y200 Diagonals of this tensor are the distance for the vector with itself. ''' total_dist = tf.sqrt(tf.abs(total_dist)) inf_eye = tf.eye(tf.shape(total_dist)[0])*1e+7 #All element positive now, no smallest elements functions. all_dist = tf.math.add(inf_eye, total_dist) neg_all_dist = tf.negative(all_dist) values, indices = tf.math.top_k(input=neg_all_dist, k=k, sorted=True) values = tf.negative(values) return indices, labels
def GMM_M_Step(X, Gama, ClusterNo, name='GMM_Statistics', **kwargs): D, h, s = tf.split(X, [1,1,1], axis=3) WXd = tf.multiply(Gama, tf.tile(D ,[1,1,1,ClusterNo])) WXa = tf.multiply(Gama, tf.tile(h ,[1,1,1,ClusterNo])) WXb = tf.multiply(Gama, tf.tile(s ,[1,1,1,ClusterNo])) S = tf.reduce_sum(tf.reduce_sum(Gama, axis=1), axis=1) S = tf.add(S, tf.contrib.keras.backend.epsilon()) S = tf.reshape(S,[1, ClusterNo]) M_d = tf.div(tf.reduce_sum(tf.reduce_sum(WXd, axis=1), axis=1) , S) M_a = tf.div(tf.reduce_sum(tf.reduce_sum(WXa, axis=1), axis=1) , S) M_b = tf.div(tf.reduce_sum(tf.reduce_sum(WXb, axis=1), axis=1) , S) Mu = tf.split(tf.concat([M_d, M_a, M_b],axis=0), ClusterNo, 1) Norm_d = tf.squared_difference(D, tf.reshape(M_d,[1, ClusterNo])) Norm_h = tf.squared_difference(h, tf.reshape(M_a,[1, ClusterNo])) Norm_s = tf.squared_difference(s, tf.reshape(M_b,[1, ClusterNo])) WSd = tf.multiply(Gama, Norm_d) WSh = tf.multiply(Gama, Norm_h) WSs = tf.multiply(Gama, Norm_s) S_d = tf.sqrt(tf.div(tf.reduce_sum(tf.reduce_sum(WSd, axis=1), axis=1) , S)) S_h = tf.sqrt(tf.div(tf.reduce_sum(tf.reduce_sum(WSh, axis=1), axis=1) , S)) S_s = tf.sqrt(tf.div(tf.reduce_sum(tf.reduce_sum(WSs, axis=1), axis=1) , S)) Std = tf.split(tf.concat([S_d, S_h, S_s],axis=0), ClusterNo, 1) dist = list() for k in range(0, ClusterNo): dist.append(tf.contrib.distributions.MultivariateNormalDiag(tf.reshape(Mu[k],[1,3]), tf.reshape(Std[k],[1,3]))) PI = tf.split(Gama, ClusterNo, axis=3) Prob0 = list() for k in range(0, ClusterNo): Prob0.append(tf.multiply(tf.squeeze(dist[k].prob(X)), tf.squeeze(PI[k]))) Prob = tf.convert_to_tensor(Prob0, dtype=tf.float32) Prob = tf.minimum(tf.add(tf.reduce_sum(Prob, axis=0), tf.contrib.keras.backend.epsilon()), tf.constant(1.0, tf.float32)) Log_Prob = tf.negative(tf.log(Prob)) Log_Likelihood = tf.reduce_mean(Log_Prob) return Log_Likelihood, Mu, Std
def testGradientReversalOp(self): with tf.Graph().as_default(): with self.test_session(): # Test that in forward prop, gradient reversal op acts as the # identity operation. examples = tf.constant([5.0, 4.0, 3.0, 2.0, 1.0]) output = grl_ops.gradient_reversal(examples) expected_output = examples self.assertAllEqual(output.eval(), expected_output.eval()) # Test that shape inference works as expected. self.assertAllEqual(output.get_shape(), expected_output.get_shape()) # Test that in backward prop, gradient reversal op multiplies # gradients by -1. examples = tf.constant([[1.0]]) w = tf.get_variable(name='w', shape=[1, 1]) b = tf.get_variable(name='b', shape=[1]) init_op = tf.global_variables_initializer() init_op.run() features = tf.nn.xw_plus_b(examples, w, b) # Construct two outputs: features layer passes directly to output1, but # features layer passes through a gradient reversal layer before # reaching output2. output1 = features output2 = grl_ops.gradient_reversal(features) gold = tf.constant([1.0]) loss1 = gold - output1 loss2 = gold - output2 opt = tf.train.GradientDescentOptimizer(learning_rate=0.01) grads_and_vars_1 = opt.compute_gradients(loss1, tf.trainable_variables()) grads_and_vars_2 = opt.compute_gradients(loss2, tf.trainable_variables()) self.assertAllEqual(len(grads_and_vars_1), len(grads_and_vars_2)) for i in range(len(grads_and_vars_1)): g1 = grads_and_vars_1[i][0] g2 = grads_and_vars_2[i][0] # Verify that gradients of loss1 are the negative of gradients of # loss2. self.assertAllEqual(tf.negative(g1).eval(), g2.eval())
def qfun(theta, allout, init, final): q = [] # first term in the summation (j=1 case) part1 = logG(gl.grid,init,theta) q.append(tf.reduce_sum(tf.multiply(part1,allout[1][:,0]))*gl.k) # last term in the summation (j=F case) part2 = logG(final,gl.grid,theta) q.append(tf.reduce_sum(tf.multiply(part2,allout[2][:,0]))*gl.k) # all intermediate terms part3 = logG(gl.gridx,gl.gridy,theta) # for j in range(gl.numsteps-2): # q.append(tf.tensordot(part3,allout[3][j,:],axes=[[0,1],[0,1]])*gl.k*gl.k) # test = tf.add_n(test) q.append(tf.reduce_sum(tf.multiply(tf.expand_dims(part3,0),allout[3]))*gl.k*gl.k) qout = tf.negative(tf.add_n(q)) return qout
def gauss(mean, stddev, ksize): """Use Tensorflow to compute a Gaussian Kernel. Parameters ---------- mean : float Mean of the Gaussian (e.g. 0.0). stddev : float Standard Deviation of the Gaussian (e.g. 1.0). ksize : int Size of kernel (e.g. 16). Returns ------- kernel : np.ndarray Computed Gaussian Kernel using Tensorflow. """ g = tf.Graph() with tf.Session(graph=g): x = tf.linspace(-3.0, 3.0, ksize) z = (tf.exp(tf.negative(tf.pow(x - mean, 2.0) / (2.0 * tf.pow(stddev, 2.0)))) * (1.0 / (stddev * tf.sqrt(2.0 * 3.1415)))) return z.eval()
def _word_dropout(words, input_keep_prob): """Drops words with probability 1 - input_keep_prob. Args: words: a list of lemmas from the paths. input_keep_prob: the probability to keep the word. Returns: The revised list where some of the words are <UNK>ed. """ # Create the mask: (-1) to drop, 1 to keep prob = tf.random_uniform(tf.shape(words), 0, 1) condition = tf.less(prob, (1 - input_keep_prob)) mask = tf.where(condition, tf.negative(tf.ones_like(words)), tf.ones_like(words)) # We need to keep zeros (<PAD>), and change other numbers to 1 (<UNK>) # if their mask is -1. First, we multiply the mask and the words. # Zeros will stay zeros, and words to drop will become negative. # Then, we change negative values to 1. masked_words = tf.multiply(mask, words) condition = tf.less(masked_words, 0) dropped_words = tf.where(condition, tf.ones_like(words), words) return dropped_words
def _build_likelihood(self): """ Construct a tensorflow function to compute the bound on the marginal likelihood. For a derivation of the terms in here, see the associated SGPR notebook. """ num_inducing = len(self.feature) num_data = tf.cast(tf.shape(self.Y)[0], settings.float_type) output_dim = tf.cast(tf.shape(self.Y)[1], settings.float_type) err = self.Y - self.mean_function(self.X) Kdiag = self.kern.Kdiag(self.X) Kuf = self.feature.Kuf(self.kern, self.X) Kuu = self.feature.Kuu(self.kern, jitter=settings.numerics.jitter_level) L = tf.cholesky(Kuu) sigma = tf.sqrt(self.likelihood.variance) # Compute intermediate matrices A = tf.matrix_triangular_solve(L, Kuf, lower=True) / sigma AAT = tf.matmul(A, A, transpose_b=True) B = AAT + tf.eye(num_inducing, dtype=settings.float_type) LB = tf.cholesky(B) Aerr = tf.matmul(A, err) c = tf.matrix_triangular_solve(LB, Aerr, lower=True) / sigma # compute log marginal bound bound = -0.5 * num_data * output_dim * np.log(2 * np.pi) bound += tf.negative(output_dim) * tf.reduce_sum(tf.log(tf.matrix_diag_part(LB))) bound -= 0.5 * num_data * output_dim * tf.log(self.likelihood.variance) bound += -0.5 * tf.reduce_sum(tf.square(err)) / self.likelihood.variance bound += 0.5 * tf.reduce_sum(tf.square(c)) bound += -0.5 * output_dim * tf.reduce_sum(Kdiag) / self.likelihood.variance bound += 0.5 * output_dim * tf.reduce_sum(tf.matrix_diag_part(AAT)) return bound
def _flip_gradients(op, grad): return [tf.negative(grad) * hp_lambda]
my_kernel = tf.exp(tf.multiply(gamma, tf.abs(sq_dists))) # Declare function to do reshape/batch multiplication def reshape_matmul(mat, _size): v1 = tf.expand_dims(mat, 1) v2 = tf.reshape(v1, [3, _size, 1]) return tf.matmul(v2, v1) # Compute SVM Model first_term = tf.reduce_sum(b) b_vec_cross = tf.matmul(tf.transpose(b), b) y_target_cross = reshape_matmul(y_target, batch_size) second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_target_cross)), [1, 2]) loss = tf.reduce_sum(tf.negative(tf.subtract(first_term, second_term))) # Gaussian (RBF) prediction kernel 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)))), tf.transpose(rB)) pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist))) prediction_output = tf.matmul(tf.multiply(y_target, b), pred_kernel) prediction = tf.argmax(prediction_output - tf.expand_dims(tf.reduce_mean(prediction_output, 1), 1), 0) accuracy = tf.reduce_mean(tf.cast(tf.equal(prediction, tf.argmax(y_target, 0)), tf.float32)) # Declare optimizer my_opt = tf.train.GradientDescentOptimizer(0.01) train_step = my_opt.minimize(loss)
def build_losses(self, vecpos, vecneg): # the Wasserstein-GAN losses self.d_loss = tf.reduce_mean(vecneg - vecpos, name='d_loss') self.g_loss = tf.negative(tf.reduce_mean(vecneg), name='g_loss') add_moving_summary(self.d_loss, self.g_loss)
def logprob_grads(): logprob = tf.negative(model.build_objective()) grads = tf.gradients(logprob, xs) return logprob, grads
def _flip_gradients(op, grad): return [tf.negative(grad) * l]
def buildNetwork(self): self.stateTrain = tf.placeholder(tf.float32, shape=[None, self.inputSize], name="stateTrain") self.critic_rewards = tf.placeholder(tf.float32, shape=[None], name="critic_rewards") self.new_lr = tf.placeholder(tf.float32, shape=[], name="learning_rate") self.lr = tf.Variable(0.01, trainable=False) # PolicyNetwork with tf.variable_scope("Policy"): self.weights1 = tf.placeholder( tf.float32, shape=[self.inputSize, self.hiddenSize], name="weights1") self.biases1 = tf.placeholder(tf.float32, shape=[self.hiddenSize], name="biases1") self.weights2 = tf.placeholder( tf.float32, shape=[self.hiddenSize, self.hiddenSize], name="weights2") self.biases2 = tf.placeholder(tf.float32, shape=[self.hiddenSize], name="biases2") self.weights3 = tf.placeholder( tf.float32, shape=[self.hiddenSize, self.hiddenSize], name="weights3") self.biases3 = tf.placeholder(tf.float32, shape=[self.hiddenSize], name="biases3") #变量保存 self.w1 = tf.get_variable( "w1", [self.inputSize, self.hiddenSize], dtype=tf.float32, initializer=tf.truncated_normal_initializer( stddev=1.0 / math.sqrt(float(self.hiddenSize))), trainable=True) self.b1 = tf.get_variable("b1", [self.hiddenSize], dtype=tf.float32, initializer=tf.zeros_initializer(), trainable=True) self.w2 = tf.get_variable( "w2", [self.hiddenSize, self.hiddenSize], dtype=tf.float32, initializer=tf.truncated_normal_initializer( stddev=1.0 / math.sqrt(float(self.hiddenSize))), trainable=True) self.b2 = tf.get_variable("b2", [self.hiddenSize], dtype=tf.float32, initializer=tf.zeros_initializer(), trainable=True) self.w3 = tf.get_variable( "w3", [self.hiddenSize, self.hiddenSize], dtype=tf.float32, initializer=tf.truncated_normal_initializer( stddev=1.0 / math.sqrt(float(self.hiddenSize))), trainable=True) self.b3 = tf.get_variable("b3", [self.hiddenSize], dtype=tf.float32, initializer=tf.zeros_initializer(), trainable=True) self.update_w1 = tf.assign(self.w1, self.weights1) self.update_w2 = tf.assign(self.w2, self.weights2) self.update_w3 = tf.assign(self.w3, self.weights3) self.update_b1 = tf.assign(self.b1, self.biases1) self.update_b2 = tf.assign(self.b2, self.biases2) self.update_b3 = tf.assign(self.b3, self.biases3) activation = tf.nn.relu L0 = activation(tf.matmul(self.stateTrain, self.w1) + self.b1) L1 = activation(tf.matmul(L0, self.w2) + self.b2) L2 = activation(tf.matmul(L1, self.w2) + self.b2) #L2 = tf.reshape(L2, [-1, self.stepNum, self.hiddenSize]) L2 = tf.reshape(L2, [1, -1, self.hiddenSize]) #construct a lstmcell ,the size is neuronNum lstmcell = tf.contrib.rnn.BasicRNNCell(self.neuronNum) cell = tf.contrib.rnn.DropoutWrapper(lstmcell, output_keep_prob=0.5) #lstmcell = tf.contrib.rnn.BasicLSTMCell(self.neuronNum, forget_bias=1.0, state_is_tuple=True,activation=tf.nn.relu) #cell_drop=tf.contrib.rnn.DropoutWrapper(lstmcell, output_keep_prob=0.5) #construct 5 layers of LSTM #cell = tf.contrib.rnn.MultiRNNCell([cell_drop for _ in range(2)], state_is_tuple=True) #系统下一时刻的状态仅由当前时刻的状态产生 outputnew, statenew = tf.nn.dynamic_rnn(cell, L2, dtype=tf.float32) #outputs = self.outputs = outputnew[:,self.stepNum-1,:] # 取最后一个step的结果 outputs = self.outputs = tf.reshape( outputnew, [-1, self.stepNum, self.neuronNum]) outputs = outputs[:, 0, :] softmax_w = tf.get_variable( "softmax_w", [self.neuronNum, 3], dtype=tf.float32, initializer=tf.truncated_normal_initializer( stddev=1.0 / math.sqrt(float(self.neuronNum)))) softmax_b = tf.get_variable("softmax_b", [3], dtype=tf.float32) logits = tf.matmul(outputs, softmax_w) + softmax_b self.probs = tf.nn.softmax(logits, name="action") # fetch the maximum probability # fetch the index of the maximum probability self.action0 = tf.reduce_max(self.probs, axis=1) self.argAction = tf.argmax(self.probs, axis=1) #--------------------------continuous action----------- #curact = tf.reshape(self.action0,[-1,30]) #curarg = tf.reshape(self.argAction,[-1,30]) #--------------------------result----------------------- #self.curact = curact[:,29] #self.curarg = curarg[:,29] #self.policyloss = policyloss = tf.log(self.curact)*self.critic_rewards #self.loss = loss = tf.negative(tf.reduce_mean(policyloss),name="loss") #loss,train self.lr_update = tf.assign(self.lr, self.new_lr) self.policyloss = policyloss = tf.log( self.action0) * self.critic_rewards self.loss = loss = tf.negative(tf.reduce_mean(policyloss), name="loss") tf.summary.scalar('actor_loss', loss) #self.actor_train = tf.train.AdamOptimizer(self.lr).minimize(loss) tvars = tf.trainable_variables() #得到可以训练的参数 self.agrads, _ = tf.clip_by_global_norm(tf.gradients(loss, tvars), 5) #防止梯度爆炸 optimizer = tf.train.AdamOptimizer(self.lr) self.actor_train = optimizer.apply_gradients( zip(self.agrads, tvars))
def __init__(self, board_width, board_height, model_file=None): self.board_width = board_width self.board_height = board_height self.action_numbers = 96 # Define the tensorflow neural network # 1. Input: 第一个参数为样本数量,第二个参数为通道数,第三个参数为棋盘高,第四个参数为棋盘宽 self.input_states = tf.placeholder( tf.float32, shape=[None, 4, board_height, board_width]) #将通道数放在最后。第一个通道为自己占据的位置表示,第二个棋盘为敌方占据位置,第三个通道为最后一颗棋 self.input_state = tf.transpose(self.input_states, [0, 2, 3, 1]) # 2. Common Networks Layers #data_format:channels_last对应于具有形状(批次,高度,宽度,通道)的输入,而channels_first对应于具有形状的输入(批次,通道,高度,宽度) self.conv1 = tf.layers.conv2d(inputs=self.input_state, filters=32, kernel_size=[3, 3], padding="same", data_format="channels_last", activation=tf.nn.relu) self.conv2 = tf.layers.conv2d(inputs=self.conv1, filters=64, kernel_size=[3, 3], padding="same", data_format="channels_last", activation=tf.nn.relu) self.conv3 = tf.layers.conv2d(inputs=self.conv2, filters=128, kernel_size=[3, 3], padding="same", data_format="channels_last", activation=tf.nn.relu) # 3-1 Action Networks self.action_conv = tf.layers.conv2d(inputs=self.conv3, filters=4, kernel_size=[1, 1], padding="same", data_format="channels_last", activation=tf.nn.relu) # Flatten the tensor self.action_conv_flat = tf.reshape( self.action_conv, [-1, 4 * board_height * board_width]) # 3-2 Full connected layer, the output is the log probability of moves # on each slot on the board self.action_fc = tf.layers.dense(inputs=self.action_conv_flat, units=self.action_numbers, activation=tf.nn.log_softmax) # 4 Evaluation Networks self.evaluation_conv = tf.layers.conv2d(inputs=self.conv3, filters=2, kernel_size=[1, 1], padding="same", data_format="channels_last", activation=tf.nn.relu) self.evaluation_conv_flat = tf.reshape( self.evaluation_conv, [-1, 2 * board_height * board_width]) self.evaluation_fc1 = tf.layers.dense(inputs=self.evaluation_conv_flat, units=64, activation=tf.nn.relu) # output the score of evaluation on current state self.evaluation_fc2 = tf.layers.dense(inputs=self.evaluation_fc1, units=1, activation=tf.nn.tanh) # Define the Loss function # 1. Label: the array containing if the game wins or not for each state self.labels = tf.placeholder(tf.float32, shape=[None, 1]) # 2. Predictions: the array containing the evaluation score of each state # which is self.evaluation_fc2 # 3-1. Value Loss function self.value_loss = tf.losses.mean_squared_error(self.labels, self.evaluation_fc2) # 3-2. Policy Loss function self.mcts_probs = tf.placeholder(tf.float32, shape=[None, self.action_numbers]) self.policy_loss = tf.negative( tf.reduce_mean( tf.reduce_sum(tf.multiply(self.mcts_probs, self.action_fc), 1))) # 3-3. L2 penalty (regularization) l2_penalty_beta = 1e-4 vars = tf.trainable_variables() l2_penalty = l2_penalty_beta * tf.add_n( [tf.nn.l2_loss(v) for v in vars if 'bias' not in v.name.lower()]) # 3-4 Add up to be the Loss function self.loss = self.value_loss + self.policy_loss + l2_penalty # Define the optimizer we use for training self.learning_rate = tf.placeholder(tf.float32) self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate).minimize(self.loss) # Make a session self.session = tf.Session() # calc policy entropy, for monitoring only self.entropy = tf.negative( tf.reduce_mean( tf.reduce_sum(tf.exp(self.action_fc) * self.action_fc, 1))) # Initialize variables init = tf.global_variables_initializer() self.session.run(init) # For saving and restoring self.saver = tf.train.Saver() if model_file is not None: self.restore_model(model_file)
Xtr = normalizedFunc(Xtr) Xte = normalizedFunc(Xte) # In[84]: # tf Graph Input xtr = tf.placeholder("float", [None, 5]) xte = tf.placeholder("float", [5]) # Nearest Neighbor calculation using L1 Distance # Calculate L1 Distance distance = tf.reduce_sum(tf.abs(tf.add(xtr, tf.negative(xte))), reduction_indices=1) # Prediction: Get min distance index (Nearest neighbor) pred = tf.arg_min(distance, 0) accuracy = 0. # Initialize the variables (i.e. assign their default value) init = tf.global_variables_initializer() predi = [] truePred = [] # Start training with tf.Session() as sess: # Run the initializer
def sigma(x): return tf.div(tf.constant(1.0), tf.add(tf.constant(1.0), tf.exp(tf.negative(x))))
def __neg__(self): return tf.negative(self)
train_pixels,train_list_values = mnist.train.next_batch(100) test_pixels,test_list_of_values = mnist.test.next_batch(10) train_pixel_tensor = tf.placeholder\ ("float", [None, 784]) test_pixel_tensor = tf.placeholder\ ("float", [784]) #Cost Function and distance optimization distance = tf.reduce_sum\ (tf.abs\ (tf.add(train_pixel_tensor, \ tf.negative(test_pixel_tensor))), \ reduction_indices=1) pred = tf.arg_min(distance, 0) # Testing and algorithm evaluation accuracy = 0. init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for i in range(len(test_list_of_values)): nn_index = sess.run(pred,\ feed_dict={train_pixel_tensor:train_pixels,\ test_pixel_tensor:test_pixels[i,:]}) print "Test N ", i,"Predicted Class: ", \
global testBatchCounter batchX = test_images[testBatchCounter:testBatchCounter + batchSize, :, :] batchY = test_labels[testBatchCounter:testBatchCounter + batchSize, :] testBatchCounter = testBatchCounter + int(batchSize) return (batchX, batchY) train_batchX, train_batchY = nextTrainBatch(25000) test_batchX, test_batchY = nextTestBatch(1000) X = tf.placeholder(tf.float32, [None, 32, 32, 3]) XX = tf.reshape(X, [-1, 3 * 32 * 32]) X_test = tf.placeholder(tf.float32, [32, 32, 3]) XX_test = tf.reshape(X_test, [-1, 3 * 32 * 32]) distance = tf.reduce_sum(tf.abs(tf.add(XX, tf.negative(XX_test))), reduction_indices=1) pred = tf.arg_min(distance, 0) accuracy = 0. init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for i in range(len(test_batchX)): nn_index = sess.run(pred, feed_dict={ X: train_batchX, X_test: test_batchX[i, :] })
#导入mnist数据 from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("mnist_data/", one_hot=True) #数据集和标签 Xtrain, Ytrain = mnist.train.next_batch(5000) Xtest, Ytest = mnist.test.next_batch(1000) print("Xtrain.shape: ", Xtrain.shape, "Xtest.shape: ", Xtest.shape) print("Ytrain.shape: ", Ytrain.shape, "Ytest.shape: ", Ytest.shape) #计算图 xtrain = tf.placeholder("float", [None, 784]) xtest = tf.placeholder("float", [784]) tmp = tf.add(xtrain, tf.negative(xtest)) distance = tf.reduce_sum(tf.abs(tmp), axis=1) pred = tf.arg_min(distance, 0) init = tf.global_variables_initializer() #启动会话 with tf.Session() as sess: sess.run(init) accuracy = 0. Ntest = len(Xtest) for i in range(Ntest): nn_index = sess.run(pred, feed_dict={ xtrain: Xtrain,
def sigmoid(v): return tf.div(tf.constant(1.0),tf.add(tf.constant(1.0),tf.exp(tf.negative(v))))
def bond(bl): return tf.add(K.relu(tf.negative(bl)), K.relu(bl - 1.0))
def poros(poroi, porof): return K.relu(tf.negative(porof)) + K.relu(porof - poroi)
def log_jacobian_tensor(self, x): return tf.negative(tf.reduce_sum(tf.nn.softplus(tf.negative(x))))
label_array.append([1, 0]) except: pass path_images('train', train_images, train_labels) # opencv cap = cv2.VideoCapture(0) # tensorflow tf.reset_default_graph() trainX = tf.placeholder(tf.float32, shape=[None, 2500]) centroid = tf.placeholder(tf.float32, 2500) distance = tf.reduce_sum(tf.abs(tf.add(trainX, tf.negative(centroid))), reduction_indices=1) prediction = tf.arg_min(distance, 0) _ = tf.Variable(initial_value='fake_variable') accuracy = 0 init = tf.global_variables_initializer() saver = tf.train.Saver() with tf.Session() as sess: sess.run(init) saver.restore(sess, './neighbor_model.ckpt') while True:
def negative_network(): input_ = tf.placeholder(tf.float32, shape=[1, 2, 2, 3], name="input") return input_, tf.negative(input_)
dist = tf.reshape(dist, [-1,1]) sq_dists = tf.add(tf.subtract(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))) def reshape_matmul(mat): v1 = tf.expand_dims(mat, 1) v2 = tf.reshape(v1, [3, batch_size, 1]) return(tf.matmul(v2, v1)) model_output = tf.matmul(b, my_kernel) first_term = tf.reduce_sum(b) b_vec_cross = tf.matmul(tf.transpose(b), b) y_target_cross = reshape_matmul(y_target) second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_target_cross)),[1,2]) loss = tf.reduce_sum(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)))), tf.transpose(rB)) pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist))) prediction_output = tf.matmul(tf.multiply(y_target,b), pred_kernel) prediction = tf.argmax(prediction_output-tf.expand_dims(tf.reduce_mean(prediction_output,1), 1), 0) accuracy = tf.reduce_mean(tf.cast(tf.equal(prediction,tf.argmax(y_target,0)), tf.float32)) my_opt = tf.train.GradientDescentOptimizer(0.01) train_step = my_opt.minimize(loss) # Initialize variables init = tf.global_variables_initializer()
# Import MNIST data from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("../../data/MNIST_data", one_hot=True) # In this example, we limit mnist data Xtr, Ytr = mnist.train.next_batch(5000) #5000 for training (nn candidates) Xte, Yte = mnist.test.next_batch(200) #200 for testing # tf Graph Input xtr = tf.placeholder("float", [None, 784]) xte = tf.placeholder("float", [784]) # Nearest Neighbor calculation using L1 Distance # Calculate L1 Distance distance = tf.reduce_sum(tf.abs(tf.add(xtr, tf.negative(xte))), reduction_indices=1) # Prediction: Get min distance index (Nearest neighbor) pred = tf.arg_min(distance, 0) accuracy = 0. # Initializing the variables init = tf.global_variables_initializer() # Launch the graph with tf.Session() as sess: sess.run(init) # loop over test data for i in range(len(Xte)): # Get nearest neighbor
def sigmoid(x): sigma = tf.div(tf.constant(1.0), tf.add(tf.constant(1.0), tf.exp(tf.negative(x)))) return sigma
def tanh(x): return tf.div(tf.subtract(tf.exp(x, tf.exp(tf.negative(x)))), tf.add(tf.exp(x, tf.exp(tf.negative(x)))))
# I think here I am right and the book is wrong, mine is RBF actually sq_dist = tf.subtract(tf.multiply(2., dist), tf.matmul(x_data, tf.transpose(x_data))) # sq_dist = tf.add(tf.subtract(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_dist))) # linear # my_kernel = tf.matmul(x_data, tf.transpose(x_data)) # dual part # max(sum(ai) - 1/2 sum(aiajyiyj <xi,xj>)), where sum(aiyi) = 0 # let the negative to be minimal == max first_term = tf.reduce_sum(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, tf.multiply(1/2, 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)))), tf.transpose(rB)) pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist))) prediction_output = tf.matmul(tf.multiply(tf.transpose(y_target), b), pred_kernel) prediction = tf.sign(prediction_output-tf.reduce_mean(prediction_output)) accuracy = tf.reduce_mean(tf.cast(tf.equal( tf.squeeze(prediction), tf.squeeze(y_target)), tf.float32)) train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
def train(x_train, y_train, supervised=0.10, epochs=1000, delta=0.001): """Training function, takes in a training set and its labels and uses gradient descent w/ logistic loss to calculate feature weights and bias for a classifier Arguments: x_train: ndarray (samplesxfeatures) The training set y_train: ndarray (samplesx1) The labels of the training set epochs: int, default 100 Number of training iterations delta: float, default 0.01 Gradient descent change parameter Returns c: ndarray (featuresx1) The calculated sample weights after training b: float The calculated bias after training """ m = x_train.shape[0] k = int(m * supervised) for i in range(k, m): y_train[i] = 0 print("\t# of total samples: {}".format(m)) print("\t# of supervised samples: {}".format(k)) K = tf.constant(utils.getK(x_train, x_train), name="K") L = tf.constant(getL(x_train), name="L") c = tf.Variable(np.random.rand(m, 1).astype(dtype='float64'), name="c") # Gaussian thing (samplesx1) b = tf.Variable(0.0, dtype=tf.float64, name="b") # Bias offset (scalar) y = tf.placeholder(dtype=tf.float64, name='y', shape=[m, 1]) # Training set labels (samplesx1) # First part of formula l = lambda i: tf.log(1 + tf.exp( tf.negative(y[i][0]) * (tf.reduce_sum(tf.multiply(c, tf.reshape(K[i], [-1, 1]))) + b))) # Second part of formula term1 = 0.5 * tf.matmul(tf.transpose(c), tf.matmul(K, c))[0][0] # Third part of formula term2 = tf.matmul(tf.transpose(c), tf.matmul(K, tf.matmul(L, tf.matmul(K, c))))[0][0] _, loss = tf.while_loop(lambda i, s: tf.less(i, k), lambda i, s: (i + 1, s + l(i) + term1 + term2), [ tf.constant(0, name="loss_i"), tf.constant(0, dtype=tf.float64, name="loss_s") ]) train = tf.train.GradientDescentOptimizer(delta).minimize(loss) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(epochs): # print("Epoch {}".format(i)) sess.run([train], feed_dict={y: y_train}) # print(sess.run(loss, feed_dict={y: y_train})) curr_c, curr_b = sess.run([c, b]) return curr_c, curr_b
def buildNetwork(self): with tf.name_scope('input'): # self.x = tf.placeholder(tf.float32, shape=[100,784], name='x') # self.y_= tf.placeholder(tf.float32,shape=[100,10],name="y_") self.states = tf.placeholder(tf.float32,shape=[None,120,20],name= "states") self.actions_taken = tf.placeholder(tf.float32,shape=[None],name= "actions_taken") self.critic_feedback = tf.placeholder(tf.float32,shape=[None],name= "critic_feedback") self.critic_rewards = tf.placeholder(tf.float32,shape=[None],name= "critic_rewards") def lstm_cell(size): return tf.contrib.rnn.BasicLSTMCell(size, forget_bias=0.0, state_is_tuple=True) # ActorNetwork with tf.variable_scope("actor") : L1= tf.contrib.layers.fully_connected( inputs=self.states, num_outputs= 20, #hidden activation_fn= tf.tanh, weights_initializer = tf.random_normal_initializer(), biases_initializer = tf.zeros_initializer() ) print("L1:",L1) lstmcell=tf.contrib.rnn.BasicLSTMCell(20, forget_bias=0.0, state_is_tuple=True) cell = tf.contrib.rnn.MultiRNNCell([lstmcell for _ in range(5)], state_is_tuple=True) #self._initial_state=cell.zero_state(batchsize,tf.float32) #input = tf.reshape(L1,[100,28,28]) state = cell.zero_state(100,tf.float32) #batchsize*hidden cells outputs = [] for time_step in range(120): if time_step > 0: tf.get_variable_scope().reuse_variables() (cell_output, state) = cell(L1[:,time_step,:], state) outputs.append(cell_output) # tf.get_variable_scope().reuse_variables() output = tf.reshape(tf.concat(axis=1, values=outputs), [-1, 20]) print("output",output) weights = tf.Variable(tf.truncated_normal([20, 3],stddev=1.0 / math.sqrt(float(1200))),name='weights') biases = tf.Variable(tf.zeros([3]),name='biases') logits = tf.matmul(output, weights) + biases #weights = tf.Variable("softmax_w", [20, 3], dtype=float32) #softmax_w = tf.get_variable( "softmax_w", [20, 3], dtype=tf.float32) #softmax_b = tf.get_variable("softmax_b", [3], dtype=tf.float32) #logits = tf.matmul(output, softmax_w) + softmax_b self.probs = tf.nn.softmax(logits,name="action") #print("action",self.action) #print(tf.shape(self.action)) #self.action =np.amax(self.action0,axis=self.action0[0]) #self.action =tf.multinomial(tf.log(self.action0),1) #self.action = tf.shape(self.action0)[1] #gather_indices = tf.range(100) * tf.shape(self.action0)[1] + self.actions_taken #self.action = tf.gather(tf.reshape(self.action0, [-1]), gather_indices) #print("action",self.action) gather_indices = tf.range(tf.shape(self.probs)[0]) * tf.shape(self.probs)[1] + self.actions_taken self.action = tf.gather(tf.reshape(self.probs, [-1]), gather_indices) print("action",self.action) #loss,train policyloss = tf.log(self.action)*(self.critic_rewards-self.critic_feedback) loss = tf.negative(tf.reduce_mean(policyloss),name="loss") #with tf.variable_scope("actor-train"): # self.actor_train = tf.train.AdamOptimizer(0.01).minimize(loss) # tf.get_variable_scope().reuse_variables() tvars = tf.trainable_variables() grads, _ = tf.clip_by_global_norm(tf.gradients(loss, tvars),5) optimizer = tf.train.GradientDescentOptimizer(0.01) self.actor_train = optimizer.apply_gradients(zip(grads, tvars)) # Critic Network with tf.variable_scope("critic") as scopeB: self.critic_target = tf.placeholder(tf.float32,name= "critic_target") critic_L1= tf.contrib.layers.fully_connected( inputs=self.states, num_outputs= 20, #hidden activation_fn= tf.tanh, weights_initializer = tf.random_normal_initializer(), biases_initializer = tf.zeros_initializer() ) # lstmcell=lstm_cell() lstmcell=tf.contrib.rnn.BasicLSTMCell(20, forget_bias=0.0, state_is_tuple=True) cell = tf.contrib.rnn.MultiRNNCell([lstmcell for _ in range(5)], state_is_tuple=True) self._initial_state=cell.zero_state(100,tf.float32) #scopeB.reuse_variables() state = cell.zero_state(100,tf.float32) #batchsize*hidden cells outputs = [] for time_step in range(120): if time_step > 0: tf.get_variable_scope().reuse_variables() (cell_output, state) = cell(critic_L1[:,time_step,:], state) outputs.append(cell_output) # weights = tf.Variable(tf.truncated_normal([28, 10],stddev=1.0 / math.sqrt(float(28))),name='weights') # biases = tf.Variable(tf.zeros([10]),name='biases') # logits = tf.matmul(cell_output, weights) + biases # self.critic_value = tf.nn.softmax(logits,name="action") output = tf.reshape(tf.concat(axis=1, values=outputs), [-1, 20]) self.critic_value = tf.contrib.layers.fully_connected( inputs=output, num_outputs= 1, #hidden activation_fn= tf.tanh, weights_initializer = tf.random_normal_initializer(), biases_initializer = tf.zeros_initializer() ) #loss,train critic_loss = tf.reduce_mean(tf.square(self.critic_target - self.critic_value) , name ="loss" ) #self.critic_train = tf.train.AdamOptimizer(0.01).minimize(critic_loss) #global_step tvar = tf.trainable_variables() grads, _ = tf.clip_by_global_norm(tf.gradients(critic_loss, tvar),5) optimizer = tf.train.GradientDescentOptimizer(0.01) self.critic_train = optimizer.apply_gradients(zip(grads, tvar))
def _tower_som(self): """ Build a single SOM tower on the TensorFlow graph """ # Randomly initialized weights for all neurons, stored together # as a matrix Variable of shape [num_neurons, input_dims] with tf.name_scope('Weights'): # Each tower will get its own copy of the weights variable. Since the towers are constructed sequentially, # the handle to the Tensors will be different for each tower even if we reference "self" self._weights = tf.get_variable( name='weights', shape=[self._m * self._n, self._dim], initializer=tf.random_uniform_initializer(maxval=1)) with tf.name_scope('summaries'): # All summary ops are added to a list and then the merge() function is called at the end of # this method mean = tf.reduce_mean(self._weights) self._summary_list.append(tf.summary.scalar('mean', mean)) with tf.name_scope('stdev'): stdev = tf.sqrt( tf.reduce_mean( tf.squared_difference(self._weights, mean))) self._summary_list.append(tf.summary.scalar('stdev', stdev)) self._summary_list.append( tf.summary.scalar('max', tf.reduce_max(self._weights))) self._summary_list.append( tf.summary.scalar('min', tf.reduce_min(self._weights))) self._summary_list.append( tf.summary.histogram('histogram', self._weights)) # Matrix of size [m*n, 2] for SOM grid locations of neurons. # Maps an index to an (x,y) coordinate of a neuron in the map for calculating the neighborhood distance self._location_vects = tf.constant(np.array( list(self._neuron_locations())), name='Location_Vectors') with tf.name_scope('Input'): self._input = tf.identity(self._input_tensor) with tf.name_scope('Epoch'): self._epoch = tf.placeholder("float", [], name="iter") # Start by computing the best matching units / winning units for each input vector in the batch. # Basically calculates the Euclidean distance between every # neuron's weight vector and the inputs, and returns the index of the neurons which give the least value # Since we are doing batch processing of the input, we need to calculate a BMU for each of the individual # inputs in the batch. Will have the shape [batch_size] # Oh also any time we call expand_dims it's almost always so we can make TF broadcast stuff properly with tf.name_scope('BMU_Indices'): # Distance between weights and the input vector # Note we are reducing along 2nd axis so we end up with a tensor of [batch_size, num_neurons] # corresponding to the distance between a particular input and each neuron in the map # Also note we are getting the squared distance because there's no point calling sqrt or tf.norm # if we're just doing a strict comparison squared_distance = tf.reduce_sum( tf.pow( tf.subtract(tf.expand_dims(self._weights, axis=0), tf.expand_dims(self._input, axis=1)), 2), 2) # Get the index of the minimum distance for each input item, shape will be [batch_size], bmu_indices = tf.argmin(squared_distance, axis=1) # This will extract the location of the BMU in the map for each input based on the BMU's indices with tf.name_scope('BMU_Locations'): # Using tf.gather we can use `bmu_indices` to index the location vectors directly bmu_locs = tf.reshape(tf.gather(self._location_vects, bmu_indices), [-1, 2]) with tf.name_scope('Learning_Rate'): # With each epoch, the initial sigma value decreases linearly radius = tf.subtract( self._initial_radius, tf.multiply( self._epoch, tf.divide( tf.cast(tf.subtract(self._initial_radius, 1), tf.float32), tf.cast(tf.subtract(self._max_epochs, 1), tf.float32)))) alpha = tf.subtract( self._initial_learning_rate, tf.multiply( self._epoch, tf.divide( tf.cast(tf.subtract(self._initial_learning_rate, 1), tf.float32), tf.cast(tf.subtract(self._max_epochs, 1), tf.float32)))) # Construct the op that will generate a matrix with learning rates for all neurons and all inputs, # based on iteration number and location to BMU # Start by getting the squared difference between each BMU location and every other unit in the map # bmu_locs is [batch_size, 2], i.e. the coordinates of the BMU for each input vector. # location vects shape should be [1, num_neurons, 2] # bmu_locs should be [batch_size, 1, 2] # Output needs to be [batch_size, num_neurons], i.e. a row vector of distances for each input item bmu_distance_squares = tf.reduce_sum( tf.pow( tf.subtract(tf.expand_dims(self._location_vects, axis=0), tf.expand_dims(bmu_locs, axis=1)), 2), 2) # Using the distances between each BMU, construct the Gaussian neighborhood function. # Basically, neurons which are close to the winner will move more than those further away. # The radius tensor decreases the width of the Gaussian over time, so early in training more # neurons will be affected by the winner and by the end of training only the winner will move. # This tensor will be of shape [batch_size, num_neurons] as well and will be the value multiplied to # each neuron based on its distance from the BMU for each input vector neighbourhood_func = tf.exp( tf.divide( tf.negative(tf.cast(bmu_distance_squares, "float32")), tf.multiply( tf.square(tf.multiply(radius, self._std_coeff)), 2))) # Finally multiply by the learning rate to decrease overall neuron movement over time learning_rate_op = tf.multiply(neighbourhood_func, alpha) # The batch formula for SOMs multiplies a neuron's neighborhood by all of the input vectors in the batch, # then divides that by just the sum of the neighborhood function for each of the inputs. # We are writing this in a way that performs that operation for each of the neurons in the map. with tf.name_scope('Update_Weights'): # The numerator needs to be shaped [num_neurons, dimensions] to represent the new weights # for each of the neurons. At this point, the learning rate tensor will be # shaped [batch_size, neurons]. # The end result is that, for each neuron in the network, we use the learning # rate between it and each of the input vectors, to calculate a new set of weights. numerator = tf.reduce_sum(tf.multiply( tf.expand_dims(learning_rate_op, axis=-1), tf.expand_dims(self._input, axis=1)), axis=0) # The denominator is just the sum of the neighborhood functions for each neuron, so we get the sum # along axis 1 giving us an output shape of [num_neurons]. We then expand the dims so we can # broadcast for the division op. Again we transpose the learning rate tensor so it's # [num_neurons, batch_size] representing the learning rate of each neuron for each input vector denominator = tf.expand_dims( tf.reduce_sum(learning_rate_op, axis=0) + float(1e-12), axis=-1) # We on;y really care about summaries from one of the tower SOMs, so assign the merge op to # the last tower we make. Otherwise there's way too many on Tensorboard. # self._merged = tf.summary.merge(self._summary_list) # With multi-gpu training we collect the results and do the weight assignment on the CPU return numerator, denominator
computed_x = s.run(x) print(computed_x) s.close() print('Another way to perform the same computation:') s = tf.Session() computed_x = x.eval(session = s) print(computed_x) s.close() print('Generate and plot a Gaussian...') # Keep in mind that in tf.pow(x, y) BOTH arguments MUST be of the same type! # Both integers, both float, ... mean = 0.0 #float! stddev = 1.0 #float! z = (tf.exp(tf.negative(tf.pow(x - mean, 2.0) / (2.0 * tf.pow(stddev, 2.0)))) * (1.0 / (stddev * tf.sqrt(2.0 * 3.1415)))) s = tf.Session() result = z.eval(session = s) s.close() import matplotlib.pyplot as plt plt.plot(result) print('Generate and plot a 2D Gaussian...') ksize = z.get_shape().as_list()[0] # Clever way to get a 2-D Gaussian: multiply a 1 x k vectot by its traspose! z_2d = tf.matmul(tf.reshape(z, [ksize, 1]), tf.reshape(z, [1, ksize])) s = tf.Session() result = z_2d.eval(session = s)
def __build_graph(self): self.__graph = tf.Graph() with self.__graph.as_default(), self.__graph.device(_device_for_node): count_max = tf.constant([self.cooccurrence_cap], dtype=tf.float32, name='max_cooccurrence_count') scaling_factor = tf.constant([self.scaling_factor], dtype=tf.float32, name="scaling_factor") self.__focal_input = tf.placeholder(tf.int32, shape=[self.batch_size], name="focal_words") self.__context_input = tf.placeholder(tf.int32, shape=[self.batch_size], name="context_words") self.__cooccurrence_count = tf.placeholder( tf.float32, shape=[self.batch_size], name="cooccurrence_count") bias_C = tf.Variable(0.5, name="bias_C") focal_embeddings = tf.Variable(tf.random_uniform( [self.vocab_size, self.embedding_size], 1.0, -1.0), name="focal_embeddings") context_embeddings = tf.Variable(tf.random_uniform( [self.vocab_size, self.embedding_size], 1.0, -1.0), name="context_embeddings") focal_biases = tf.Variable(tf.random_uniform([self.vocab_size], 1.0, -1.0), name='focal_biases') context_biases = tf.Variable(tf.random_uniform([self.vocab_size], 1.0, -1.0), name="context_biases") focal_embedding = tf.nn.embedding_lookup([focal_embeddings], self.__focal_input) context_embedding = tf.nn.embedding_lookup([context_embeddings], self.__context_input) focal_bias = tf.nn.embedding_lookup([focal_biases], self.__focal_input) context_bias = tf.nn.embedding_lookup([context_biases], self.__context_input) weighting_factor = tf.minimum( 1.0, tf.pow(tf.div(self.__cooccurrence_count, count_max), scaling_factor)) embedding_product = tf.reduce_sum( tf.multiply(focal_embedding, context_embedding), 1) log_cooccurrences = tf.log(tf.to_float(self.__cooccurrence_count)) distance_expr = tf.square( tf.add_n([ embedding_product, focal_bias, context_bias, tf.negative(log_cooccurrences) ])) single_losses = tf.multiply(weighting_factor, distance_expr) self.__total_loss = tf.reduce_sum(single_losses) tf.summary.scalar("GloVe_loss", self.__total_loss) self.__optimizer = tf.train.AdagradOptimizer( self.learning_rate).minimize(self.__total_loss) self.__summary = tf.summary.merge_all() self.__combined_embeddings = tf.add(focal_embeddings, context_embeddings, name="combined_embeddings")
def __init__(self, dtype, gs): # shortcuts action_dim = int(gs.policyOut.shape[-1]) state_dim = int(gs.input.shape[-1]) action = tf.identity(gs.policyOut, name="action") ## 3D value = tf.identity(gs.valueOut, name="value") ## 2D # standard deviation layer with tf.name_scope('stdevconcatOutput'): wo = tf.Variable(tf.zeros(shape=[1, action_dim], dtype=dtype), name='W', trainable=True) # Log standard deviation action_stdev = tf.identity(tf.exp(wo), name='stdev') gs.l_param_list.append(wo) gs.a_param_list.append(wo) super(RecurrentStochasticPolicyValue, self).__init__(dtype, gs) stdev_assign_placeholder = tf.placeholder(dtype, shape=[1, action_dim], name='Stdev_placeholder') Stdev_assign = tf.assign(wo, tf.log(stdev_assign_placeholder), name='assignStdev') Stdev_get = tf.exp(wo, name='getStdev') # Algorithm placeholders old_stdv = tf.placeholder(dtype, shape=[1, action_dim], name='stdv_o') old_action_sampled = tf.placeholder(dtype, shape=[None, None, action_dim], name='sampledAction') old_action_noise = tf.placeholder(dtype, shape=[None, None, action_dim], name='actionNoise') advantage_in = tf.placeholder(dtype, shape=[None, None], name='advantage') value_target = tf.placeholder(dtype, shape=[None, None], name='targetValue') value_pred = tf.placeholder(dtype, shape=[None, None], name='predictedValue') # Algorithm params v_coeff = tf.Variable(tf.constant(0.5, dtype=dtype), name='v_coeff') ent_coeff = tf.Variable(tf.constant(0.01, dtype=dtype), name='ent_coeff') clip_param = tf.Variable(tf.constant(0.2, dtype=dtype), name='clip_param') clip_param_decay_rate = tf.Variable(tf.constant(1, dtype=dtype), name='clip_param_decay_rate') # Assign ops. PPO_params_placeholder = tf.placeholder(dtype=dtype, shape=[1, 4], name='PPO_params_placeholder') param_assign_op_list = [] param_assign_op_list += [ tf.assign(v_coeff, tf.reshape( tf.slice(PPO_params_placeholder, [0, 0], [1, 1]), []), name='kl_coeff_assign') ] param_assign_op_list += [ tf.assign(ent_coeff, tf.reshape( tf.slice(PPO_params_placeholder, [0, 1], [1, 1]), []), name='ent_coeff_assign') ] param_assign_op_list += [ tf.assign(clip_param, tf.reshape( tf.slice(PPO_params_placeholder, [0, 2], [1, 1]), []), name='clip_param_assign') ] param_assign_op_list += [ tf.assign(clip_param_decay_rate, tf.reshape( tf.slice(PPO_params_placeholder, [0, 3], [1, 1]), []), name='clip_decayrate_assign') ] PPO_param_assign_ops = tf.group(*param_assign_op_list, name='PPO_param_assign_ops') with tf.name_scope('trainUsingGrad'): gradient_from_critic = tf.placeholder(dtype, shape=[1, None], name='Inputgradient') train_using_grad_optimizer = tf.train.AdamOptimizer( learning_rate=self.learningRate, epsilon=1e-5) # train_using_grad_optimizer = tf.train.RMSPropOptimizer(learning_rate=train_using_critic_learning_rate) split_parameter_gradients = tf.split(gradient_from_critic, [ reduce(mul, param.get_shape().as_list(), 1) for param in gs.a_param_list ], 1) manipulated_parameter_gradients = [] for grad, param in zip(split_parameter_gradients, gs.l_param_list): manipulated_parameter_gradients += [ tf.reshape(grad, tf.shape(param)) ] manipulated_parameter_gradients_and_parameters = zip( manipulated_parameter_gradients, gs.l_param_list) train_using_gradients = train_using_grad_optimizer.apply_gradients( manipulated_parameter_gradients_and_parameters, name='applyGradients', global_step=tf.train.get_global_step()) util = Utils.Utils(dtype) with tf.name_scope('Algo'): mask = tf.sequence_mask(gs.seq_length, maxlen=tf.shape(gs.input)[1], name='mask') logp_n = tf.boolean_mask( util.log_likelihood(action, action_stdev, old_action_sampled), mask) logp_old = tf.boolean_mask( util.log_likelihood(old_action_noise, old_stdv), mask) advantage = tf.boolean_mask(advantage_in, mask) ratio = tf.exp(logp_n - logp_old) ent = tf.reduce_sum( wo + .5 * tf.cast(tf.log(2.0 * np.pi * np.e), dtype=dtype), axis=-1) meanent = tf.reduce_mean(ent) with tf.name_scope('RPPO'): clip_range = tf.train.exponential_decay( clip_param, tf.train.get_global_step(), self.decayStep_lr, clip_param_decay_rate, name='clip_range') #POLICY LOSS surr1 = tf.multiply(ratio, advantage) surr2 = tf.multiply( tf.clip_by_value(ratio, 1.0 - clip_range, 1.0 + clip_range), advantage) PPO_loss = tf.reduce_mean(tf.maximum( surr1, surr2)) # PPO's pessimistic surrogate (L^CLIP) kl_ = tf.boolean_mask( util.kl_divergence((old_action_sampled - old_action_noise), old_stdv, action, action_stdev), mask) kl_mean = tf.reshape(tf.reduce_mean(kl_), shape=[], name='kl_mean') #VALUE LOSS vpredclipped = value_pred + tf.clip_by_value( value - value_pred, tf.negative(clip_param), clip_param) vf_err1 = tf.square(value - value_target) vf_err2 = tf.square(vpredclipped - value_target) vf_err1_masked = tf.boolean_mask(vf_err1, mask) vf_err2_masked = tf.boolean_mask(vf_err2, mask) vf_loss = .5 * tf.reduce_mean( tf.maximum(vf_err1_masked, vf_err2_masked)) Total_loss = tf.identity(PPO_loss - tf.multiply(ent_coeff, meanent) + v_coeff * vf_loss, name='loss') policy_gradient = tf.identity(tf.expand_dims(util.flatgrad( Total_loss, gs.l_param_list, self.max_grad_norm), axis=0), name='Pg') # flatgrad testTensor = tf.identity(surr1, name='test')
# Placeholders x_data_train = tf.placeholder(shape=[None, 784], dtype=tf.float32) x_data_test = tf.placeholder(shape=[None, 784], dtype=tf.float32) y_target_train = tf.placeholder(shape=[None, 10], dtype=tf.float32) y_target_test = tf.placeholder(shape=[None, 10], dtype=tf.float32) # Declare distance metric # L1 distance = tf.reduce_sum(tf.abs(tf.subtract(x_data_train, tf.expand_dims(x_data_test,1))), axis=2) # L2 #distance = tf.sqrt(tf.reduce_sum(tf.square(tf.subtract(x_data_train, tf.expand_dims(x_data_test,1))), reduction_indices=1)) # Predict: Get min distance index (Nearest neighbor) top_k_xvals, top_k_indices = tf.nn.top_k(tf.negative(distance), k=k) prediction_indices = tf.gather(y_target_train, top_k_indices) # Predict the mode category count_of_predictions = tf.reduce_sum(prediction_indices, axis=1) prediction = tf.argmax(count_of_predictions) # Calculate how many loops over training data num_loops = int(np.ceil(len(x_vals_test)/batch_size)) test_output = [] actual_vals = [] for i in range(num_loops): min_index = i*batch_size max_index = min((i+1)*batch_size,len(x_vals_train)) x_batch = x_vals_test[min_index:max_index] y_batch = y_vals_test[min_index:max_index]
#-*- codeing:utf-8 -*- ''' Created on 2019年1月12日 @author: adp ''' import tensorflow as tf sess = tf.InteractiveSession() x = tf.constant([1, 2]) neg_x = tf.negative(x) result = neg_x.eval() print(result) sess.close()
# Import MNIST data from tensorflow.examples.tutorials.mnist import input_data # Store the MNIST data in /tmp/data mnist = input_data.read_data_sets("mnist_data/", one_hot=True) training_digits, training_labels = mnist.train.next_batch(5000) test_digits, test_labels = mnist.test.next_batch(200) training_digits_pl = tf.placeholder("float", [None, 784]) test_digit_pl = tf.placeholder("float", [784]) # Nearest Neighbor calculation using L1 distance l1_distance = tf.abs(tf.add(training_digits_pl, tf.negative(test_digit_pl))) distance = tf.reduce_sum(l1_distance, axis=1) # Prediction: Get min distance index (Nearest neighbor) pred = tf.arg_min(distance, 0) accuracy = 0. # Initializing the variables init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) # loop over test data
def negative(self): backing = [tf.negative(xi) % mi for xi, mi in zip(self.backing, MODULI)] return DenseTensor(backing)
from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("/tmp/data",one_hot=True) # In this example, we limit mnist data X_train, Y_train = mnist.train.next_batch(5000) #5000 for training (nn candidates) X_test, Y_test = mnist.test.next_batch(200) #200 for testing # tf Graph Input x_train = tf.placeholder("float", [None, 784]) x_test = tf.placeholder("float", [784]) # Nearest Neighbor calculation using L1 Distance # Calculate L1 Distance distance = tf.reduce_sum(tf.abs(tf.add(x_train, tf.negative(x_test))), reduction_indices=1) # Prediction: Get min distance index (Nearest neighbor) pred = tf.arg_min(distance, 0) accuracy = 0. # Initialize the variables (i.e. assign their default value) init = tf.global_variables_initializer() # Start training with tf.Session() as sess: sess.run(init) for i in range(len(X_test)): # Get nearest neighbor
def __init__(self, m, n, dim, n_iterations=100, alpha=None, sigma=None): """ Initializes all necessary components of the TensorFlow Graph. m X n are the dimensions of the SOM. 'n_iterations' should should be an integer denoting the number of iterations undergone while training. 'dim' is the dimensionality of the training inputs. 'alpha' is a number denoting the initial time(iteration no)-based learning rate. Default value is 0.3 'sigma' is the the initial neighbourhood value, denoting the radius of influence of the BMU while training. By default, its taken to be half of max(m, n). """ #Assign required variables first self._m = m self._n = n if alpha is None: alpha = 0.3 else: alpha = float(alpha) if sigma is None: sigma = max(m, n) / 2.0 else: sigma = float(sigma) self._n_iterations = abs(int(n_iterations)) ##INITIALIZE GRAPH self._graph = tf.Graph() ##POPULATE GRAPH WITH NECESSARY COMPONENTS with self._graph.as_default(): ##VARIABLES AND CONSTANT OPS FOR DATA STORAGE #Randomly initialized weightage vectors for all neurons, #stored together as a matrix Variable of size [m*n, dim] self._weightage_vects = tf.Variable(tf.random_normal([m * n, dim])) #Matrix of size [m*n, 2] for SOM grid locations #of neurons self._location_vects = tf.constant( np.array(list(self._neuron_locations(m, n)))) ##PLACEHOLDERS FOR TRAINING INPUTS #We need to assign them as attributes to self, since they #will be fed in during training #The training vector self._vect_input = tf.placeholder("float", [dim]) #Iteration number self._iter_input = tf.placeholder("float") ##CONSTRUCT TRAINING OP PIECE BY PIECE #Only the final, 'root' training op needs to be assigned as #an attribute to self, since all the rest will be executed #automatically during training #To compute the Best Matching Unit given a vector #Basically calculates the Euclidean distance between every #neuron's weightage vector and the input, and returns the #index of the neuron which gives the least value bmu_index = tf.argmin( tf.sqrt( tf.reduce_sum( tf.pow( tf.subtract( self._weightage_vects, tf.stack( [self._vect_input for i in range(m * n)])), 2), 1)), 0) #This will extract the location of the BMU based on the BMU's #index slice_input = tf.pad(tf.reshape(bmu_index, [1]), np.array([[0, 1]])) bmu_loc = tf.reshape( tf.slice(self._location_vects, slice_input, tf.constant(np.array([1, 2]))), [2]) #To compute the alpha and sigma values based on iteration #number learning_rate_op = tf.subtract( 1.0, tf.div(self._iter_input, self._n_iterations)) _alpha_op = tf.multiply(alpha, learning_rate_op) _sigma_op = tf.multiply(sigma, learning_rate_op) #Construct the op that will generate a vector with learning #rates for all neurons, based on iteration number and location #wrt BMU. bmu_distance_squares = tf.reduce_sum( tf.pow( tf.subtract(self._location_vects, tf.stack([bmu_loc for i in range(m * n)])), 2), 1) neighbourhood_func = tf.exp( tf.negative( tf.div(tf.cast(bmu_distance_squares, "float32"), tf.pow(_sigma_op, 2)))) learning_rate_op = tf.multiply(_alpha_op, neighbourhood_func) #Finally, the op that will use learning_rate_op to update #the weightage vectors of all neurons based on a particular #input learning_rate_multiplier = tf.stack([ tf.tile( tf.slice(learning_rate_op, np.array([i]), np.array([1])), [dim]) for i in range(m * n) ]) weightage_delta = tf.multiply( learning_rate_multiplier, tf.subtract(tf.stack([self._vect_input for i in range(m * n)]), self._weightage_vects)) new_weightages_op = tf.add(self._weightage_vects, weightage_delta) self._training_op = tf.assign(self._weightage_vects, new_weightages_op) ##INITIALIZE SESSION self._sess = tf.Session() ##INITIALIZE VARIABLES init_op = tf.global_variables_initializer() self._sess.run(init_op)