def simple_classification(): batch_size = 100 x = tf.placeholder(tf.float32, (None, 784)) b = tf.Variable(tf.zeros((batch_size, ))) W = tf.Variable(tf.random_uniform((784, batch_size), -1, 1)) h = tf.nn.relu(tf.matmul(x, W) + b) prediction = tf.nn.softmax(h) label = tf.placeholder(tf.float32, [batch_size, 10]) cross_entropy = -tf.reduc_sum(label * tf.log(prediction), axis=1) # 0.5 is learning rate train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) tf.reset_default_graph() sess = tf.Session() sess.run(tf.initialize_all_variable()) for i in range(1000): batch_x, batch_label = data.next_batch() sess.run(train_step, feed_dict={x: batch_x, label: batch_label})
def train(): sess = tf.Session() model = ConvModel1() data_reader = DataReader() loss = tf.sqrt(tf.reduce_mean(tf.square(tf.sub(model.y_, model.y)))) train_step = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) sess.run(tf.initialize_all_variable()) saver = tf.train.Saver() for epoch in range(NUM_EPOCH): for train_batch in data_reader.train_batch(BATCH_SIZE): train_step.run(feed_dict={ model.x: train_batch[0], model.y_: train_batch[1] }) train_error = loss.eval(feed_dict={ model.x: train_batch[0], model.y_: train_batch[1] }) if epoch % 10 == 0: cv_set = data_reader.cv_set() cv_error = loss.eval(feed_dict={ model.x: cv_set[0], model.y_: cv_set[1] }) print("Step: %d, train loss: %g, cv loss: " % epoch, train_error, cv_error) checkpoint_path = os.path.join(CKPT_DIR, CKPT_FILE) filename = saver.save(sess, checkpoint_path) print('Model saved in file: %s' % filename)
def train_neural_network(x): prediction = recurrent_neural_network(x) cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(prediction, y)) optimizer = tf.train.AdamOptimizer().minimize(cost) with tf.Session() as sess: sess.run(tf.initialize_all_variable()) for epoch in range(hm_epochs): epoch_loss = 0 for _ in range(int(mnist.train.num_examples / batch_size)): epoch_x, epoch_y = mnist.train.next_batch(batch_size) epoch_x = epoch_x.reshape((batch_size, n_chunks, chunk_size)) _, c = sess.run([optimizer, cost], feed_dict={ x: epoch_x, y: epoch_y }) epoch_loss += c print('Epoch', epoch, 'completed out of', hm_epochs, 'loss:', epoch_loss) correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct, 'float')) print( 'Accuracy:', accuracy.eval({ x: mnist.test.images.reshape((-1, n_chunks, chunk_size)), y: mnist.test.labels }))
import tensorflow as tf state = tf.Variable(0,name='counter') #print(state.name) one = tf.constant(1) new_value = tf.add(state,noe) update = tf.assign(state,new_value) init = tf.initialize_all_variable() # must have if define variable with tf.Session as sess: sess.run(init) for_in range(3): sess.run(update) print(sess.run()state)
X=tf.constant("float") Y=tf.constant("float") # Create Model W=tf.Variable(rng.randn(),name="weight") b=tf.Variable(rng.randn(),name="bias") # Construct a linear model activation=tf.add(tf.mul(X, W), b) # minimize squared error cost=tf.reduce_sum(tf.pow(Y-activation,2)/(2*n_samples)) optimiser=tf.train.GradientDescentOptimizer(learninn_rate).minimize(cost) # initialize all the variables init=tf.initialize_all_variable() # launch the graph with tf.Session() as sess: sess.run(init) # fit all training data for epoch in range(training_epochs): for (x,y) in zip(train_X,train_Y): sess.run(optimiser,feed_dict={X:x,Y:y}) # display logs each epoch if epoch % display_step ==0: print "Epoch:",'%04d' % (epoch+1), "cost=","{:.9f}".format(sess.run(cost,feed_dict={X:train_X,Y:train_Y})),"W=",sess.run(W)\ ,"b=",sess.run(b)
import os import tensorflow as tf from tensorflow.core.protobuf import saver_pb2 import driving_data #2 import model #3 log = './save' sess = tf.InteractiveSession() L2NormConst = 0.001 train_variables = tf.trainable_variables() loss_func = tf.reduce_mean(tf.square(tf.subtract(model.y_,model.y)) + tf.add_n([tf.nn.l2_loss(v) for v in train_variables]) * L2NormConst ) train_step = tf.train.AdamOptimizer(1e-4).minimize(loss) sess.run(tf.initialize_all_variable()) ##TO SAVE THE RESULT tf.summary.scalar("loss", loss) merged_summary_op = tf.summary.merger_all() saver = tf.train.Saver(write_version = saver_pb2.SaverDef.V1) logs_path = './logs' summary_writer = tf.summay.FileWriter(logs_path,graph=tf.get_default_graph()) #### epochs = 30 batch_size = 100 for epoch in range(epochs): for i in range(int(driving_data.num_of_images / batch_size)): x, y = driving_data.LoadBatchFromTraining(batch_size)
import tensorflow as tf state = tf.Variable(0, name="counter") one = tf.constant(1) new_value = tf.add(state, one) update = tf.assign(state, new_value) init = tf.initialize_all_variable() with tf.Session() as sess: sess.run(init) for _ in range(3): sess.run(update) print(sess.run(state))
def train(self, config): d_optim = tf.train.AdamOptimizer(config.learning_rate, beta1=config.beta1).minimize( self.d_loss, var_list=self.d_vars) g_optim = tf.train.AdamOptimizer(config.learning_rate, beta1=config.beta1).minimize( self.g_loss, var_list=self.g_vars) try: tf.global_variables_initializer().run() except: tf.initialize_all_variable().run() if config.G_img_sum: self.g_sum = merge_summary([ self.z_sum, self.d_sum_, self.G_sum, self.d_loss_fake_sum, self.g_loss_sum ]) else: self.g_sum = merge_summary([ self.z_sum, self.d_sum_, self.d_loss_fake_sum, self.g_loss_sum ]) self.d_sum = merge_summary( [self.z_sum, self.d_sum, self.d_loss_real_sum, self.d_loss_sum]) self.writer = SummaryWriter(os.path.join(self.out_dir, "logs"), self.sess.graph) sample_z = gen_random(config.z_dist, size=(self.sample_num, self.z_dim)) sample_files = self.data[0:self.sample_num] sample = [ get_image(sample_file, input_height=self.input_height, input_width=self.input_width, resize_height=self.output_height, resize_width=self.output_width, crop=self.crop, grayscale=self.grayscale) for sample_file in sample_files ] if (self.grayscale): sample_inputs = np.array(sample).astype(np.float32)[:, :, :, None] else: sample_inputs = np.array(sample).astype(np.float32) counter = 1 start_time = time.time() could_load, checkpoint_counter = self.load(self.checkpoint_dir) if could_load: counter = checkpoint_counter print("load success") else: print("load failed") for epoch in xrange(config.epoch): self.data = glob( os.path.join(config.data_dir, config.dataset, self.input_fname_pattern)) np.random.shuffle(self.data) batch_idxs = min(len(self.data), config.train_size) // config.batch_size for idx in xrange(0, int(batch_idxs)): batch_files = self.data[idx * config.batch_size:(idx + 1) * config.batch_size] batch = [ get_image(batch_file, input_height=self.input_height, input_width=self.input_width, resize_height=self.output_height, resize_width=self.output_width, crop=self.crop, grayscale=self.grayscale) for batch_file in batch_files ] if self.grayscale: batch_images = np.array(batch).astype(np.float32)[:, :, :, None] else: batch_images = np.array(batch).astype(np.float32) batch_z = gen_random(config.z_dist, size=[config.batch_size, self.z_dim]) \ .astype(np.float32) _, summary_str = self.sess.run([d_optim, self.d_sum], feed_dict={ self.inputs: batch_images, self.z: batch_z }) self.writer.add_summary(summary_str, counter) _, summary_str = self.sess.run([g_optim, self.g_sum], feed_dict={self.z: batch_z}) self.writer.add_summary(summary_str, counter) _, summary_str = self.sess.run([g_optim, self.g_sum], feed_dict={self.z: batch_z}) self.writer.add_summary(summary_str, counter) _, summary_str = self.sess.run([g_optim, self.g_sum], feed_dict={self.z: batch_z}) self.writer.add_summary(summary_str, counter) errD_fake = self.d_loss_fake.eval({self.z: batch_z}) errD_real = self.d_loss_real.eval({self.inputs: batch_images}) errG = self.g_loss.eval({self.z: batch_z}) print("%8d Epoch:[%2d/%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \ % (counter, epoch, config.epoch, idx, batch_idxs, time.time() - start_time, errD_fake+errD_real, errG)) if np.mod(counter, config.sample_freq) == 0: try: samples, d_loss, g_loss = self.sess.run( [self.sampler, self.d_loss, self.g_loss], feed_dict={ self.z: sample_z, self.inputs: sample_inputs, }, ) save_images( samples, image_manifold_size(samples.shape[0]), './{}/train_{:08d}.png'.format( config.sample_dir, counter)) print("[Sample] d_loss: %.8f, g_loss: %.8f" % (d_loss, g_loss)) except: print("one pic error!") if np.mod(counter, config.ckpt_freq) == 0: self.save(config.checkpoint_dir, counter) counter += 1