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

Я очень новичок в 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)

Это правильный код для обучения набора данных?

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

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)

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

Спасибо.

 an unique monkey26 мая 2016 г., 05:07
ОК, я код простой пример для вас подождать минут
 an unique monkey26 мая 2016 г., 08:28
пожалуйста, вы могли бы провести некоторое время, это не сложно, как вы думаете ....
 VICTOR26 мая 2016 г., 05:14
@ уникальная обезьяна Большое спасибо!
 an unique monkey26 мая 2016 г., 04:51
Я думаю, что вы должны изучить некоторые базовые знания по API tenorflow, такие как тензор графов и т. Д. ... тогда вы могли бы увидеть первый пример классификации изображений, это так просто / tensorflow / примеры / уроки / mnist:
 VICTOR26 мая 2016 г., 04:54
@ уникальная обезьяна Спасибо за ваш ответ. Я прочитал учебник по TensorFlow. Тем не менее, это довольно сложно для меня, и я не могу найти простой способ классификации изображений. Есть ли у вас какие-либо предложения, по которым я должен читать?

Ответы на вопрос(1)

Решение Вопроса

может быть, вы можете попробовать это после установки 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()
 Sakhri Houssem06 февр. 2018 г., 14:25
Спасибо, мистер @ an-unique-monkey, я использовалtf.image.decode_gif  для формата изображенийTIF а это моеDataSetGen   код, но я не знаю, если это правильный путь
 Hara Hara Mahadevaki09 апр. 2017 г., 13:05
он говорит 'ValueError: только вызовsparse_softmax_cross_entropy_with_logits с именованным аргументом '
 VICTOR26 мая 2016 г., 09:52
Итак, модель будет сохранена после запуска этого кода. Я прав? Если я хочу использовать модель для классификации нового ввода, какую функцию я должен использовать?
 an unique monkey26 мая 2016 г., 11:24
нет ... когда вы сохраняете свою модель, вы должны:saver.save (sess, 'models_0524 / my_modle', global_step = step) когда вы восстанавливаете модель, вы должны:saver.restore (Sess, "models_0522_pm / my_modle-2049")
 VICTOR26 мая 2016 г., 10:15
Нужно ли открывать новую .py программу с кодом:save = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, "checkpoint")?
 an unique monkey26 мая 2016 г., 09:57
tf.restore для загрузки модели и tf.nn.softmax для прогнозирования нового ввода
 VICTOR26 мая 2016 г., 11:26
 omar02 апр. 2017 г., 22:37
Кто-нибудь получает следующую ошибку при попытке ответить на этот вопрос? может кто-нибудь помочь, пожалуйста! ValueError: только вызовsparse_softmax_cross_entropy_with_logits с именованными аргументами (метки = ..., logits = ..., ...)
 VICTOR26 мая 2016 г., 10:34
Нужно ли изменить размер нового ввода, прежде чем его прогнозировать?
 an unique monkey05 апр. 2017 г., 09:32
@omar cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits (logits = logits, метки = метки, name = 'xentropy')
 VICTOR26 мая 2016 г., 11:00
save = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, "checkpoint")  Это способ восстановить модель? Тем не менее, есть ошибкаNo variables to save
 VICTOR26 мая 2016 г., 07:01
OMG, это круто. Позвольте мне сначала понять код. Спасибо!
 an unique monkey26 мая 2016 г., 10:55
да, вы должны изменить размер нового ввода в соответствии с размером данных трассировки

Ваш ответ на вопрос