def _compile(self): """ compile the tensorflow function "self._objective" """ self.make_tf_array(self._free_vars) with self.tf_mode(): f = self.build_likelihood() + self.build_prior() g, = tf.gradients(f, self._free_vars) minusF = tf.neg(f, name='objective') minusG = tf.neg(g, name='grad_objective') #initialize variables. I confess I don;t understand what this does - JH init = tf.initialize_all_variables() self._session.run(init) #build tensorflow functions for computing the likelihood and predictions print("compiling tensorflow function...") sys.stdout.flush() def obj(x): return self._session.run([minusF, minusG], feed_dict={self._free_vars: x}) self._objective = obj print("done") sys.stdout.flush() self._needs_recompile = False
def _compile(self): """ compile the tensorflow function "self._objective" """ self.make_tf_array(self._free_vars) with self.tf_mode(): f = self.build_likelihood() + self.build_prior() g, = tf.gradients(f, self._free_vars) minusF = tf.neg( f, name = 'objective' ) minusG = tf.neg( g, name = 'grad_objective' ) #initialize variables. I confess I don;t understand what this does - JH init = tf.initialize_all_variables() self._session.run(init) #build tensorflow functions for computing the likelihood and predictions print("compiling tensorflow function...") sys.stdout.flush() def obj(x): return self._session.run([minusF,minusG], feed_dict={self._free_vars: x}) self._objective = obj print("done") sys.stdout.flush() self._needs_recompile = False
def build_energy_op(self): with self.graph.as_default(), tf.device(self.device): # [1, nbatch] e_x_0 = tf.neg((self.state_pl[0, :] ** 2) / (self.scale ** 2), name='E_x_0') # [ndims - 1, nbatch] e_x_k = tf.neg((self.state_pl[1:, :] ** 2) / tf.exp(self.state_pl[0, :]), name='E_x_k') # [nbatch] self.energy_op = tf.reduce_sum(tf.add(e_x_0, e_x_k), 0, name='energy_op')
def _compile(self, optimizer=None): """ compile the tensorflow function "self._objective" """ # Make float32 hack float32_hack = False if optimizer is not None: if tf.float64 not in optimizer._valid_dtypes( ) and tf.float32 in optimizer._valid_dtypes(): print("Using float32 hack for Tensorflow optimizers...") float32_hack = True self._free_vars = tf.Variable(self.get_free_state()) if float32_hack: self._free_vars32 = tf.Variable(self.get_free_state().astype( np.float32)) self._free_vars = tf.cast(self._free_vars32, tf.float64) self.make_tf_array(self._free_vars) with self.tf_mode(): f = self.build_likelihood() + self.build_prior() g, = tf.gradients(f, self._free_vars) self._minusF = tf.neg(f, name='objective') self._minusG = tf.neg(g, name='grad_objective') # The optimiser needs to be part of the computational graph, and needs # to be initialised before tf.initialise_all_variables() is called. if optimizer is None: opt_step = None else: if float32_hack: opt_step = optimizer.minimize(tf.cast(self._minusF, tf.float32), var_list=[self._free_vars32]) else: opt_step = optimizer.minimize(self._minusF, var_list=[self._free_vars]) init = tf.initialize_all_variables() self._session.run(init) #build tensorflow functions for computing the likelihood and predictions print("compiling tensorflow function...") sys.stdout.flush() def obj(x): return self._session.run([self._minusF, self._minusG], feed_dict={self._free_vars: x}) self._objective = obj print("done") sys.stdout.flush() self._needs_recompile = False return opt_step
def energy_function(self, input, w_test, v_test, h_test, sigma_test): wh = tf.matmul(tf.div(input, sigma_test**2), w_test) + h_test step1 = tf.reduce_sum(tf.div(tf.square(input - v_test), 2*tf.square(sigma_test)), reduction_indices=[1]) wh_plus = tf.maximum(wh, 0) step2 = step1 - tf.reduce_sum(tf.log(tf.exp(tf.neg(wh_plus))+tf.exp(wh - wh_plus)) + wh_plus, reduction_indices=[1]) step3 = tf.transpose(step2) e = tf.reduce_mean(step3) e_sum = tf.reduce_sum(tf.neg(step3)) tf.scalar_summary('energy_val', e_sum) return step3, e, e_sum
def twins_relu(x): """ return [relu(x), -relu(-x)] """ from tflearn import utils #from tflearn.layers.conv import max_pool_2d input_shape = get_incoming_shape(x) res = tf.concat(len(input_shape)-1, [tf.nn.relu(x), tf.neg(tf.nn.relu(tf.neg(x)))]) #print(tf.shape(res)) return res
def BiBU(x): """ A trick from [Sergey Ioffe](http://stackoverflow.com/a/36480182) Binary Branch Units, binarizing twins_relu works not good, shold continue experimenting new binary methods for twins_relu. """ input_shape = get_incoming_shape(x) binary_x = tf.sign(x) forward = tf.concat(len(input_shape)-1, [tf.nn.relu(binary_x), tf.neg(tf.nn.relu(tf.neg(binary_x)))]) backward = tf.concat(len(input_shape)-1, [tf.nn.relu(x), tf.neg(tf.nn.relu(tf.neg(x)))]) return backward + tf.stop_gradient(forward - backward)
def testArithmeticRenames(self): with self.test_session() as s: stuff = tf.split(1, 2, [[1, 2, 3, 4], [4, 5, 6, 7]]) vals = s.run(stuff) self.assertAllEqual(vals, [[[1, 2], [4, 5]], [[3, 4], [6, 7]]]) self.assertAllEqual(tf.neg(tf.mul(tf.add(1, 2), tf.sub(5, 3))).eval(), -6) self.assertAllEqual(s.run(tf.listdiff([1, 2, 3], [3, 3, 4]))[0], [1, 2]) self.assertAllEqual(tf.list_diff([1, 2, 3], [3, 3, 4])[0].eval(), [1, 2]) a = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] foo = np.where(np.less(a, 2), np.negative(a), a) self.assertAllEqual(tf.select(tf.less(a, 2), tf.neg(a), a).eval(), foo) self.assertAllEqual(tf.complex_abs(tf.constant(3 + 4.0j)).eval(), 5)
def build_energy_op(self): with self.graph.as_default(), tf.device(self.energy_device): # [1, nbatch] e_x_0 = tf.neg((self.state_pl[0, :]**2) / (self.scale**2), name='E_x_0') # [ndims - 1, nbatch] e_x_k = tf.neg( (self.state_pl[1:, :]**2) / tf.exp(self.state_pl[0, :]), name='E_x_k') # [nbatch] self.energy_op = tf.reduce_sum(tf.add(e_x_0, e_x_k), 0, name='energy_op')
def _compile(self, optimizer=None): """ compile the tensorflow function "self._objective" """ self._graph = tf.Graph() self._session = tf.Session(graph=self._graph) with self._graph.as_default(): self._free_vars = tf.Variable(self.get_free_state()) self.make_tf_array(self._free_vars) with self.tf_mode(): f = self.build_likelihood() + self.build_prior() g, = tf.gradients(f, self._free_vars) self._minusF = tf.neg(f, name='objective') self._minusG = tf.neg(g, name='grad_objective') # The optimiser needs to be part of the computational graph, and needs # to be initialised before tf.initialise_all_variables() is called. if optimizer is None: opt_step = None else: opt_step = optimizer.minimize(self._minusF, var_list=[self._free_vars]) init = tf.initialize_all_variables() self._session.run(init) # build tensorflow functions for computing the likelihood if settings.verbosity.tf_compile_verb: print("compiling tensorflow function...") sys.stdout.flush() self._feed_dict_keys = self.get_feed_dict_keys() def obj(x): feed_dict = {self._free_vars: x} self.update_feed_dict(self._feed_dict_keys, feed_dict) f, g = self._session.run([self._minusF, self._minusG], feed_dict=feed_dict) return f.astype(np.float64), g.astype(np.float64) self._objective = obj if settings.verbosity.tf_compile_verb: print("done") sys.stdout.flush() self._needs_recompile = False return opt_step
def testInitializerFunction(self): value = [[-42], [133.7]] shape = [2, 1] with self.test_session(): initializer = lambda: tf.constant(value) with self.assertRaises(ValueError): # Checks that dtype must be specified. tf.Variable(initializer) v1 = tf.Variable(initializer, dtype=tf.float32) self.assertEqual(shape, v1.get_shape()) self.assertAllClose(value, v1.initial_value.eval()) with self.assertRaises(tf.errors.FailedPreconditionError): v1.eval() v2 = tf.Variable(tf.neg(v1.initialized_value()), dtype=tf.float32) self.assertEqual(v1.get_shape(), v2.get_shape()) self.assertAllClose(np.negative(value), v2.initial_value.eval()) # Once v2.initial_value.eval() has been called, v1 has effectively been # initialized. self.assertAllClose(value, v1.eval()) with self.assertRaises(tf.errors.FailedPreconditionError): v2.eval() tf.initialize_all_variables().run() self.assertAllClose(np.negative(value), v2.eval())
def test_cwise_unary_grad(self): """ Ensure that all component-wise unary functions in the math op library yield an identical gradient to tensorflow """ with tf.Session() as s: arg_np = np.random.random(100) grad_above = tf.constant(np.random.random(100)) arg = tf.constant(arg_np) def test_grad(fcn, tf_fcn): ovl_out = as_tensorflow(fcn(arg)) tf_out = tf_fcn(arg) ovl_grad = tf.gradients(ovl_out, arg, grad_above)[0] tf_grad = tf.gradients(tf_out, arg, grad_above)[0] ovl_out, tf_out, ovl_grad, tf_grad = s.run( [ovl_out, tf_out, ovl_grad, tf_grad]) assert np.allclose(ovl_out, tf_out) assert np.allclose(ovl_grad, tf_grad) test_grad(lambda x: neg(x), lambda x: tf.neg(x)) test_grad(lambda x: tanh(x), lambda x: tf.tanh(x)) test_grad(lambda x: sigmoid(x), lambda x: tf.sigmoid(x))
def get_layers(self): input_vars, predict_op = self.get_predict_op() action = tf.placeholder(tf.int32, shape=(None,), name='action') reward = tf.placeholder(tf.float32, shape=(None,), name='reward') credit = tf.placeholder(tf.float32, shape=(None,), name='credit') label_vars = [action, reward, credit] if self.options.pg_normalize: reward_mean, reward_variance = tfutils.moments(reward) normalized = tf.nn.batch_normalization(reward, reward_mean, reward_variance, scale=1.0, offset=0.0, variance_epsilon=1e-4) else: normalized = reward opt = tf.train.RMSPropOptimizer(learning_rate=self.options.learning_rate) logp = tf.neg(tf.nn.sparse_softmax_cross_entropy_with_logits(predict_op, action), name='action_log_prob') signal = tf.mul(logp, normalized * credit, name='signal') signal_down = tf.reduce_sum(tf.slice(tf.reshape(signal, [-1, 10]), [0, 4], [-1, 1]), [0], name='signal_down') if self.options.verbosity >= 5: print_node = tf.Print(signal, [signal_down], message='signal_down: ', summarize=10) with tf.control_dependencies([print_node]): signal = tf.identity(signal) loss = tf.reduce_mean(-signal, name='loss') var_list = tf.trainable_variables() print('Trainable variables:') for var in var_list: print(var.name) train_op = minimize_with_grad_clip(opt, self.options.pg_grad_clip, loss, var_list=var_list) return input_vars, label_vars, train_op, predict_op
def hard_resp(pw_matrix, k): ''' hard_resp Calculates the hard KNN responsibility vector ''' #We need to index the closest values ref_matrix = tf.neg(tf.transpose(pw_matrix)) values, indices = tf.nn.top_k(ref_matrix, k, sorted=False) #Generate the indices from top_k (adapted liberally from Stack Overflow) range_repeated = tf.tile( tf.expand_dims(tf.range(0, tf.shape(indices)[0]), 1), [1, k]) # Tiime to update full_indices = tf.reshape( tf.concat( 2, [tf.expand_dims(range_repeated, 2), tf.expand_dims(indices, 2)]), [-1, 2]) update = tf.mul( tf.truediv(tf.constant(1.0, dtype=tf.float64), tf.cast(k, tf.float64)), tf.ones(tf.shape(values), dtype=tf.float64)) return tf.sparse_to_dense(full_indices, tf.shape(ref_matrix), tf.reshape(update, [-1]), default_value=0., validate_indices=False)
def step(model, current, dt): with tf.name_scope('neurons'): v_rest = tf.constant([model.v_rest] * model.size, name='v_rest') r_m = tf.constant([model.r_m] * model.size, name='r_m') c_m = tf.constant([model.c_m] * model.size, name='c_m') tau_m = tf.mul(r_m, c_m, name='tau_m') tau_ref = tf.constant([model.tau_ref] * model.size, name='tau_ref') v_spike = tf.constant([model.v_spike] * model.size, name='v_spike') v_m = tf.Variable(tf.zeros(model.size), trainable=True, name='v_m') tf.scalar_summary(['v_m'] * model.size, v_m) t_rest = tf.Variable(tf.zeros(model.size), trainable=True, name='t_rest') v_m_ = (tf.neg(v_m) + current * r_m) / tau_m * dt # neurons = tf.dynamic_partition(t_rest, tf.greater(t_rest, 0.0), 2) # neurons[0] def resting_op(): return tf.tuple((t_rest.assign_sub(dt), v_m.assign(v_rest))) def spiking_op(): return tf.tuple( (t_rest.assign_add(tau_ref), v_m.assign_add(v_spike))) def responding_op(): return tf.tuple((t_rest, v_m.assign_add(v_m_))) _step = tf.case( ((tf.reshape(tf.greater(t_rest, 0), []), resting_op), (tf.reshape(tf.greater(v_m, v_spike), []), spiking_op)), responding_op) return _step
def build_graph_tf(): a = tf.constant(2) b = tf.constant(3) c = tf.add(a, b) c2 = tf.mul(a, b) d = tf.neg(c) return a, b, c, c2, d
def test_cwise_unary_grad(self): """ Ensure that all component-wise unary functions in the math op library yield an identical gradient to tensorflow """ test_config = tf.ConfigProto(allow_soft_placement=False) test_config.graph_options.optimizer_options.opt_level = -1 with tf.Session(config=test_config) as s: arg_np = np.random.random(100) grad_above = tf.constant(np.random.random(100)) arg = tf.constant(arg_np) def test_grad(fcn, tf_fcn): ovl_out = as_tensorflow(fcn(arg)) tf_out = tf_fcn(arg) ovl_grad = tf.gradients(ovl_out, arg, grad_above)[0] tf_grad = tf.gradients(tf_out, arg, grad_above)[0] ovl_out, tf_out, ovl_grad, tf_grad = s.run([ovl_out, tf_out, ovl_grad, tf_grad]) assert np.allclose(ovl_out, tf_out) assert np.allclose(ovl_grad, tf_grad) test_grad(lambda x: neg(x), lambda x: tf.neg(x)) test_grad(lambda x: tanh(x), lambda x: tf.tanh(x)) test_grad(lambda x: sin(x), lambda x: tf.sin(x)) test_grad(lambda x: cos(x), lambda x: tf.cos(x)) test_grad(lambda x: tan(x), lambda x: tf.tan(x)) test_grad(lambda x: sigmoid(x), lambda x: tf.sigmoid(x))
def gauss(mean, stddev, ksize): """Uses 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.neg(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 tf_neg_masked_scaled_root_mean_square_errors(y_est, y_masked, y_std, do_neg_rmdse=False): with tf.name_scope("MSE"): y = y_masked[:, :, 0] y_mask = y_masked[:, :, 1] y_est.get_shape().assert_is_compatible_with(y.get_shape()) y_diff_masked = tf.multiply( tf.subtract(y_est, y), y_mask, name="y_diff_masked") y_mask_count = tf.reduce_sum( y_mask, name = "y_mask_count") mse = tf.div( tf.reduce_sum(tf.square(y_diff_masked)), y_mask_count, name="MSE") rmse = tf.sqrt( tf.div( tf.reduce_sum( tf.square( tf.multiply( y_diff_masked, y_std))), y_mask_count), name="RMSE") if do_neg_rmdse: rmse = tf.neg(rmse, name="-RMSE") return mse, rmse
def CreateRegressionNetwork(input_d, output_d, num_hidden=20, learning_rate=0.01, correlation_loss=False): g = tf.Graph() with g.as_default(): x1 = tf.placeholder(tf.float32, shape=(None, input_d), name='x1') # Will be batch_size x input_d W1 = tf.Variable(tf.random_uniform([input_d,num_hidden], -1.0, 1.0), name='W1') # input_d x num_hidden b1 = tf.Variable(tf.zeros([num_hidden]), name='bias1') y1 = tf.nn.relu(tf.nn.bias_add(tf.matmul(x1,W1), b1), name='y1') # batch_size x num_hidden W2 = tf.Variable(tf.random_uniform([num_hidden,output_d], -1.0, 1.0), name='W2') b2 = tf.Variable(tf.zeros([output_d]), name='b2') y2 = tf.nn.bias_add(tf.matmul(y1,W2), b2, name='y2') # Will be batch_size x output_d ytrue = tf.placeholder(tf.float32, shape=(None, output_d), name='ytrue') # num_batch x output_d if correlation_loss: # Compute the correlation r = PearsonCorrelationTF(ytrue, y2) tf.scalar_summary('correlation', r) loss = tf.neg(r, name='loss_pearson') else: # Minimize the mean squared errors. loss = tf.reduce_mean(tf.square(y2 - ytrue), name='loss_euclidean') tf.scalar_summary('loss', loss) # https://www.quora.com/Which-optimizer-in-TensorFlow-is-best-suited-for-learning-regression # optimizer = tf.train.AdadeltaOptimizer(learning_rate) # optimizer = tf.train.GradientDescentOptimizer(learning_rate) optimizer = tf.train.AdamOptimizer(learning_rate) train = optimizer.minimize(loss) # Before starting, initialize the variables. We will 'run' this first. init = tf.initialize_all_variables() saver = tf.train.Saver() merged_summaries = tf.merge_all_summaries() return g, train, loss, init, x1, y2, ytrue, merged_summaries, saver
def cross_entropy_loss(y, yhat): """ Compute the cross entropy loss in tensorflow. 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 score = tf.neg(tf.mul(tf.to_float(y), tf.log(yhat))) out = tf.reduce_sum(score) ### END YOUR CODE return out
def get_mapping(self, max_iterations=None): """ find the best mapping according to the given emission and entries matrix Return: a mapping between PDTB relations and RST relations. Mapping[i, j] = P(RST_j|PDTB_i) """ if max_iterations is None: max_iterations = 50000 sdc = Lexconn.__one_hot_encoding(self.__entries[:, 0], self.__dc_cnt) src = Lexconn.__one_hot_encoding(self.__entries[:, 1], self.__rst_cnt) sdc_e = np.dot(sdc, self.__emission) #select emission row for each entry in LEXCONN init_value = np.random.rand(self.__pdtb_cnt, self.__rst_cnt).astype(np.float32) m_logits = tf.Variable(init_value) #parameters of mapping probabilities m = tf.nn.softmax(m_logits) #Mapping probabilities src_m = tf.matmul(m, src.T) #select mapping rows for each entry in LEXCONN score = tf.matmul(sdc_e, src_m) #calculate the probabilities of all possible combination of connectives and relations log_score = tf.log(score) sum_log_score = tf.trace(log_score) #we only need those that have the same index in LEXCONN optimizer = tf.train.AdamOptimizer(0.01).minimize(tf.neg(sum_log_score)) init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) #print(sess.run(m)) print(sess.run(sum_log_score)) # Fit the line. np.set_printoptions(precision=4) np.set_printoptions(suppress=True) for step in range(max_iterations): sess.run(optimizer) if step % 1000 == 0: print(step, sess.run(sum_log_score)) return sess.run(m)
def model(train, label, test): dist = tf.reduce_sum(tf.abs(tf.add(train, tf.neg(test))), reduction_indices=1) min_index = tf.argmin(dist, 0) min_index = tf.cast(min_index, tf.int32) pred = label[min_index] return pred
def build_graph_tf(): a=tf.constant(2) b=tf.constant(3) c=tf.add(a,b) c2=tf.mul(a,b) d=tf.neg(c) return a,b,c,c2,d
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 log_y = tf.log(yhat) temp = log_y * tf.to_float(y) out = tf.neg(tf.reduce_sum(temp)) ### END YOUR CODE return out
def initializeKnn(self): if self.qualitative_outputs: n_input = self.input_end_column - self.input_start_column + 1 self.tf_in = tf.placeholder("float", [None, n_input]) self.tf_testing = tf.placeholder("float", [n_input]) # Calculate L1 Distance self.distance = tf.reduce_sum(tf.abs(tf.add(self.tf_in, tf.neg(self.tf_testing))), reduction_indices=1) # Predict: Get min distance index (Nearest neighbor) self.prediction = tf.arg_min(self.distance, 0) init = tf.initialize_all_variables() self.sess = tf.Session() self.sess.run(init) accuracy = 0 #output part for i in range(len(self.testing_data)): # Get nearest neighbor nn_index = self.sess.run(self.prediction, feed_dict={self.tf_in: self.training_data, self.tf_testing: self.testing_data[i,:]}) # Calculate accuracy if np.argmax(self.training_outputs[nn_index]) == np.argmax(self.testing_outputs[i]): accuracy += 1./len(self.testing_data) self.accuracy = accuracy self.epochs_for_accuracy = "N/A" self.best_accuracy = "N/A" self.epochs_for_best_accuracy = "N/A" self.trained = True else: raise ValueError("NOT IMPLEMENTED")
def testSideEffect(self): a = tf.constant(1) b = tf.constant(1) c = tf.add(a, b) with tf.control_dependencies([c]): d = tf.constant(42) n = tf.neg(c) shared = [] def sub(t): shared.append(t) return t c = subscribe.subscribe(c, lambda t: tf.py_func(sub, [t], [t.dtype])) with self.test_session() as sess: c_out = sess.run([c]) n_out = sess.run([n]) d_out = sess.run([d]) self.assertEquals(n_out, [-2]) self.assertEquals(c_out, [2]) self.assertEquals(d_out, [42]) self.assertEquals(shared, [2, 2, 2])
def test_cwise_unary_grad(self): """ Ensure that all component-wise unary functions in the math op library yield an identical gradient to tensorflow """ test_config = tf.ConfigProto(allow_soft_placement=False) test_config.graph_options.optimizer_options.opt_level = -1 with tf.Session(config=test_config) as s: arg_np = np.random.random(100) grad_above = tf.constant(np.random.random(100)) arg = tf.constant(arg_np) def test_grad(fcn, tf_fcn): ovl_out = as_tensorflow(fcn(arg)) tf_out = tf_fcn(arg) ovl_grad = tf.gradients(ovl_out, arg, grad_above)[0] tf_grad = tf.gradients(tf_out, arg, grad_above)[0] ovl_out, tf_out, ovl_grad, tf_grad = s.run( [ovl_out, tf_out, ovl_grad, tf_grad]) assert np.allclose(ovl_out, tf_out) assert np.allclose(ovl_grad, tf_grad) test_grad(lambda x: neg(x), lambda x: tf.neg(x)) test_grad(lambda x: tanh(x), lambda x: tf.tanh(x)) test_grad(lambda x: sin(x), lambda x: tf.sin(x)) test_grad(lambda x: cos(x), lambda x: tf.cos(x)) test_grad(lambda x: tan(x), lambda x: tf.tan(x)) test_grad(lambda x: sigmoid(x), lambda x: tf.sigmoid(x))
def w(input_data, cu, kappas_t_1, config): batch_size = config.batch_size mixture_size = config.mixture_size vocab_length = config.vocab_length # split along dim of mixture size * 3 hat_alphas_t, hat_betas_t, hat_kappas_t = tf.split(1, 3, input_data) alphas_t = tf.exp(hat_alphas_t) betas_t = tf.exp(hat_betas_t) kappas_t = tf.add(kappas_t_1, tf.exp(hat_kappas_t)) speech_length = tf.shape(cu)[1] u = tf.linspace(1.0, tf.cast(speech_length,tf.float32) , speech_length) u = tf.expand_dims(u, 0) u = tf.expand_dims(u, 0) u = tf.tile(u, [batch_size, mixture_size, 1]) alphas_t_expanded = tf.tile(tf.expand_dims(alphas_t, -1), [1, 1, speech_length]) betas_t_expanded = tf.tile(tf.expand_dims(betas_t, -1), [1, 1, speech_length]) kappas_t_expanded = tf.tile(tf.expand_dims(kappas_t, -1), [1, 1, speech_length]) calc = tf.square(tf.sub(kappas_t_expanded, u)) calc = tf.mul(calc, tf.neg(betas_t_expanded)) calc = tf.exp(calc) calc = tf.mul(calc, alphas_t_expanded) phi_t = tf.expand_dims(tf.reduce_sum(calc, 1), 1) output = tf.squeeze(tf.batch_matmul(phi_t, cu), [1]) return output, kappas_t, phi_t
def compile(self, optimizer=tf.train.AdamOptimizer(), collection=graph_key.VARIABLES, global_step=None): """ Create self.method_op and self.optimize_op. args: - optimzer: instance of tf.train.optimizer. - collection: variable collection that will be optimized. - global_step: If want to decrease learning rate, global_step can be passed. """ print('compiling...') var_list = self.model.get_tf_variables(collection) with self.model.tf_mode(): self.method_op = self.likelihood_method(self.model) self.optimize_op = optimizer.minimize(tf.neg(self.method_op), var_list=var_list, global_step=global_step) # manual initialization. self.model.initialize() # initialize un-initialized variable self.model._session.run( tf.initialize_variables([ v for v in tf.all_variables() if not self.model._session.run(tf.is_variable_initialized(v)) ])) # make validation self.model.validate()
def testArithmeticRenames(self): with self.cached_session() as s: stuff = tf.split(1, 2, [[1, 2, 3, 4], [4, 5, 6, 7]]) vals = s.run(stuff) self.assertAllEqual(vals, [[[1, 2], [4, 5]], [[3, 4], [6, 7]]]) self.assertAllEqual( tf.neg(tf.mul(tf.add(1, 2), tf.sub(5, 3))).eval(), -6) self.assertAllEqual( s.run(tf.listdiff([1, 2, 3], [3, 3, 4]))[0], [1, 2]) self.assertAllEqual( tf.list_diff([1, 2, 3], [3, 3, 4])[0].eval(), [1, 2]) a = [[1., 2., 3.], [4., 5., 6.]] foo = np.where(np.less(a, 2), np.negative(a), a) self.assertAllEqual( tf.select(tf.less(a, 2), tf.neg(a), a).eval(), foo) self.assertAllEqual(tf.complex_abs(tf.constant(3 + 4.j)).eval(), 5)
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") 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)) # weighting_factor = 1 embedding_product = tf.reduce_sum(tf.mul(focal_embedding, context_embedding), 1) log_cooccurrences = tf.log(tf.to_float(self.__cooccurrence_count)) # log_cooccurrences = self.__cooccurrence_count distance_expr = tf.square(tf.add_n([ embedding_product, focal_bias, context_bias, tf.neg(log_cooccurrences)])) single_losses = tf.mul(weighting_factor, distance_expr) self.__total_loss = tf.reduce_sum(single_losses) tf.scalar_summary("GloVe loss", self.__total_loss) self.__optimizer = tf.train.AdagradOptimizer(self.learning_rate).minimize( self.__total_loss) self.__summary = tf.merge_all_summaries() self.__combined_embeddings = tf.add(focal_embeddings, context_embeddings, name="combined_embeddings")
def sqk_gpr(input1, input2, l): ''' sqk_gpr Calculates the squared exponential kernel ''' #We need to index the closest values return tf.exp(l * tf.neg(get_distance_matrix(input1, input2)))
def _compile(self, optimizer=None): """ compile the tensorflow function "self._objective" """ # Make float32 hack float32_hack = False if optimizer is not None: if tf.float64 not in optimizer._valid_dtypes() and tf.float32 in optimizer._valid_dtypes(): print("Using float32 hack for Tensorflow optimizers...") float32_hack = True self._free_vars = tf.Variable(self.get_free_state()) if float32_hack: self._free_vars32 = tf.Variable(self.get_free_state().astype(np.float32)) self._free_vars = tf.cast(self._free_vars32, tf.float64) self.make_tf_array(self._free_vars) with self.tf_mode(): f = self.build_likelihood() + self.build_prior() g, = tf.gradients(f, self._free_vars) self._minusF = tf.neg( f, name = 'objective' ) self._minusG = tf.neg( g, name = 'grad_objective' ) # The optimiser needs to be part of the computational graph, and needs # to be initialised before tf.initialise_all_variables() is called. if optimizer is None: opt_step = None else: if float32_hack: opt_step = optimizer.minimize(tf.cast(self._minusF, tf.float32), var_list=[self._free_vars32]) else: opt_step = optimizer.minimize(self._minusF, var_list=[self._free_vars]) init = tf.initialize_all_variables() self._session.run(init) #build tensorflow functions for computing the likelihood and predictions print("compiling tensorflow function...") sys.stdout.flush() def obj(x): return self._session.run([self._minusF, self._minusG], feed_dict={self._free_vars: x}) self._objective = obj print("done") sys.stdout.flush() self._needs_recompile = False return opt_step
def test_neg(self): # computation a = tf.placeholder(tf.float32, shape=(20, 30)) neg_a = tf.neg(a) # test feed_dict = {a: np.random.rand(*tf_to_shape_tuple(a))} self.run(neg_a, tf_feed_dict=feed_dict)
def calculate_loss(self, predictions, labels, **unused_params): with tf.name_scope("loss_xent"): epsilon = 10e-8 float_labels = tf.cast(labels, tf.float32) cross_entropy_loss = float_labels * tf.log( predictions + epsilon) + ( 1 - float_labels) * tf.log(1 - predictions + epsilon) cross_entropy_loss = tf.neg(cross_entropy_loss) return tf.reduce_mean(tf.reduce_sum(cross_entropy_loss, 1))
def _compute_constant(self): """ Computes constant term in lml. """ self.constant = tf.reshape(tf.neg( (tf.cast(self.n_tf, dtype=tf.float32) / 2.0) * tf.log(2 * math.pi)), shape=[1, 1], name='constant')
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(1, [x, u]) 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 xrange(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.neg(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.mul(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 psnr_loss(inference_tensor, reference_tensor, name="loss_layer"): with tf.name_scope(name) as scope: l2 = tf.square(inference_tensor - reference_tensor, name='l2_difference') MSE = tf.reduce_mean(l2, name='MSE') # MSE = tf.nn.l2_loss(inference_tensor - reference_tensor, name='MSE') loss = tf.neg(tf.log(tf.inv(tf.sqrt(MSE + FLAGS.eps))), name='psnr') tf.add_to_collection('losses', loss) return loss
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") 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.mul(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.neg(log_cooccurrences)])) single_losses = tf.mul(weighting_factor, distance_expr) self.__total_loss = tf.reduce_sum(single_losses) tf.scalar_summary("GloVe loss", self.__total_loss) self.__optimizer = tf.train.AdagradOptimizer(self.learning_rate).minimize( self.__total_loss) self.__summary = tf.merge_all_summaries() self.__combined_embeddings = tf.add(focal_embeddings, context_embeddings, name="combined_embeddings")
def loss_function(self): pos_diff = self.anchor - self.positive neg_diff = self.anchor - self.negative pos_dist = tf.reduce_sum(tf.mul(pos_diff, pos_diff), 1) neg_dist = tf.reduce_sum(tf.mul(neg_diff, neg_diff), 1) triplet = tf.add(self.ALPHA, tf.add(pos_dist, tf.neg(neg_dist))) return tf.reduce_sum(tf.nn.relu(triplet))
def binary_cross_entropy(prediction, target): """ let o=prediction, t=target -(t*log(o) + (1-t)*log(1-o)) Adds a small (1e-12) value to the logarithms to avoid log(0) """ op1 = tf.mul(target, tf.log(prediction + 1e-12)) op2 = tf.mul(tf.sub(1., target), tf.log(tf.sub(1., prediction) + 1e-12)) return tf.neg(tf.add(op1, op2))
def gaussian_kernel(tensor_a, a_inputs, tensor_b, b_inputs, gamma): """Returns the Gaussian kernel matrix of two matrices of vectors element-wise.""" cross = cross_matrices(tensor_a, a_inputs, tensor_b, b_inputs) kernel = tf.exp(tf.mul(tf.reduce_sum(tf.square( tf.sub(cross[0], cross[1])), reduction_indices=2), tf.neg(tf.constant(gamma, dtype=tf.float32)))) return kernel
def activation(type, synapse): """Chooses the activation function to use.""" if type == "sigmoid": return tf.sigmoid(synapse) elif type == "linear": return synapse elif type == "tanh": return tf.tanh(synapse) elif type == "radial": return tf.sqrt(tf.exp(tf.neg(tf.square(synapse))))
def gabor(n_values=32, sigma=1.0, mean=0.0): x = tf.linspace(-3.0, 3.0, n_values) z = (tf.exp(tf.neg(tf.pow(x - mean, 2.0) / (2.0 * tf.pow(sigma, 2.0)))) * (1.0 / (sigma * tf.sqrt(2.0 * 3.1415)))) 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.mul(tf.matmul(x, y), gauss_kernel) return gabor_kernel
def test_1(self): """ ht->tf """ a=tf.constant(2) b=tf.constant(3) c=tdb.python_op(myadd,inputs=[a,b],outputs=[tf.placeholder(tf.int32)]) # a+b d=tf.neg(c) status,result=tdb.debug([d], feed_dict=None, breakpoints=None, break_immediately=False) self.assertEqual(status, tdb.FINISHED) self.assertEqual(result[0],-5)
def loss(output,target): output = tf.squeeze(output,squeeze_dims=[3]) all_true_probability = output all_false_probability = tf.sub(tf.constant(1,dtype=tf.float32),output) tf.squeeze(target,squeeze_dims=[0]) actual_probability = tf.select(target,all_true_probability,all_false_probability) log_probability = tf.log(actual_probability) total_log_prob = tf.reduce_sum(log_probability,name='log_loss') total_log_loss = tf.neg(total_log_prob) return total_log_loss
def _compile(self, optimizer=None, verbose = False): """ compile the tensorflow function "self._objective" """ self._free_vars = tf.Variable(self.get_free_state()) self.make_tf_array(self._free_vars) with self.tf_mode(): f = self.build_likelihood() + self.build_prior() g, = tf.gradients(f, self._free_vars) self._minusF = tf.neg(f, name='objective') self._minusG = tf.neg(g, name='grad_objective') # The optimiser needs to be part of the computational graph, and needs # to be initialised before tf.initialise_all_variables() is called. if optimizer is None: opt_step = None else: opt_step = optimizer.minimize(self._minusF, var_list=[self._free_vars]) init = tf.initialize_all_variables() self._session.run(init) # build tensorflow functions for computing the likelihood if verbose: print("compiling tensorflow function...") sys.stdout.flush() def obj(x): return self._session.run([self._minusF, self._minusG], feed_dict={self._free_vars: x}) self._objective = obj if verbose: print("done") sys.stdout.flush() self._needs_recompile = False return opt_step
def __init__(self, num_words): # Define the hyperparameters self.dim = embed_dim # The size of the learned embeddings self.alpha = glove_alpha self.xmax = glove_xmax self.learning_rate = glove_learning_rate self.batch_size = glove_batch_size self.training_epochs = glove_training_epochs self.display_epoch_freq = 10 # How often to test and print out statistics self.num_words = num_words # The number of vectors to learn self.embeddings_cache = None # To be set later #self.inter_sess = tf.InteractiveSession(); # Define the inputs to the model self.Wi_input = tf.placeholder(tf.int32, None) self.Wj_input = tf.placeholder(tf.int32, None) self.coocur_input = tf.placeholder(tf.float32, None) # Define the trainable parameters of the model self.embeddings = tf.Variable(tf.random_uniform([len(vocabulary), self.dim], 1.0, -1.0)) self.bias = tf.Variable(tf.zeros([len(vocabulary)])) # Define the forward computation of the model self.Wi_embeddings = tf.reshape(tf.nn.embedding_lookup([self.embeddings], self.Wi_input), [self.batch_size, 1, self.dim ]) # print(tf.shape(self.Wi_embeddings)) self.Wj_embeddings = tf.reshape(tf.nn.embedding_lookup([self.embeddings], self.Wj_input), [self.batch_size, self.dim, 1]) self.bi = tf.reshape(tf.nn.embedding_lookup([self.bias], self.Wi_input), [self.batch_size, 1]) self.bj = tf.reshape(tf.nn.embedding_lookup([self.bias], self.Wj_input), [self.batch_size, 1]) self.dot_products = tf.reshape(tf.batch_matmul(self.Wi_embeddings, self.Wj_embeddings), [self.batch_size, 1]) # tf.Print(self.dot_products, [self.dot_products], message="This is a: ") self.square_term = tf.square(tf.add_n([self.dot_products, self.bi, self.bj, tf.neg(tf.log(tf.to_float(self.coocur_input)))])) self.weight_factor = tf.minimum(1.0, tf.pow(tf.div(self.coocur_input, self.xmax), self.alpha)) self.example_cost = tf.mul(self.weight_factor, self.square_term) # Define the cost function self.total_cost = tf.reduce_mean(self.example_cost) # Train self.optimizer = tf.train.AdagradOptimizer(self.learning_rate).minimize(self.total_cost) # Initialize variables self.init = tf.initialize_all_variables() # Initialize the model self.sess = tf.Session() self.sess.run(self.init)
def logsigmoid(input_tensor, name='logsigmoid'): '''Compute the log-sigmoid of an input tensor: ``f(x) = - log(1 + exp(-x))`` Parameters ---------- input_tensor : tf.Tensor The input tensor to scale Returns ------- logsigmoid : tf.Operator The log-sigmoid operator ''' with tf.name_scope(name): output = tf.neg(tf.nn.softplus(-input_tensor)) return output
def __init__(self, label, domain, layers=default_layers, defined=None, type_idx=None): self.label = label self.type_idx = type_idx self.defined = defined self.domain = domain self.number_of_layers = layers self.W = tf.Variable(tf.zeros([layers, self.domain.columns, self.domain.columns]), name="W"+label) self.V = tf.Variable(tf.zeros([layers, self.domain.columns]), name="V"+label) self.b = tf.Variable(tf.neg(tf.ones([1,layers])), name="b"+label) self.u = tf.Variable(tf.ones([layers,1]), name="u"+label) self.parameters = [self.W, self.V, self.b, self.u]
def fit(self): self.init = tf.initialize_all_variables() distance = tf.reduce_sum(tf.abs(tf.add(self.xtr, tf.neg(self.xte))), reduction_indices=1) self.pred = tf.arg_min(distance, 0) accuracy = 0. if self.x_test is None: return with tf.Session() as sess: sess.run(self.init) for i in range(len(self.x_test)): nn_index = sess.run(self.pred, feed_dict={self.xtr: self.x_train, self.xte: self.x_test[i, :]}) # print "Test", i, "Prediction:", np.argmax(self.y_train[nn_index]), \ # "True Class:", np.argmax(self.y_test[i]) if np.argmax(self.y_train[nn_index]) == np.argmax(self.y_test[i]): accuracy += 1. / len(self.x_test) print "Done!" print "Accuracy:", accuracy return accuracy
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.neg(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 gaussian2d(x, y, cx, cy, a, b, dtype = tf.float32): """ This cunction calcuate sum of N 2D Gaussian probability density functions in m points y, x : m x n 2D tensor. Position of calculation points m is number of calculation points n is number of Gaussian functions cx, cy, a, b : m x n 2D tensor. Parameters of Gaussian function cx and cy are center position a and b are the width in x and y firection """ # A = 1/(2*pi*a*b) A = tf.inv(tf.mul(tf.constant(2.0*np.pi, dtype), tf.mul(a, b))) # powerX = (x-xc)^2 / (2*a^2) powerX = tf.truediv(tf.pow(tf.sub(x, cx) , tf.constant(2.0, dtype)), tf.mul(tf.constant(2.0, dtype),tf.pow(a, tf.constant(2.0, dtype)))) # powerY = (y-yc)^2 / (2*b^2) powerY = tf.truediv(tf.pow(tf.sub(y, cy) , tf.constant(2.0, dtype)), tf.mul(tf.constant(2.0, dtype),tf.pow(a, tf.constant(2.0, dtype)))) # p = A*exp(- powerX - powerY) standard 2D Gaussian distribution probability = tf.reduce_sum( tf.mul(A, tf.exp(tf.neg(tf.add(powerX, powerY)))), 1) return probability
def setUp(self): self.a = tf.Variable(2.0, name="a") self.b = tf.Variable(3.0, name="b") self.c = tf.mul(self.a, self.b, name="c") # Should be 6.0. self.d = tf.mul(self.a, self.a, name="d") # Should be 4.0. self.e = tf.mul(self.d, self.c, name="e") # Should be 24.0. self.f_y = tf.constant(0.30, name="f_y") self.f = tf.div(self.b, self.f_y, name="f") # Should be 10.0. # The there nodes x, y and z form a graph with "cross-links" in. I.e., x # and y are both direct inputs to z, but x is also a direct input to y. self.x = tf.Variable(2.0, name="x") # Should be 2.0 self.y = tf.neg(self.x, name="y") # Should be -2.0. self.z = tf.mul(self.x, self.y, name="z") # Should be -4.0. self.sess = tf.Session() self.sess.run(tf.global_variables_initializer()) self.sess = tf.Session() self.sess.run(tf.global_variables_initializer())
x.eval(session=sess) # x.eval() does not work, as it requires a session! # %% We can setup an interactive session if we don't # want to keep passing the session around: sess.close() sess = tf.InteractiveSession() # %% Now this will work! x.eval() # %% Now a tf.Operation # We'll use our values from [-3, 3] to create a Gaussian Distribution sigma = 1.0 mean = 0.0 z = (tf.exp(tf.neg(tf.pow(x - mean, 2.0) / (2.0 * tf.pow(sigma, 2.0)))) * (1.0 / (sigma * tf.sqrt(2.0 * 3.1415)))) # %% By default, new operations are added to the default Graph assert z.graph is tf.get_default_graph() # %% Execute the graph and plot the result plt.plot(z.eval()) # %% We can find out the shape of a tensor like so: print(z.get_shape()) # %% Or in a more friendly format print(z.get_shape().as_list()) # %% Sometimes we may not know the shape of a tensor