TensorFlow классификация изображений

Question

Я очень новичок в TensorFlow. Теперь я делаю классификацию , используя мою собственную базу данных обучения.

Однако, после того как я подготовил свой собственный набор данных, я понятия не имею, как классифицировать входное изображение.

Вот мой код для подготовки моих собственного набора данных

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 кода правит для подготовки набора данных?

Впоследствии я пытаюсь использовать его для классификации входных изображений с помощью следующего кода.

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) 

Однако он не возвращает прогнозируемую метку для входных изображений. Я ищу помощь, чтобы научить меня классифицировать изображения, используя собственный набор данных.

спасибо.

Answer 1

может быть, вы могли бы попробовать это после того, как вы должны установить PIL питона 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()