I am very new to TensorFlow. I am now doing the image classification by using my own training database.
However, after I trained my own dataset, I have no idea on how to classify the input image.
Here is my code for preparing my own dataset
filenames = ['01.jpg', '02.jpg', '03.jpg', '04.jpg'] label = [0,1,1,1] filename_queue = tf.train.string_input_producer(filenames) reader = tf.WholeFileReader() filename, content = reader.read(filename_queue) image = tf.image.decode_jpeg(content, channels=3) image = tf.cast(image, tf.float32) resized_image = tf.image.resize_images(image, 224, 224) image_batch , label_batch= tf.train.batch([resized_image,label], batch_size=8, num_threads = 3, capacity=5000)
Am I code correct for training the dataset?
Afterwards, I try to use it to classify the input images with the following code.
test = ['test.jpg', 'test2.jpg'] test_queue=tf.train.string_input_producer(test) reader = tf.WholeFileReader() testname, test_content = reader.read(test_queue) test = tf.image.decode_jpeg(test_content, channels=3) test = tf.cast(test, tf.float32) resized_image = tf.image.resize_images(test, 224,224) with tf.Session() as sess: coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) res = sess.run(resized_image) coord.request_stop() coord.join(threads)
However, it does not return the predicted label for the input images. I am looking the help to teach me how to classify the images by using my own dataset.
Thank you.
maybe you could try this after you have install PIL python lib:
from __future__ import absolute_import from __future__ import division from __future__ import print_function import time import math import numpy import numpy as np import random from PIL import Image from six.moves import xrange # pylint: disable=redefined-builtin import tensorflow as tf # Basic model parameters as external flags. flags = tf.app.flags FLAGS = flags.FLAGS flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.') flags.DEFINE_integer('max_steps', 2000, 'Number of steps to run trainer.') flags.DEFINE_integer('hidden1', 128, 'Number of units in hidden layer 1.') flags.DEFINE_integer('hidden2', 32, 'Number of units in hidden layer 2.') flags.DEFINE_integer('batch_size', 4, 'Batch size. ' 'Must divide evenly into the dataset sizes.') flags.DEFINE_string('train_dir', 'data', 'Directory to put the training data.') flags.DEFINE_boolean('fake_data', False, 'If true, uses fake data ' 'for unit testing.') NUM_CLASSES = 2 IMAGE_SIZE = 28 CHANNELS = 3 IMAGE_PIXELS = IMAGE_SIZE * IMAGE_SIZE * CHANNELS def inference(images, hidden1_units, hidden2_units): # Hidden 1 with tf.name_scope('hidden1'): weights = tf.Variable( tf.truncated_normal([IMAGE_PIXELS, hidden1_units], stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))), name='weights') biases = tf.Variable(tf.zeros([hidden1_units]), name='biases') hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases) # Hidden 2 with tf.name_scope('hidden2'): weights = tf.Variable( tf.truncated_normal([hidden1_units, hidden2_units], stddev=1.0 / math.sqrt(float(hidden1_units))), name='weights') biases = tf.Variable(tf.zeros([hidden2_units]), name='biases') hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases) # Linear with tf.name_scope('softmax_linear'): weights = tf.Variable( tf.truncated_normal([hidden2_units, NUM_CLASSES], stddev=1.0 / math.sqrt(float(hidden2_units))), name='weights') biases = tf.Variable(tf.zeros([NUM_CLASSES]), name='biases') logits = tf.matmul(hidden2, weights) + biases return logits def cal_loss(logits, labels): labels = tf.to_int64(labels) cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits( logits, labels, name='xentropy') loss = tf.reduce_mean(cross_entropy, name='xentropy_mean') return loss def training(loss, learning_rate): optimizer = tf.train.GradientDescentOptimizer(learning_rate) global_step = tf.Variable(0, name='global_step', trainable=False) train_op = optimizer.minimize(loss, global_step=global_step) return train_op def evaluation(logits, labels): correct = tf.nn.in_top_k(logits, labels, 1) return tf.reduce_sum(tf.cast(correct, tf.int32)) def placeholder_inputs(batch_size): images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,IMAGE_PIXELS)) labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size)) return images_placeholder, labels_placeholder def fill_feed_dict(images_feed,labels_feed, images_pl, labels_pl): feed_dict = { images_pl: images_feed, labels_pl: labels_feed, } return feed_dict def do_eval(sess, eval_correct, images_placeholder, labels_placeholder, data_set): # And run one epoch of eval. true_count = 0 # Counts the number of correct predictions. steps_per_epoch = 4 // FLAGS.batch_size num_examples = steps_per_epoch * FLAGS.batch_size for step in xrange(steps_per_epoch): feed_dict = fill_feed_dict(train_images,train_labels, images_placeholder, labels_placeholder) true_count += sess.run(eval_correct, feed_dict=feed_dict) precision = true_count / num_examples print(' Num examples: %d Num correct: %d Precision @ 1: %0.04f' % (num_examples, true_count, precision)) # Get the sets of images and labels for training, validation, and train_images = [] for filename in ['01.jpg', '02.jpg', '03.jpg', '04.jpg']: image = Image.open(filename) image = image.resize((IMAGE_SIZE,IMAGE_SIZE)) train_images.append(np.array(image)) train_images = np.array(train_images) train_images = train_images.reshape(4,IMAGE_PIXELS) label = [0,1,1,1] train_labels = np.array(label) def run_training(): # Tell TensorFlow that the model will be built into the default Graph. with tf.Graph().as_default(): # Generate placeholders for the images and labels. images_placeholder, labels_placeholder = placeholder_inputs(4) # Build a Graph that computes predictions from the inference model. logits = inference(images_placeholder, FLAGS.hidden1, FLAGS.hidden2) # Add to the Graph the Ops for loss calculation. loss = cal_loss(logits, labels_placeholder) # Add to the Graph the Ops that calculate and apply gradients. train_op = training(loss, FLAGS.learning_rate) # Add the Op to compare the logits to the labels during evaluation. eval_correct = evaluation(logits, labels_placeholder) # Create a saver for writing training checkpoints. saver = tf.train.Saver() # Create a session for running Ops on the Graph. sess = tf.Session() # Run the Op to initialize the variables. init = tf.initialize_all_variables() sess.run(init) # And then after everything is built, start the training loop. for step in xrange(FLAGS.max_steps): start_time = time.time() feed_dict = fill_feed_dict(train_images,train_labels, images_placeholder, labels_placeholder) _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict) duration = time.time() - start_time if step % 100 == 0: # Print status to stdout. print('Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration)) if (step + 1) % 1000 == 0 or (step + 1) == FLAGS.max_steps: saver.save(sess, FLAGS.train_dir, global_step=step) print('Training Data Eval:') do_eval(sess, eval_correct, images_placeholder, labels_placeholder, train_images) def main(_): run_training() if __name__ == '__main__': tf.app.run()
