def add_data(mnist_data, data_list): """ Args: mnist_data: original mnist_data dat_list: numpy array list Return: numy array """ data_num = len(data_list) train_images = mnist_data.train.images train_labels = mnist_data.train.labels test_images = mnist_data.test.images test_labels = mnist_data.test.labels for data in data_list: add_num = len(data) train_images = fix_images(train_images, data) train_labels = fix_labels(train_labels, add_num) test_images = fix_images(test_images, data) test_labels = fix_labels(test_labels, add_num) VALIDATION_SIZE = 5000 validation_images = train_images[:VALIDATION_SIZE] validation_labels = train_labels[:VALIDATION_SIZE] train_images = train_images[VALIDATION_SIZE:] train_labels = train_labels[VALIDATION_SIZE:] mnist_data.train = input_data.DataSet(train_images, train_labels, add=True) mnist_data.validation = input_data.DataSet(validation_images, validation_labels, add=True) mnist_data.test = input_data.DataSet(test_images, test_labels, add=True) return mnist_data
def augment_data(data, folderpath=''): images = data.train.images labels = data.train.labels images = images.reshape((-1, 28, 28, 1)) imgs = [x for i in range(10) for x in read_results(i, folderpath)[-1][0]] imgs = np.array(imgs)[:, :, :, None] lbls = np.empty((imgs.shape[0], 10)) lbls.fill(1/10) images = np.concatenate((imgs, images)) labels = np.concatenate((lbls, labels)) images, labels = _shuffle_images_labels(images, labels) new_train = input_data.DataSet(images, labels) data.train = new_train
def augment_random_data(data): images = data.train.images labels = data.train.labels uniform_prob = np.empty((800, 10)) uniform_prob.fill(1/10) images = np.concatenate((np.zeros((800, 784)), images)) labels = np.concatenate((uniform_prob, labels)) images = np.concatenate((np.random.rand(800, 784), images)) labels = np.concatenate((uniform_prob, labels)) images *= 255 images = images.reshape((-1, 28, 28, 1)) images, labels = _shuffle_images_labels(images, labels) new_train = input_data.DataSet(images, labels) data.train = new_train
correct = 0 wrong = 0 for i in range(cnt): files[i] = dir_name + "/" + files[i] print('files:', files[i]) test_images1, test_labels1 = GetImage([files[i]]) input_index = int(files[i].strip().split('/')[1][0]) print("input_index:", input_index) # print (tf.cast(correct_prediction, tf.float32).eval) # print(shape(test_images1)) mnist.test = input_data.DataSet(test_images1, test_labels1, dtype=tf.float32) res = accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}) # print('++++++++++++++++++++++++++++++++++++++++++') # print(shape(mnist.test.images)) # print('------------------------------------------') # print (tf.argmax(y, 1)) # print(y.eval()) output_res = int(res[0]) print("output:", output_res) print("\n") # if(output_res==input_index): # correct = correct + 1 # print("correct!\n")
#validation step correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) # accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))# used to get accuracy accuracy = tf.cast(tf.argmax(y_conv, 1), tf.float32) # used to get calculated label labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] dir_name = "data/test/" files = os.listdir(dir_name) cnt = len(files) #print(files) test_images, test_labels = GetImage(dir_name, files) test_set = input_data.DataSet(test_images, test_labels) saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, 'models/mnist_10.model') output = sess.run(accuracy, feed_dict={ x: test_set.images, y: test_set.labels, keep_prob: 1.0 }) for a in range(len(output)): print 'input_' + str(a) + ':', labels[argmax(test_labels[a])] print 'output_' + str(a) + ':', labels[int(output[a])] #print("output:",labels[res.argmax()]) '''
def run_training(): train_data = input_data.DataSet('train.txt') test_data = input_data.DataSet('test.txt') # Tell TensorFlow that the model will be built into the default Graph. with tf.Graph().as_default(): # Generate placeholders for the images and truth. images_placeholder, truth_placeholder = placeholder_inputs( FLAGS.batch_size) # Build a Graph that computes result from the inference model. result = face_net.inference(images_placeholder) # Add to the Graph the Ops for loss calculation. loss = face_net.loss(result, truth_placeholder) # Add to the Graph the Ops that calculate and apply gradients. train_op = face_net.training(loss, FLAGS.learning_rate) # Build the summary Tensor based on the TF collection of Summaries. summary = tf.summary.merge_all() # Add the variable initializer Op. init = tf.global_variables_initializer() # Create a saver for writing training checkpoints. saver = tf.train.Saver() # Create a session for running Ops on the Graph. sess = tf.Session() # Instantiate a SummaryWriter to output summaries and the Graph. summary_writer = tf.summary.FileWriter(FLAGS.log_dir, sess.graph) # And then after everything is built: # Run the Op to initialize the variables. sess.run(init) total_time = 0 # Start the training loop. for step in xrange(FLAGS.max_steps): start_time = time.time() # Fill a feed dictionary with the actual set of images and truth # for this particular training step. feed_dict = fill_feed_dict(train_data, images_placeholder, truth_placeholder) # Run one step of the model. The return values are the activations # from the `train_op` (which is discarded) and the `loss` Op. To # inspect the values of your Ops or variables, you may include them # in the list passed to sess.run() and the value tensors will be # returned in the tuple from the call. _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict) duration = time.time() - start_time total_time = total_time + duration # Write the summaries and print an overview fairly often. if (step+1) % 100 == 0: # Print status to stdout. print('Step %d: loss = %.2f (%.3f sec)' % (step+1, loss_value, total_time)) # Update the events file. summary_str = sess.run(summary, feed_dict=feed_dict) summary_writer.add_summary(summary_str, step) summary_writer.flush() # Save a checkpoint and evaluate the model periodically. if (step + 1) % 5000 == 0 or (step + 1) == FLAGS.max_steps: checkpoint_file = os.path.join(FLAGS.log_dir, 'model.ckpt') saver.save(sess, checkpoint_file, global_step=step) # Evaluate against the training set. print('Training Data Eval:') do_eval(sess, loss, images_placeholder, truth_placeholder, train_data) # Evaluate against the test set. print('Test Data Eval:') do_eval(sess, loss, images_placeholder, truth_placeholder, test_data) summary_writer.flush() print('Total time: %.3f sec' % (total_time))
final_train_labels = train_labels else: final_train_images = train_images final_train_labels = train_labels print('total number of images used for training : ', len(final_train_images)) # set aside a few images for validation and tuning validation_images = final_train_images[:VALIDATION_SIZE] validation_labels = final_train_labels[:VALIDATION_SIZE] # train images and labels train_images = final_train_images[VALIDATION_SIZE:] train_labels = final_train_labels[VALIDATION_SIZE:] # update data_sets class data_sets.train = input_data.DataSet(train_images, train_labels) data_sets.validation = input_data.DataSet(validation_images, validation_labels) data_sets.test = input_data.DataSet(test_images, test_labels) data = data_sets # model with tf.variable_scope("convolutional"): x = tf.placeholder(tf.float32, [None, 784]) keep_prob = tf.placeholder(tf.float32) y, variables = model.convolutional(x, keep_prob) # train y_ = tf.placeholder(tf.float32, [None, 10]) cross_entropy = -tf.reduce_sum(y_ * tf.log(y)) train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) #accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) accuracy = tf.cast(tf.argmax(y_conv, 1), tf.float32) sess = tf.InteractiveSession() saver = tf.train.Saver() saver_path = saver.restore( sess, "/home/tuopan/PycharmProjects/test/model/model.ckpt") print(sess.run(b_conv1)) #batch = mnist.train.next_batch(10) print('start batching') #print("test accuracy :" ,sess.run(accuracy,feed_dict={ # x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})) dir_name = "test_num" files = os.listdir(dir_name) cnt = len(files) for i in range(cnt): files[i] = dir_name + "/" + files[i] test_images1, test_labels1 = GetImage([files[i]]) mnist.test = input_data.DataSet(test_images1, test_labels1) res = sess.run(accuracy, feed_dict={ x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0 }) print("output:", int(res[0])) print("\n") print('end batching')