Merge pull request #5 from tensorflow/inception

added inception model

inception/imagenet_data.py

+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Small library that points to the ImageNet data set.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+
+from inception.dataset import Dataset
+
+
+class ImagenetData(Dataset):
+  """ImageNet data set."""
+
+  def __init__(self, subset):
+    super(ImagenetData, self).__init__('ImageNet', subset)
+
+  def num_classes(self):
+    """Returns the number of classes in the data set."""
+    return 1000
+
+  def num_examples_per_epoch(self):
+    """Returns the number of examples in the data set."""
+    # Bounding box data consists of 615299 bounding boxes for 544546 images.
+    if self.subset == 'train':
+      return 1281167
+    if self.subset == 'validation':
+      return 50000
+
+  def download_message(self):
+    """Instruction to download and extract the tarball from Flowers website."""
+
+    print('Failed to find any ImageNet %s files'% self.subset)
+    print('')
+    print('If you have already downloaded and processed the data, then make '
+          'sure to set --data_dir to point to the directory containing the '
+          'location of the sharded TFRecords.\n')
+    print('If you have not downloaded and prepared the ImageNet data in the '
+          'TFRecord format, you will need to do this at least once. This '
+          'process could take several hours depending on the speed of your '
+          'computer and network connection\n')
+    print('Please see README.md for instructions on how to build '
+          'the ImageNet dataset using download_and_preprocess_imagenet.\n')
+    print('Note that the raw data size is 300 GB and the processed data size '
+          'is 150 GB. Please ensure you have at least 500GB disk space.')

inception/imagenet_eval.py

+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""A binary to evaluate Inception on the flowers data set.
+
+Note that using the supplied pre-trained inception checkpoint, the eval should
+achieve:
+  precision @ 1 = 0.7874 recall @ 5 = 0.9436 [50000 examples]
+
+See the README.md for more details.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+import tensorflow as tf
+
+from inception import inception_eval
+from inception.imagenet_data import ImagenetData
+
+FLAGS = tf.app.flags.FLAGS
+
+
+def main(unused_argv=None):
+  dataset = ImagenetData(subset=FLAGS.subset)
+  assert dataset.data_files()
+  if tf.gfile.Exists(FLAGS.eval_dir):
+    tf.gfile.DeleteRecursively(FLAGS.eval_dir)
+  tf.gfile.MakeDirs(FLAGS.eval_dir)
+  inception_eval.evaluate(dataset)
+
+
+if __name__ == '__main__':
+  tf.app.run()

inception/imagenet_train.py

+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""A binary to train Inception on the ImageNet data set.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+
+import tensorflow as tf
+
+from inception import inception_train
+from inception.imagenet_data import ImagenetData
+
+FLAGS = tf.app.flags.FLAGS
+
+
+def main(_):
+  dataset = ImagenetData(subset=FLAGS.subset)
+  assert dataset.data_files()
+  if tf.gfile.Exists(FLAGS.train_dir):
+    tf.gfile.DeleteRecursively(FLAGS.train_dir)
+  tf.gfile.MakeDirs(FLAGS.train_dir)
+  inception_train.train(dataset)
+
+
+if __name__ == '__main__':
+  tf.app.run()

inception/inception_eval.py

+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""A library to evaluate Inception on a single GPU.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from datetime import datetime
+import math
+import os.path
+import time
+
+
+import numpy as np
+import tensorflow as tf
+
+from inception import image_processing
+from inception import inception_model as inception
+
+
+FLAGS = tf.app.flags.FLAGS
+
+tf.app.flags.DEFINE_string('eval_dir', '/tmp/imagenet_eval',
+                           """Directory where to write event logs.""")
+tf.app.flags.DEFINE_string('checkpoint_dir', '/tmp/imagenet_train',
+                           """Directory where to read model checkpoints.""")
+
+# Flags governing the frequency of the eval.
+tf.app.flags.DEFINE_integer('eval_interval_secs', 60 * 5,
+                            """How often to run the eval.""")
+tf.app.flags.DEFINE_boolean('run_once', False,
+                            """Whether to run eval only once.""")
+
+# Flags governing the data used for the eval.
+tf.app.flags.DEFINE_integer('num_examples', 50000,
+                            """Number of examples to run. Note that the eval """
+                            """ImageNet dataset contains 50000 examples.""")
+tf.app.flags.DEFINE_string('subset', 'validation',
+                           """Either 'validation' or 'train'.""")
+
+
+def _eval_once(saver, summary_writer, top_1_op, top_5_op, summary_op):
+  """Runs Eval once.
+
+  Args:
+    saver: Saver.
+    summary_writer: Summary writer.
+    top_1_op: Top 1 op.
+    top_5_op: Top 5 op.
+    summary_op: Summary op.
+  """
+  with tf.Session() as sess:
+    ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
+    if ckpt and ckpt.model_checkpoint_path:
+      if os.path.isabs(ckpt.model_checkpoint_path):
+        # Restores from checkpoint with absolute path.
+        saver.restore(sess, ckpt.model_checkpoint_path)
+      else:
+        # Restores from checkpoint with relative path.
+        saver.restore(sess, os.path.join(FLAGS.checkpoint_dir,
+                                         ckpt.model_checkpoint_path))
+
+      # Assuming model_checkpoint_path looks something like:
+      #   /my-favorite-path/imagenet_train/model.ckpt-0,
+      # extract global_step from it.
+      global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
+      print('Succesfully loaded model from %s at step=%s.' %
+            (ckpt.model_checkpoint_path, global_step))
+    else:
+      print('No checkpoint file found')
+      return
+
+    # Start the queue runners.
+    coord = tf.train.Coordinator()
+    try:
+      threads = []
+      for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
+        threads.extend(qr.create_threads(sess, coord=coord, daemon=True,
+                                         start=True))
+
+      num_iter = int(math.ceil(FLAGS.num_examples / FLAGS.batch_size))
+      # Counts the number of correct predictions.
+      count_top_1 = 0.0
+      count_top_5 = 0.0
+      total_sample_count = num_iter * FLAGS.batch_size
+      step = 0
+
+      print('%s: starting evaluation on (%s).' % (datetime.now(), FLAGS.subset))
+      start_time = time.time()
+      while step < num_iter and not coord.should_stop():
+        top_1, top_5 = sess.run([top_1_op, top_5_op])
+        count_top_1 += np.sum(top_1)
+        count_top_5 += np.sum(top_5)
+        step += 1
+        if step % 20 == 0:
+          duration = time.time() - start_time
+          sec_per_batch = duration / 20.0
+          examples_per_sec = FLAGS.batch_size / sec_per_batch
+          print('%s: [%d batches out of %d] (%.1f examples/sec; %.3f'
+                'sec/batch)' % (datetime.now(), step, num_iter,
+                                examples_per_sec, sec_per_batch))
+          start_time = time.time()
+
+      # Compute precision @ 1.
+      precision_at_1 = count_top_1 / total_sample_count
+      recall_at_5 = count_top_5 / total_sample_count
+      print('%s: precision @ 1 = %.4f recall @ 5 = %.4f [%d examples]' %
+            (datetime.now(), precision_at_1, recall_at_5, total_sample_count))
+
+      summary = tf.Summary()
+      summary.ParseFromString(sess.run(summary_op))
+      summary.value.add(tag='Precision @ 1', simple_value=precision_at_1)
+      summary.value.add(tag='Recall @ 5', simple_value=recall_at_5)
+      summary_writer.add_summary(summary, global_step)
+
+    except Exception as e:  # pylint: disable=broad-except
+      coord.request_stop(e)
+
+    coord.request_stop()
+    coord.join(threads, stop_grace_period_secs=10)
+
+
+def evaluate(dataset):
+  """Evaluate model on Dataset for a number of steps."""
+  with tf.Graph().as_default():
+    # Get images and labels from the dataset.
+    images, labels = image_processing.inputs(dataset)
+
+    # Number of classes in the Dataset label set plus 1.
+    # Label 0 is reserved for an (unused) background class.
+    num_classes = dataset.num_classes() + 1
+
+    # Build a Graph that computes the logits predictions from the
+    # inference model.
+    logits, _ = inception.inference(images, num_classes)
+
+    # Calculate predictions.
+    top_1_op = tf.nn.in_top_k(logits, labels, 1)
+    top_5_op = tf.nn.in_top_k(logits, labels, 5)
+
+    # Restore the moving average version of the learned variables for eval.
+    variable_averages = tf.train.ExponentialMovingAverage(
+        inception.MOVING_AVERAGE_DECAY)
+    variables_to_restore = variable_averages.variables_to_restore()
+    saver = tf.train.Saver(variables_to_restore)
+
+    # Build the summary operation based on the TF collection of Summaries.
+    summary_op = tf.merge_all_summaries()
+
+    graph_def = tf.get_default_graph().as_graph_def()
+    summary_writer = tf.train.SummaryWriter(FLAGS.eval_dir,
+                                            graph_def=graph_def)
+
+    while True:
+      _eval_once(saver, summary_writer, top_1_op, top_5_op, summary_op)
+      if FLAGS.run_once:
+        break
+      time.sleep(FLAGS.eval_interval_secs)

inception/inception_model.py

+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Build the Inception v3 network on ImageNet data set.
+
+The Inception v3 architecture is described in http://arxiv.org/abs/1512.00567
+
+Summary of available functions:
+ inference: Compute inference on the model inputs to make a prediction
+ loss: Compute the loss of the prediction with respect to the labels
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import re
+
+
+import tensorflow as tf
+
+from inception.slim import slim
+
+FLAGS = tf.app.flags.FLAGS
+
+# If a model is trained using multiple GPUs, prefix all Op names with tower_name
+# to differentiate the operations. Note that this prefix is removed from the
+# names of the summaries when visualizing a model.
+TOWER_NAME = 'tower'
+
+# Batch normalization. Constant governing the exponential moving average of
+# the 'global' mean and variance for all activations.
+BATCHNORM_MOVING_AVERAGE_DECAY = 0.9997
+
+# The decay to use for the moving average.
+MOVING_AVERAGE_DECAY = 0.9999
+
+
+def inference(images, num_classes, for_training=False, restore_logits=True,
+              scope=None):
+  """Build Inception v3 model architecture.
+
+  See here for reference: http://arxiv.org/abs/1512.00567
+
+  Args:
+    images: Images returned from inputs() or distorted_inputs().
+    num_classes: number of classes
+    for_training: If set to `True`, build the inference model for training.
+      Kernels that operate differently for inference during training
+      e.g. dropout, are appropriately configured.
+    restore_logits: whether or not the logits layers should be restored.
+      Useful for fine-tuning a model with different num_classes.
+    scope: optional prefix string identifying the ImageNet tower.
+
+  Returns:
+    Logits. 2-D float Tensor.
+    Auxiliary Logits. 2-D float Tensor of side-head. Used for training only.
+  """
+  # Parameters for BatchNorm.
+  batch_norm_params = {
+      # Decay for the moving averages.
+      'decay': BATCHNORM_MOVING_AVERAGE_DECAY,
+      # epsilon to prevent 0s in variance.
+      'epsilon': 0.001,
+  }
+  # Set weight_decay for weights in Conv and FC layers.
+  with slim.arg_scope([slim.ops.conv2d, slim.ops.fc], weight_decay=0.00004):
+    with slim.arg_scope([slim.ops.conv2d],
+                        stddev=0.1,
+                        activation=tf.nn.relu,
+                        batch_norm_params=batch_norm_params):
+      # Force all Variables to reside on the CPU.
+      with slim.arg_scope([slim.variables.variable], device='/cpu:0'):
+        logits, endpoints = slim.inception.inception_v3(
+            images,
+            dropout_keep_prob=0.8,
+            num_classes=num_classes,
+            is_training=for_training,
+            restore_logits=restore_logits,
+            scope=scope)
+
+  # Add summaries for viewing model statistics on TensorBoard.
+  _activation_summaries(endpoints)
+
+  # Grab the logits associated with the side head. Employed during training.
+  auxiliary_logits = endpoints['aux_logits']
+
+  return logits, auxiliary_logits
+
+
+def loss(logits, labels, batch_size=None):
+  """Adds all losses for the model.
+
+  Note the final loss is not returned. Instead, the list of losses are collected
+  by slim.losses. The losses are accumulated in tower_loss() and summed to
+  calculate the total loss.
+
+  Args:
+    logits: List of logits from inference(). Each entry is a 2-D float Tensor.
+    labels: Labels from distorted_inputs or inputs(). 1-D tensor
+            of shape [batch_size]
+    batch_size: integer
+  """
+  if not batch_size:
+    batch_size = FLAGS.batch_size
+
+  # Reshape the labels into a dense Tensor of
+  # shape [FLAGS.batch_size, num_classes].
+  sparse_labels = tf.reshape(labels, [batch_size, 1])
+  indices = tf.reshape(tf.range(batch_size), [batch_size, 1])
+  concated = tf.concat(1, [indices, sparse_labels])
+  num_classes = logits[0].get_shape()[-1].value
+  dense_labels = tf.sparse_to_dense(concated,
+                                    [batch_size, num_classes],
+                                    1.0, 0.0)
+
+  # Cross entropy loss for the main softmax prediction.
+  slim.losses.cross_entropy_loss(logits[0],
+                                 dense_labels,
+                                 label_smoothing=0.1,
+                                 weight=1.0)
+
+  # Cross entropy loss for the auxiliary softmax head.
+  slim.losses.cross_entropy_loss(logits[1],
+                                 dense_labels,
+                                 label_smoothing=0.1,
+                                 weight=0.4,
+                                 scope='aux_loss')
+
+
+def _activation_summary(x):
+  """Helper to create summaries for activations.
+
+  Creates a summary that provides a histogram of activations.
+  Creates a summary that measure the sparsity of activations.
+
+  Args:
+    x: Tensor
+  """
+  # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training
+  # session. This helps the clarity of presentation on tensorboard.
+  tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)
+  tf.histogram_summary(tensor_name + '/activations', x)
+  tf.scalar_summary(tensor_name + '/sparsity', tf.nn.zero_fraction(x))
+
+
+def _activation_summaries(endpoints):
+  with tf.name_scope('summaries'):
+    for act in endpoints.values():
+      _activation_summary(act)

inception/slim/BUILD

+# Description:
+#   Contains the operations and nets for building TensorFlow-Slim models.
+
+package(default_visibility = ["//inception:internal"])
+
+licenses(["notice"])  # Apache 2.0
+
+exports_files(["LICENSE"])
+
+py_library(
+    name = "scopes",
+    srcs = ["scopes.py"],
+    deps = [
+        "@tf//tensorflow:tensorflow_py",
+    ],
+)
+
+py_test(
+    name = "scopes_test",
+    size = "small",
+    srcs = ["scopes_test.py"],
+    deps = [
+        ":scopes",
+    ],
+)
+
+py_library(
+    name = "variables",
+    srcs = ["variables.py"],
+    deps = [
+        "@tf//tensorflow:tensorflow_py",
+        ":scopes",
+    ],
+)
+
+py_test(
+    name = "variables_test",
+    size = "small",
+    srcs = ["variables_test.py"],
+    deps = [
+        ":variables",
+    ],
+)
+
+py_library(
+    name = "losses",
+    srcs = ["losses.py"],
+    deps = [
+        "@tf//tensorflow:tensorflow_py",
+    ],
+)
+
+py_test(
+    name = "losses_test",
+    size = "small",
+    srcs = ["losses_test.py"],
+    deps = [
+        ":losses",
+    ],
+)
+
+py_library(
+    name = "ops",
+    srcs = ["ops.py"],
+    deps = [
+        "@tf//tensorflow:tensorflow_py",
+        ":losses",
+        ":scopes",
+        ":variables",
+    ],
+)
+
+py_test(
+    name = "ops_test",
+    size = "small",
+    srcs = ["ops_test.py"],
+    deps = [
+        ":ops",
+        ":variables",
+    ],
+)
+
+py_library(
+    name = "inception",
+    srcs = ["inception_model.py"],
+    deps = [
+        "@tf//tensorflow:tensorflow_py",
+        ":ops",
+        ":scopes",
+    ],
+)
+
+py_test(
+    name = "inception_test",
+    size = "medium",
+    srcs = ["inception_test.py"],
+    deps = [
+        ":inception",
+    ],
+)
+
+py_library(
+    name = "slim",
+    srcs = ["slim.py"],
+    deps = [
+        ":inception",
+        ":losses",
+        ":ops",
+        ":scopes",
+        ":variables",
+    ],
+)

third_party

+tensorflow/third_party
\ No newline at end of file