用一个Inception v3 架构模型实现简单的迁移学习（译：../tensorflow/tensorflow/examples/image_retraining/retrain.py）

# Copyright 2015 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.
# ==============================================================================
"""用一个Inception v3 架构模型实现简单的迁移学习。
    这个例子展示了如何实现一个Inception v3架构模型，在ImageNet图片的训练，并且训练一层可以被别的物类识别的新顶层。
    顶层，对于每张图片可以接受输入2048-维向量。在此之上，我们训练一个软件层。假定软件层包含N个labels，这相应的需要
学习N+2048×N个模型参数，还有相应的学习偏差和权重。
    这里有一个例子，假设你有一个文件夹包含类名子文件夹，每一个子文件夹标签包含照片。例子文件夹flower_photos应该是
这样的结构：
~/flower_photos/daisy/photo1.jpg
~/flower_photos/daisy/photo2.jpg
...
~/flower_photos/rose/anotherphoto77.jpg
...
~/flower_photos/sunflower/somepicture.jpg
    子文件夹的命名是好非常重要的，一旦他们被定义，那么类别的标签就会被应用到该子文件夹里的每张照片，但是照片本身的名字可以
随便。如果你准备好了照片，你可以开始进行训练，使用这些命令：
bazel build third_party/tensorflow/examples/image_retraining:retrain && \
bazel-bin/third_party/tensorflow/examples/image_retraining/retrain \
--image_dir ~/flower_photos
    你可以替换image_dir参数，使用任意的文件夹，只要包含子文件夹，且子文件夹里包含照片。对应每张照片的标签是子文件夹的名字。
    这样产生的新模型文件可以被任意的Tensorflow程序加载和执行，例如label_iamge的代码。
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from datetime import datetime
import glob
import hashlib
import os.path
import random
import re
import sys
import tarfile

import numpy as np
from six.moves import urllib
import tensorflow as tf

from tensorflow.python.client import graph_util
from tensorflow.python.framework import tensor_shape
from tensorflow.python.platform import gfile


FLAGS = tf.app.flags.FLAGS

# 输入和输出文件标志
tf.app.flags.DEFINE_string('image_dir', '',
                           """图片文件夹的路径。""")
tf.app.flags.DEFINE_string('output_graph', '/tmp/output_graph.pb',
                           """训练图表保存到哪里？""")
tf.app.flags.DEFINE_string('output_labels', '/tmp/output_labels.txt',
                           """训练图表的标签保存到哪里？""")

# 详细的训练配置
tf.app.flags.DEFINE_integer('how_many_training_steps', 4000,
                            """在结束之前，需要训练多少步？""")
tf.app.flags.DEFINE_float('learning_rate', 0.01,
                          """在训练的时候设置多大的学习率？""")
tf.app.flags.DEFINE_integer(
    'testing_percentage', 10,
    """图片用于测试的百分比""")
tf.app.flags.DEFINE_integer(
    'validation_percentage', 10,
    """图片用于检定的百分比""")
tf.app.flags.DEFINE_integer('eval_step_interval', 10,
                            """评估培训结果的频率？""")
tf.app.flags.DEFINE_integer('train_batch_size', 100,
                            """一次训练多少张照片？""")
tf.app.flags.DEFINE_integer('test_batch_size', 500,
                            """一次测试多少张照片？"""
                            """这个测试集只使用很少来验证"""
                            """模型的整体精度。""")
tf.app.flags.DEFINE_integer(
    'validation_batch_size', 100,
    """有多少图片在一个评估批量使用。这个验证集"""
    """被使用的频率比测试集多, 这也是一个早期的指标"""
    """模型有多精确在训练期间。""")

# 文件系统cache所在目录
tf.app.flags.DEFINE_string('model_dir', '/tmp/imagenet',
                           """classify_image_graph_def.pb，"""
                           """imagenet_synset_to_human_label_map.txt, and """
                           """imagenet_2012_challenge_label_map_proto.pbtxt的路径。""")
tf.app.flags.DEFINE_string(
    'bottleneck_dir', '/tmp/bottleneck',
    """cache bottleneck 层作为值的文件集。""")
tf.app.flags.DEFINE_string('final_tensor_name', 'final_result',
                           """分类输出层的名称"""
                           """在重新训练时。""")

# 控制扭曲参数在训练期间
tf.app.flags.DEFINE_boolean(
    'flip_left_right', False,
    """是否随机对半水平翻转训练图片。""")
tf.app.flags.DEFINE_integer(
    'random_crop', 0,
    """A percentage determining how much of a margin to randomly crop off the"""
    """ training images.""")
tf.app.flags.DEFINE_integer(
    'random_scale', 0,
    """A percentage determining how much to randomly scale up the size of the"""
    """ training images by.""")
tf.app.flags.DEFINE_integer(
    'random_brightness', 0,
    """A percentage determining how much to randomly multiply the training"""
    """ image input pixels up or down by.""")

# 这些都是参数绑定到特定的模型架构
# 我们使用的Inceptionv3。这些包括张量名称及其大小。
# 如果你想适应这个脚本使用到另一个模型,您将需要更新这些反映网络中使用的值。
# pylint: disable=line-too-long
DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'
# pylint: enable=line-too-long
BOTTLENECK_TENSOR_NAME = 'pool_3/_reshape:0'
BOTTLENECK_TENSOR_SIZE = 2048
MODEL_INPUT_WIDTH = 299
MODEL_INPUT_HEIGHT = 299
MODEL_INPUT_DEPTH = 3
JPEG_DATA_TENSOR_NAME = 'DecodeJpeg/contents:0'
RESIZED_INPUT_TENSOR_NAME = 'ResizeBilinear:0'


def create_image_lists(image_dir, testing_percentage, validation_percentage):
    """建立训练图像的文件系统的列表。
    分析了图像中的子文件夹目录,分裂成稳定的训练、测试和验证集,并返回一个数据结构来描述图像的列表为每个标签及其路径。
    Args:
    image_dir:字符串路径文件夹包含图片的子文件夹。
    testing_percentage:图像的整数百分比保留给测试。
    validation_percentage:图像的整数百分比保留给校正。

    Return:一个文件夹包含每个子文件夹入口标签，伴随着图片被分成training，testing和validation集
"""
  if not gfile.Exists(image_dir):
    print("Image directory '" + image_dir + "' not found.")
    return None
  result = {}
  sub_dirs = [x[0] for x in os.walk(image_dir)]
  # The root directory comes first, so skip it.
  is_root_dir = True
  for sub_dir in sub_dirs:
    if is_root_dir:
      is_root_dir = False
      continue
    extensions = ['jpg', 'jpeg', 'JPG', 'JPEG']
    file_list = []
    dir_name = os.path.basename(sub_dir)
    if dir_name == image_dir:
      continue
    print("Looking for images in '" + dir_name + "'")
    for extension in extensions:
      file_glob = os.path.join(image_dir, dir_name, '*.' + extension)
      file_list.extend(glob.glob(file_glob))
    if not file_list:
      print('No files found')
      continue
    if len(file_list) < 20:
      print('WARNING: Folder has less than 20 images, which may cause issues.')
    label_name = re.sub(r'[^a-z0-9]+', ' ', dir_name.lower())
    training_images = []
    testing_images = []
    validation_images = []
    for file_name in file_list:
      base_name = os.path.basename(file_name)
    #我们想要忽略任何东西在'_nohash_'的文件名称,当决定将把一个图像,
    数据集的创造者的分组照片接近彼此的变化。例如这是用于植物病害数据设置为组的多个图片相同的叶子。
      hash_name = re.sub(r'_nohash_.*$', '', file_name)
    #这看起来有点不可思议,但是我们需要决定这文件是否应该被写入training，testing或者validation集，并且
        我们希望保持现有的文件在同一组即使随后制造更多的文件。
        我们需要一个稳定的方式决定基于文件名本身,所以我们做一个散列,然后用它来生成一个概率值,我们使用分配它。
      hash_name_hashed = hashlib.sha1(hash_name.encode('utf-8')).hexdigest()
      percentage_hash = (int(hash_name_hashed, 16) % (65536)) * (100 / 65535.0)
      if percentage_hash < validation_percentage:
        validation_images.append(base_name)
      elif percentage_hash < (testing_percentage + validation_percentage):
        testing_images.append(base_name)
      else:
        training_images.append(base_name)
    result[label_name] = {
        'dir': dir_name,
        'training': training_images,
        'testing': testing_images,
        'validation': validation_images,
    }
  return result

def get_image_path(image_lists, label_name, index, image_dir, category):
    """返回一个路径为一个标签图像给定索引。

    Args:
    image_lists:每一个标签的训练图片字典。
    label_name:我们想要一个图像标签字符串。
    index:我们想要的图片偏移值，这会被取模通过图片label的有效值，所以它的意义重大。
    image_dir:根目录包含子目录字符，里面包含训练照片。
    category：名称字符串设置将图像从培训,测试,或验证获取。
    Return：
    文件系统路径字符串满足图像请求的参数。
"""

  if label_name not in image_lists:
    tf.logging.fatal('Label does not exist %s.', label_name)
  label_lists = image_lists[label_name]
  if category not in label_lists:
    tf.logging.fatal('Category does not exist %s.', category)
  category_list = label_lists[category]
  if not category_list:
    tf.logging.fatal('Category has no images - %s.', category)
  mod_index = index % len(category_list)
  base_name = category_list[mod_index]
  sub_dir = label_lists['dir']
  full_path = os.path.join(image_dir, sub_dir, base_name)
  return full_path

def get_bottleneck_path(image_lists, label_name, index, bottleneck_dir,
                        category):
    """在给定的索引标签，返回一个路径给一个bottleneck文件。
    Asgs：
    image_lists:每一个标签的训练图片字典。
    label_name:我们想要一个图像标签字符串。
    index:我们想要的图片偏移值，这会被取模通过图片label的有效值，所以它的意义重大。
        bottleneck:bottleneck值的缓存字符文件夹
    image_dir:根目录包含子目录字符，里面包含训练照片。
    category：名称字符串设置将图像从培训,测试,或验证获取。
    Returns:
    符合要求的参数照片的文件系统路径字符
    """
  return get_image_path(image_lists, label_name, index, bottleneck_dir,
                        category) + '.txt'

def create_inception_graph():
    """从保存的GraphDef文件创建一个图形，然后返回一个图形对象。
    Returns：
    包含已经训练过的Inception网络图形，和各种各样的tensors，我们将要控制的。
"""
  with tf.Session() as sess:
    model_filename = os.path.join(
        FLAGS.model_dir, 'classify_image_graph_def.pb')
    with gfile.FastGFile(model_filename, 'rb') as f:
      graph_def = tf.GraphDef()
      graph_def.ParseFromString(f.read())
      bottleneck_tensor, jpeg_data_tensor, resized_input_tensor = (
          tf.import_graph_def(graph_def, name='', return_elements=[
              BOTTLENECK_TENSOR_NAME, JPEG_DATA_TENSOR_NAME,
              RESIZED_INPUT_TENSOR_NAME]))
  return sess.graph, bottleneck_tensor, jpeg_data_tensor, resized_input_tensor


def run_bottleneck_on_image(sess, image_data, image_data_tensor,
                            bottleneck_tensor):
    """在一张照片运行推断提取'bottleneck'简要层
    Args:
    sess: 当前活跃的Tensorflow Session
    image_data: 图片数据的Numpy矩阵
    image_data_tensor: 在图表中的输入数据层
    bottleneck_tensor: 在最后软件层之前的层

  Returns:
    bottleneck值的Numpy矩阵。
  """
  bottleneck_values = sess.run(
      bottleneck_tensor,
      {image_data_tensor: image_data})
  bottleneck_values = np.squeeze(bottleneck_values)
  return bottleneck_values


def maybe_download_and_extract():
    """下载和解压模型的tar文件
    如果在重新训练模型之前，我们使用的不存在，这个函数会从Tensorflow.org网站下载，然后解压它到一个文件夹。
"""
  dest_directory = FLAGS.model_dir
  if not os.path.exists(dest_directory):
    os.makedirs(dest_directory)
  filename = DATA_URL.split('/')[-1]
  filepath = os.path.join(dest_directory, filename)
  if not os.path.exists(filepath):

    def _progress(count, block_size, total_size):
      sys.stdout.write('\r>> Downloading %s %.1f%%' %
                       (filename,
                        float(count * block_size) / float(total_size) * 100.0))
      sys.stdout.flush()

    filepath, _ = urllib.request.urlretrieve(DATA_URL,
                                             filepath,
                                             reporthook=_progress)
    print()
    statinfo = os.stat(filepath)
    print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')
  tarfile.open(filepath, 'r:gz').extractall(dest_directory)


def ensure_dir_exists(dir_name):
  """确保文件夹在硬盘里存在。

  Args:
    dir_name: 我们想要创建的路径字符文件夹
  """
  if not os.path.exists(dir_name):
    os.makedirs(dir_name)


def get_or_create_bottleneck(sess, image_lists, label_name, index, image_dir,
                             category, bottleneck_dir, jpeg_data_tensor,
                             bottleneck_tensor):
  """重新找回或者计算一张照片的bottleneck值

  如果在硬盘上存在一个cached的版本，放回它，否则计算值并保存到硬盘，供下次使用。

  Args:
    sess: 当前活跃的Tensorflow Session
    image_lists: 每一个标签的训练图片字典。
    label_name: 我们想要一个图像标签字符串。
    index:我们想要的图片偏移值，这会被取模通过图片label的有效值，所以它的意义重大。。
    category：名称字符串设置将图像从培训,测试,或验证获取。
    bottleneck_dir: 包含bottleneck值的缓存文件夹字符。
    jpeg_data_tensor: 获取加载jpeg数据进入tensor。
    bottleneck_tensor: bottleneck值的输出tensor。

  Returns:
    为一张图片而长生的Numpy矩阵值，在bottleneck层。
  """
  label_lists = image_lists[label_name]
  sub_dir = label_lists['dir']
  sub_dir_path = os.path.join(bottleneck_dir, sub_dir)
  ensure_dir_exists(sub_dir_path)
  bottleneck_path = get_bottleneck_path(image_lists, label_name, index,
                                        bottleneck_dir, category)
  if not os.path.exists(bottleneck_path):
    print('Creating bottleneck at ' + bottleneck_path)
    image_path = get_image_path(image_lists, label_name, index, image_dir,
                                category)
    if not gfile.Exists(image_path):
      tf.logging.fatal('File does not exist %s', image_path)
    image_data = gfile.FastGFile(image_path, 'rb').read()
    bottleneck_values = run_bottleneck_on_image(sess, image_data,
                                                jpeg_data_tensor,
                                                bottleneck_tensor)
    bottleneck_string = ','.join(str(x) for x in bottleneck_values)
    with open(bottleneck_path, 'w') as bottleneck_file:
      bottleneck_file.write(bottleneck_string)

  with open(bottleneck_path, 'r') as bottleneck_file:
    bottleneck_string = bottleneck_file.read()
  bottleneck_values = [float(x) for x in bottleneck_string.split(',')]
  return bottleneck_values


def cache_bottlenecks(sess, image_lists, image_dir, bottleneck_dir,
                      jpeg_data_tensor, bottleneck_tensor):
  """保证所有的training，testing和validation的bottleneck都缓存完毕。
  因为我们可能会读取同一张照片很多次（如果在训练的时候没有运用扭曲）它可以加快速度很多，如果我们为每个图像计算bottleneck值一次在预处理层
然后在训练的时候反复地只读这些缓存值。这我们就完成了所有我们发现的所有照片，计算这些值，然后保存他们。

  Args:
    sess: 当前活跃的Tensorflow Session
    image_lists: 每一个标签的训练图片字典。
    image_dir:根目录包含子目录字符，里面包含训练照片。
    bottleneck_dir: 包含bottleneck值的缓存文件夹字符。
    jpeg_data_tensor: 获取加载jpeg数据进入tensor。
    bottleneck_tensor: 倒数第二输出层的图。

  Returns:
    无
  """
  how_many_bottlenecks = 0
  ensure_dir_exists(bottleneck_dir)
  for label_name, label_lists in image_lists.items():
    for category in ['training', 'testing', 'validation']:
      category_list = label_lists[category]
      for index, unused_base_name in enumerate(category_list):
        get_or_create_bottleneck(sess, image_lists, label_name, index,
                                 image_dir, category, bottleneck_dir,
                                 jpeg_data_tensor, bottleneck_tensor)
        how_many_bottlenecks += 1
        if how_many_bottlenecks % 100 == 0:
          print(str(how_many_bottlenecks) + ' bottleneck files created.')


def get_random_cached_bottlenecks(sess, image_lists, how_many, category,
                                  bottleneck_dir, image_dir, jpeg_data_tensor,
                                  bottleneck_tensor):
  """重新得到为缓存图片获得bottleneck值

  如果没有应用扭曲，这函数能够重新得到缓存bottleneck的值，直接从硬盘。它挑选一组随机的照片
从特定类别。

  Args:
    sess: 当前活跃的Tensorflow Session
    image_lists: 每一个标签的训练图片字典。
    how_many: 返回bottleneck值的数量
    category: 名称字符串设置将图像从培训,测试,或验证获取。
    bottleneck_dir: 包含bottleneck值的缓存文件夹字符。
    image_dir: 根目录包含子目录字符，里面包含训练照片。
    jpeg_data_tensor: 获取加载jpeg数据进入tensor。
    bottleneck_tensor: 倒数第二输出层的CNN图。

  Returns:
    bottleneck列表和他们相应的ground truthes.
  """
  class_count = len(image_lists.keys())
  bottlenecks = []
  ground_truthes = []
  for unused_i in range(how_many):
    label_index = random.randrange(class_count)
    label_name = list(image_lists.keys())[label_index]
    image_index = random.randrange(65536)
    bottleneck = get_or_create_bottleneck(sess, image_lists, label_name,
                                          image_index, image_dir, category,
                                          bottleneck_dir, jpeg_data_tensor,
                                          bottleneck_tensor)
    ground_truth = np.zeros(class_count, dtype=np.float32)
    ground_truth[label_index] = 1.0
    bottlenecks.append(bottleneck)
    ground_truthes.append(ground_truth)
  return bottlenecks, ground_truthes


def get_random_distorted_bottlenecks(
    sess, image_lists, how_many, category, image_dir, input_jpeg_tensor,
    distorted_image, resized_input_tensor, bottleneck_tensor):
  """扭曲之后，为训练的照片重新获得bottleneck的值。

  如果我们训练使用扭曲，例如修剪，缩放，翻转，我们不得不重新计算整个模型的每张照片，所以我们不能用缓存里bottleneck的
值。相反，我们为请求类别寻找随机照片，通过扭曲的图表来执行，然后整个图表为每个获得bottleneck结果。

  Args:
    sess: 当前活跃的Tensorflow Session
    image_lists: 每一个标签的训练图片字典。
    how_many: 返回bottleneck值的数量
    category: 名称字符串设置将图像从培训,测试,或验证获取。
    image_dir: 根目录包含子目录字符，里面包含训练照片。
    input_jpeg_tensor: 我们输入图片数据的输入层。
    distorted_image: 输出节点的扭曲图表
    resized_input_tensor: 输入节点的识别图表。
    bottleneck_tensor: 倒数第二输出层的CNN图。

  Returns:
    bottleneck列表和他们相应的ground truthes.
  """
  class_count = len(image_lists.keys())
  bottlenecks = []
  ground_truthes = []
  for unused_i in range(how_many):
    label_index = random.randrange(class_count)
    label_name = image_lists.keys()[label_index]
    image_index = random.randrange(65536)
    image_path = get_image_path(image_lists, label_name, image_index, image_dir,
                                category)
    if not gfile.Exists(image_path):
      tf.logging.fatal('File does not exist %s', image_path)
    jpeg_data = gfile.FastGFile(image_path, 'r').read()
    # 注意,我们实现distorted_image_data作为numpy矩阵在
    # 发送运行推理的形象之前。
    # 这涉及到两次内存拷贝和可能在其他实现优化。
    distorted_image_data = sess.run(distorted_image,
                                    {input_jpeg_tensor: jpeg_data})
    bottleneck = run_bottleneck_on_image(sess, distorted_image_data,
                                         resized_input_tensor,
                                         bottleneck_tensor)
    ground_truth = np.zeros(class_count, dtype=np.float32)
    ground_truth[label_index] = 1.0
    bottlenecks.append(bottleneck)
    ground_truthes.append(ground_truth)
  return bottlenecks, ground_truthes


def should_distort_images(flip_left_right, random_crop, random_scale,
                          random_brightness):
  """是否启用了扭曲,从输入标志。

  Args:
    flip_left_right: Boolean是否随机水平反应图片。
    random_crop: 整数百分比设置使用总利润在裁剪盒子。
    random_scale: 改变规模的整数百分比是多少
    random_brightness: 整数范围内随机乘以像素的值。

  Returns:
    Boolean值表明，是否有扭曲的值需要被应用。
  """
  return (flip_left_right or (random_crop != 0) or (random_scale != 0) or
          (random_brightness != 0))


def add_input_distortions(flip_left_right, random_crop, random_scale,
                          random_brightness):
  """创建操作来应用规定的扭曲。

  在训练的时候，可以帮助改善结果，如果我们运行图片通过简单扭曲，例如修剪，缩放，翻转。
这些反映这种变化是我们在现实世界所期待的，所以可以帮助训练模型，更高效地应对自然的数据。
这里我们提供参数和构造一个操作网络在一张照片应用他们。

  Cropping
  ~~~~~~~~

  Cropping is done by placing a bounding box at a random position in the full
  image. The cropping parameter controls the size of that box relative to the
  input image. If it's zero, then the box is the same size as the input and no
  cropping is performed. If the value is 50%, then the crop box will be half the
  width and height of the input. In a diagram it looks like this:

  <       width         >
  +---------------------+
  |                     |
  |   width - crop%     |
  |    <      >         |
  |    +------+         |
  |    |      |         |
  |    |      |         |
  |    |      |         |
  |    +------+         |
  |                     |
  |                     |
  +---------------------+

  Scaling
  ~~~~~~~

  Scaling is a lot like cropping, except that the bounding box is always
  centered and its size varies randomly within the given range. For example if
  the scale percentage is zero, then the bounding box is the same size as the
  input and no scaling is applied. If it's 50%, then the bounding box will be in
  a random range between half the width and height and full size.

  Args:
    flip_left_right: Boolean是否随机水平反应图片。
    random_crop: 整数百分比设置使用总利润在裁剪盒子。
    random_scale: 改变规模的整数百分比是多少
    random_brightness: 整数范围内随机乘以像素的值。

  Returns:
    jpeg的输入层和扭曲最后的tensor。
  """
  jpeg_data = tf.placeholder(tf.string, name='DistortJPGInput')
  decoded_image = tf.image.decode_jpeg(jpeg_data)
  decoded_image_as_float = tf.cast(decoded_image, dtype=tf.float32)
  decoded_image_4d = tf.expand_dims(decoded_image_as_float, 0)
  margin_scale = 1.0 + (random_crop / 100.0)
  resize_scale = 1.0 + (random_scale / 100.0)
  margin_scale_value = tf.constant(margin_scale)
  resize_scale_value = tf.random_uniform(tensor_shape.scalar(),
                                         minval=1.0,
                                         maxval=resize_scale)
  scale_value = tf.mul(margin_scale_value, resize_scale_value)
  precrop_width = tf.mul(scale_value, MODEL_INPUT_WIDTH)
  precrop_height = tf.mul(scale_value, MODEL_INPUT_HEIGHT)
  precrop_shape = tf.pack([precrop_height, precrop_width])
  precrop_shape_as_int = tf.cast(precrop_shape, dtype=tf.int32)
  precropped_image = tf.image.resize_bilinear(decoded_image_4d,
                                              precrop_shape_as_int)
  precropped_image_3d = tf.squeeze(precropped_image, squeeze_dims=[0])
  cropped_image = tf.random_crop(precropped_image_3d,
                                 [MODEL_INPUT_HEIGHT, MODEL_INPUT_WIDTH,
                                  MODEL_INPUT_DEPTH])
  if flip_left_right:
    flipped_image = tf.image.random_flip_left_right(cropped_image)
  else:
    flipped_image = cropped_image
  brightness_min = 1.0 - (random_brightness / 100.0)
  brightness_max = 1.0 + (random_brightness / 100.0)
  brightness_value = tf.random_uniform(tensor_shape.scalar(),
                                       minval=brightness_min,
                                       maxval=brightness_max)
  brightened_image = tf.mul(flipped_image, brightness_value)
  distort_result = tf.expand_dims(brightened_image, 0, name='DistortResult')
  return jpeg_data, distort_result


def add_final_training_ops(class_count, final_tensor_name, bottleneck_tensor):
  """加一新的软件层和全连接层给训练。

  我们需要重新训练最顶层来识别你的新类别，所以这个函数加了正确的操作给图表，伴随着一些可变参数
来权重，然后设置所有的梯度为向后传递。 
  设置为SOFTMAX和全连接层是基于：
  https://tensorflow.org/versions/master/tutorials/mnist/beginners/index.html

  Args:
    class_count: 整数，多少类别的物体我们想要识别。
    final_tensor_name: 用于生成结果的新的最终节点的名称字符串。
    bottleneck_tensor: 输出的主CNN图表。

  Returns:
    为训练和交叉熵的结果张量，和bottleneck的tensor的输入和ground truth的输入。
  """
  bottleneck_input = tf.placeholder_with_default(
      bottleneck_tensor, shape=[None, BOTTLENECK_TENSOR_SIZE],
      name='BottleneckInputPlaceholder')
  layer_weights = tf.Variable(
      tf.truncated_normal([BOTTLENECK_TENSOR_SIZE, class_count], stddev=0.001),
      name='final_weights')
  layer_biases = tf.Variable(tf.zeros([class_count]), name='final_biases')
  logits = tf.matmul(bottleneck_input, layer_weights,
                     name='final_matmul') + layer_biases
  final_tensor = tf.nn.softmax(logits, name=final_tensor_name)
  ground_truth_input = tf.placeholder(tf.float32,
                                      [None, class_count],
                                      name='GroundTruthInput')
  cross_entropy = tf.nn.softmax_cross_entropy_with_logits(
      logits, ground_truth_input)
  cross_entropy_mean = tf.reduce_mean(cross_entropy)
  train_step = tf.train.GradientDescentOptimizer(FLAGS.learning_rate).minimize(
      cross_entropy_mean)
  return (train_step, cross_entropy_mean, bottleneck_input, ground_truth_input,
          final_tensor)


def add_evaluation_step(result_tensor, ground_truth_tensor):
  """插入操作，我们需要评估我们的结果的准确性。 
  Args:
    result_tensor: 产生结果的新的最终节点。
    ground_truth_tensor: 我们feed ground truth数据进去节点。

  Returns:
    无
  """
  correct_prediction = tf.equal(
      tf.argmax(result_tensor, 1), tf.argmax(ground_truth_tensor, 1))
  evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
  return evaluation_step


def main(_):
  # 建立预训练图。 
  maybe_download_and_extract()
  graph, bottleneck_tensor, jpeg_data_tensor, resized_image_tensor = (
      create_inception_graph())

  # 查看文件夹结构，并创建所有图像的列表。 
  image_lists = create_image_lists(FLAGS.image_dir, FLAGS.testing_percentage,
                                   FLAGS.validation_percentage)
  class_count = len(image_lists.keys())
  if class_count == 0:
    print('No valid folders of images found at ' + FLAGS.image_dir)
    return -1
  if class_count == 1:
    print('Only one valid folder of images found at ' + FLAGS.image_dir +
          ' - multiple classes are needed for classification.')
    return -1

  # 看看这个命令行标志意味着我们使用任意扭曲。 
  do_distort_images = should_distort_images(
      FLAGS.flip_left_right, FLAGS.random_crop, FLAGS.random_scale,
      FLAGS.random_brightness)
  sess = tf.Session()

  if do_distort_images:
    # 我们将运用扭曲，所以我们需要设置操作。
    distorted_jpeg_data_tensor, distorted_image_tensor = add_input_distortions(
        FLAGS.flip_left_right, FLAGS.random_crop, FLAGS.random_scale,
        FLAGS.random_brightness)
  else:
    # 我们将确保我们已经计算了'bottleneck'图像摘要和缓存
    cache_bottlenecks(sess, image_lists, FLAGS.image_dir, FLAGS.bottleneck_dir,
                      jpeg_data_tensor, bottleneck_tensor)

  # 添加新的层，我们将训练。 
  (train_step, cross_entropy, bottleneck_input, ground_truth_input,
   final_tensor) = add_final_training_ops(len(image_lists.keys()),
                                          FLAGS.final_tensor_name,
                                          bottleneck_tensor)

  # 将所有的权重设置为初始默认值。 
  init = tf.initialize_all_variables()
  sess.run(init)

  # 创建操作，我们需要评估我们的新层的准确性。
  evaluation_step = add_evaluation_step(final_tensor, ground_truth_input)

  # 运行在命令行上的要求的许多周期的训练。 
  for i in range(FLAGS.how_many_training_steps):
    #获取一个输入bottleneck值，要么计算新的值每一次，或者从存储在硬盘的缓存获得。
    if do_distort_images:
      train_bottlenecks, train_ground_truth = get_random_distorted_bottlenecks(
          sess, image_lists, FLAGS.train_batch_size, 'training',
          FLAGS.image_dir, distorted_jpeg_data_tensor,
          distorted_image_tensor, resized_image_tensor, bottleneck_tensor)
    else:
      train_bottlenecks, train_ground_truth = get_random_cached_bottlenecks(
          sess, image_lists, FLAGS.train_batch_size, 'training',
          FLAGS.bottleneck_dir, FLAGS.image_dir, jpeg_data_tensor,
          bottleneck_tensor)
    # Feed的bottlenecks和ground truth 到图表，并且运行一个训练步骤。
    sess.run(train_step,
             feed_dict={bottleneck_input: train_bottlenecks,
                        ground_truth_input: train_ground_truth})
    # 每一个如此，打印出有多么好的图形训练。 
    is_last_step = (i + 1 == FLAGS.how_many_training_steps)
    if (i % FLAGS.eval_step_interval) == 0 or is_last_step:
      train_accuracy, cross_entropy_value = sess.run(
          [evaluation_step, cross_entropy],
          feed_dict={bottleneck_input: train_bottlenecks,
                     ground_truth_input: train_ground_truth})
      print('%s: Step %d: Train accuracy = %.1f%%' % (datetime.now(), i,
                                                      train_accuracy * 100))
      print('%s: Step %d: Cross entropy = %f' % (datetime.now(), i,
                                                 cross_entropy_value))
      validation_bottlenecks, validation_ground_truth = (
          get_random_cached_bottlenecks(
              sess, image_lists, FLAGS.validation_batch_size, 'validation',
              FLAGS.bottleneck_dir, FLAGS.image_dir, jpeg_data_tensor,
              bottleneck_tensor))
      validation_accuracy = sess.run(
          evaluation_step,
          feed_dict={bottleneck_input: validation_bottlenecks,
                     ground_truth_input: validation_ground_truth})
      print('%s: Step %d: Validation accuracy = %.1f%%' %
            (datetime.now(), i, validation_accuracy * 100))

  # 我们已经完成了所有的训练，所以在一些新的测试中运行了最后的测试评估 
  test_bottlenecks, test_ground_truth = get_random_cached_bottlenecks(
      sess, image_lists, FLAGS.test_batch_size, 'testing',
      FLAGS.bottleneck_dir, FLAGS.image_dir, jpeg_data_tensor,
      bottleneck_tensor)
  test_accuracy = sess.run(
      evaluation_step,
      feed_dict={bottleneck_input: test_bottlenecks,
                 ground_truth_input: test_ground_truth})
  print('Final test accuracy = %.1f%%' % (test_accuracy * 100))

  # 把训练的图表和标签与存储为常量的权重。 
  output_graph_def = graph_util.convert_variables_to_constants(
      sess, graph.as_graph_def(), [FLAGS.final_tensor_name])
  with gfile.FastGFile(FLAGS.output_graph, 'wb') as f:
    f.write(output_graph_def.SerializeToString())
  with gfile.FastGFile(FLAGS.output_labels, 'w') as f:
    f.write('\n'.join(image_lists.keys()) + '\n')


if __name__ == '__main__':
  tf.app.run()

#英语能力有限，哈哈，原文链接：https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/image_retraining/retrain.py

    由于时间的原因，我在编译完3的时候被我切断了。四组图片28*28的，每组6000张左右，设置train：validation：test = 4：1：1。编译的照片在TRAINIMAGE，运行的照片在VALIDATEIMAGE，训练了两天半（56个小时）。最后的识别结果如下：
    1、编译0,1,2,3。
user01@user01-forfish:~/Documents/tensorflow$ bazel-bin/tensorflow/examples/image_retraining/retrain --image_dir ~/FISHMNIST2/TRAINIMAGE/
Looking for images in '1'
Looking for images in '0'
Looking for images in '3'
Looking for images in '2'
100 bottleneck files created.
200 bottleneck files created.
300 bottleneck files created.
400 bottleneck files created.
............
24300 bottleneck files created.
24400 bottleneck files created.
24500 bottleneck files created.
24600 bottleneck files created.
24700 bottleneck files created.
2016-04-07 16:03:35.848447: Step 0: Train accuracy = 56.0%
2016-04-07 16:03:35.848516: Step 0: Cross entropy = 1.286888
2016-04-07 16:03:36.059755: Step 0: Validation accuracy = 35.0%
2016-04-07 16:03:37.677323: Step 10: Train accuracy = 92.0%
2016-04-07 16:03:37.677392: Step 10: Cross entropy = 0.810003
2016-04-07 16:03:37.817034: Step 10: Validation accuracy = 84.0%
2016-04-07 16:03:39.249091: Step 20: Train accuracy = 93.0%
2016-04-07 16:03:39.249168: Step 20: Cross entropy = 0.611544
............
2016-04-07 16:07:54.362384: Step 3980: Validation accuracy = 99.0%
2016-04-07 16:07:54.905122: Step 3990: Train accuracy = 100.0%
2016-04-07 16:07:54.905188: Step 3990: Cross entropy = 0.028465
2016-04-07 16:07:54.954875: Step 3990: Validation accuracy = 99.0%
2016-04-07 16:07:55.431090: Step 3999: Train accuracy = 100.0%
2016-04-07 16:07:55.431152: Step 3999: Cross entropy = 0.044311
2016-04-07 16:07:55.480975: Step 3999: Validation accuracy = 97.0%
Final test accuracy = 99.0%
Converted 2 variables to const ops.

    2、使用以上的编译结果。
        （1）识别手写0：
user01@user01-forfish:~/Documents/tensorflow$ bazel build tensorflow/examples/label_image:label_image && \
> bazel-bin/tensorflow/examples/label_image/label_image \
> --graph=/tmp/output_graph.pb --labels=/tmp/output_labels.txt \
> --output_layer=final_result \
> --image=$HOME/FISHMNIST2/VALIDATEIMAGE/0/MUSIC-1383.jpg
..............
INFO: Found 1 target...
Target //tensorflow/examples/label_image:label_image up-to-date:
  bazel-bin/tensorflow/examples/label_image/label_image
INFO: Elapsed time: 42.557s, Critical Path: 23.00s
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in
............
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
I tensorflow/examples/label_image/main.cc:207] 0 (1): 0.999816
I tensorflow/examples/label_image/main.cc:207] 2 (3): 0.000103101
I tensorflow/examples/label_image/main.cc:207] 3 (2): 7.5385e-05
I tensorflow/examples/label_image/main.cc:207] 1 (0): 5.35907e-06

        （2）识别手写1：
user01@user01-forfish:~/Documents/tensorflow$ bazel build tensorflow/examples/label_image:label_image && bazel-bin/tensorflow/examples/label_image/label_image --graph=/tmp/output_graph.pb --labels=/tmp/output_labels.txt --output_layer=final_result --image=$HOME/FISHMNIST2/VALIDATEIMAGE/1/JAVA-10000.jpg
INFO: Found 1 target...
Target //tensorflow/examples/label_image:label_image up-to-date:
  bazel-bin/tensorflow/examples/label_image/label_image
INFO: Elapsed time: 0.196s, Critical Path: 0.00s
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in
............
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
I tensorflow/examples/label_image/main.cc:207] 1 (0): 0.999564
I tensorflow/examples/label_image/main.cc:207] 2 (3): 0.000373375
I tensorflow/examples/label_image/main.cc:207] 3 (2): 4.03145e-05
I tensorflow/examples/label_image/main.cc:207] 0 (1): 2.2671e-05


        （2）识别手写2：
user01@user01-forfish:~/Documents/tensorflow$ bazel build tensorflow/examples/label_image:label_image && bazel-bin/tensorflow/examples/label_image/label_image --graph=/tmp/output_graph.pb --labels=/tmp/output_labels.txt --output_layer=final_result --image=$HOME/FISHMNIST2/VALIDATEIMAGE/2/CHUAN-10006.jpg
INFO: Found 1 target...
Target //tensorflow/examples/label_image:label_image up-to-date:
  bazel-bin/tensorflow/examples/label_image/label_image
INFO: Elapsed time: 0.146s, Critical Path: 0.00s
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
............
GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
I tensorflow/examples/label_image/main.cc:207] 2 (3): 0.99146
I tensorflow/examples/label_image/main.cc:207] 3 (2): 0.00433606
I tensorflow/examples/label_image/main.cc:207] 1 (0): 0.00381229
I tensorflow/examples/label_image/main.cc:207] 0 (1): 0.000391908


        （3）识别手写3：
user01@user01-forfish:~/Documents/tensorflow$ bazel build tensorflow/examples/label_image:label_image && bazel-bin/tensorflow/examples/label_image/label_image --graph=/tmp/output_graph.pb --labels=/tmp/output_labels.txt --output_layer=final_result --image=$HOME/FISHMNIST2/VALIDATEIMAGE/3/YAHOO-1089.jpg
INFO: Found 1 target...
Target //tensorflow/examples/label_image:label_image up-to-date:
  bazel-bin/tensorflow/examples/label_image/label_image
INFO: Elapsed time: 0.121s, Critical Path: 0.00s
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in
............
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
W tensorflow/core/kernels/batch_norm_op.cc:36] Op is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
I tensorflow/examples/label_image/main.cc:207] 3 (2): 0.99796
I tensorflow/examples/label_image/main.cc:207] 2 (3): 0.00196124
I tensorflow/examples/label_image/main.cc:207] 0 (1): 5.19803e-05
I tensorflow/examples/label_image/main.cc:207] 1 (0): 2.67401e-05

    识别率还是蛮高的。