win10安装tensorflow object_detection API

环境：

• win10
• Anaconda3.6
• tensorflow-gpu==1.9.0
• CUDA7 + cudnn9

安装：

1. 下载object_detection项目
   https://github.com/tensorflow/models
   直接下载压缩包，但是我这边实测真的很难下载，网速很慢，还总是中断，所以附上百度云连接:[models-master](链接：https://pan.baidu.com/s/11KGzIR0PQU23QWZjkh3l-A
   提取码：ohe0 )
2. 将解压出来的文件夹名称改为models,放入anaconda的tensorflow文件夹内。例如D:\Program Files (x86)\Anaconda3\Lib\site-packages\tensorflow
   注意路径中不要有中文，否则会出现一些意想不到的错误.
3. 使用protoc编译文件
   在 models/research 目录下，打开命令行窗口，执行以下语句：
   protoc object_detection/protos/*.proto --python_out=.
   此步骤将object_detection/protoc文件夹内的.proto文件编译为.py文件
4. 配置路径文件
   在site-packages添加一个路径文件，如tensorflow_model.pth，必须以.pth为后缀，写上你要加入的模块文件所在的目录名称。例如：

D:\Program Files (x86)\Anaconda3\Lib\site-packages\tensorflow\models\research
D:\Program Files (x86)\Anaconda3\Lib\site-packages\tensorflow\models\research\slim

否则会出现如下错误提示：

Traceback (most recent call last):
  File "object_detection/builders/model_builder_test.py", line 21, in <module>
    from object_detection.builders import model_builder
ImportError: No module named 'object_detection'

6. 测试是否安装成功
   在model/reseach文件夹下，打开命令行，输入
   python object_detection/builders/model_builder_test.py
   出现ok即为完成
7. 安装pycocotools
   在运行自带的object_detection_tutorial.ipynb文件时，需要用到这个工具包，但是windows下的安装问题较多，亲测有效的方法是：
   step1.下载项目文件
   https://github.com/philferriere/cocoapi
   将文件解压，进入PythonAPI文件夹，打开命令行窗口，执行：
   python setup.py build_ext install
   此步骤将pycocotools安装进site-packages

运行猪皮特

• 在object_detection文件夹下，有个object_detection_tutorial.ipynb文件，是一个教你如何使用训练好的模型进行预测的教程。可能你会遇到tensorflow禁止爬虫访问的问题。索性，将其转换为.py文件，自己在模型库中将模型下载好，直接运行脚本。
• 在object_detection文件夹下打开命令行，执行：
  jupyter-notebook.exe object_detection_tutorial.ipynb
• 在弹出的网页中，将其转换问.py文件
  
  将其放入同文件夹下。
• 下载预训练模型
  模型库地址https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md
  我们选择基于coco数据集的第一个模型做测试。
  
  得到文件ssd_mobilenet_v1_coco_2018_01_28.tar.gz,文件名可能不同，因为经常更新。不需解压，在object_detection目录下新建文件夹，用于存放模型，例如ckpoints，将模型文件放入其中。同时再新建一个文件夹用于存放检测结果，例如test_results。
• 编辑object_detection_tutorial.py文件
  主要包括模型的地址的更改。

# coding: utf-8

# # Object Detection Demo
# Welcome to the object detection inference walkthrough!  This notebook will walk you step by step through the process of using a pre-trained model to detect objects in an image. Make sure to follow the [installation instructions](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/installation.md) before you start.

# # Imports

# In[6]:


import numpy as np
import os
import six.moves.urllib as urllib
import sys
import tarfile
import tensorflow as tf
import zipfile

from distutils.version import StrictVersion
from collections import defaultdict
from io import StringIO
# from matplotlib import pyplot as plt
from PIL import Image

import matplotlib  # 出现matplotlib的警告，换为新的使用方法
matplotlib.use('Agg')
import matplotlib.pyplot as plt

# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
from object_detection.utils import ops as utils_ops

if StrictVersion(tf.__version__) < StrictVersion('1.9.0'):
  raise ImportError('Please upgrade your TensorFlow installation to v1.9.* or later!')


# ## Env setup

# In[7]:


# This is needed to display the images.
# get_ipython().run_line_magic('matplotlib', 'inline')


# ## Object detection imports
# Here are the imports from the object detection module.

# In[8]:


from utils import label_map_util

from utils import visualization_utils as vis_util


# # Model preparation 

# ## Variables
# 
# Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_FROZEN_GRAPH` to point to a new .pb file.  
# 
# By default we use an "SSD with Mobilenet" model here. See the [detection model zoo](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md) for a list of other models that can be run out-of-the-box with varying speeds and accuracies.

# In[11]:


# What model to download.
MODEL_NAME = 'ssd_mobilenet_v1_coco_2018_01_28' # 此处更改为模型的文件名
MODEL_PATH = 'ckpoints' ## 新定义一个模型文件夹
MODEL_FILE =  MODEL_PATH +'/'+ MODEL_NAME + '.tar.gz' # 更改模型文件的地址
#DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'  # 注释掉，无需网络爬虫

# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_FROZEN_GRAPH = MODEL_PATH +'/'+ MODEL_NAME+'/frozen_inference_graph.pb' # 此处为解压出来的.pb模型的地址，

# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')


# ## Download Model

# In[12]:


# opener = urllib.request.URLopener() # 这两行注释掉，无需下载
# opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)
tar_file = tarfile.open(MODEL_FILE)
for file in tar_file.getmembers():
  file_name = os.path.basename(file.name)
  if 'frozen_inference_graph.pb' in file_name:
    print(MODEL_PATH)
    tar_file.extract(file, MODEL_PATH) # 解压文件到某目录，该函数会自动创建同名文件夹


# ## Load a (frozen) Tensorflow model into memory.

# In[ ]:


detection_graph = tf.Graph()
with detection_graph.as_default():
  od_graph_def = tf.GraphDef()
  print(PATH_TO_FROZEN_GRAPH)
  with tf.gfile.GFile(PATH_TO_FROZEN_GRAPH, 'rb') as fid:
    serialized_graph = fid.read()
    od_graph_def.ParseFromString(serialized_graph)
    tf.import_graph_def(od_graph_def, name='')


# ## Loading label map
# Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`.  Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine

# In[ ]:


category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)


# ## Helper code

# In[ ]:


def load_image_into_numpy_array(image):
  (im_width, im_height) = image.size
  return np.array(image.getdata()).reshape((im_height, im_width, 3)).astype(np.uint8)


# # Detection

# In[ ]:


# For the sake of simplicity we will use only 2 images:
# image1.jpg
# image2.jpg
# If you want to test the code with your images, just add path to the images to the TEST_IMAGE_PATHS.
PATH_TO_TEST_IMAGES_DIR = 'test_images'
TEST_IMAGE_PATHS = [ os.path.join(PATH_TO_TEST_IMAGES_DIR, 'image{}.jpg'.format(i)) for i in range(1, 3) ]

# Size, in inches, of the output images.
IMAGE_SIZE = (12, 8)


# In[ ]:


def run_inference_for_single_image(image, graph):
  with graph.as_default():
    with tf.Session() as sess:
      # Get handles to input and output tensors
      ops = tf.get_default_graph().get_operations()
      all_tensor_names = {output.name for op in ops for output in op.outputs}
      tensor_dict = {}
      for key in [
          'num_detections', 'detection_boxes', 'detection_scores',
          'detection_classes', 'detection_masks'
      ]:
        tensor_name = key + ':0'
        if tensor_name in all_tensor_names:
          tensor_dict[key] = tf.get_default_graph().get_tensor_by_name(tensor_name)
      if 'detection_masks' in tensor_dict:
        # The following processing is only for single image
        detection_boxes = tf.squeeze(tensor_dict['detection_boxes'], [0])
        detection_masks = tf.squeeze(tensor_dict['detection_masks'], [0])
        # Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
        real_num_detection = tf.cast(tensor_dict['num_detections'][0], tf.int32)
        detection_boxes = tf.slice(detection_boxes, [0, 0], [real_num_detection, -1])
        detection_masks = tf.slice(detection_masks, [0, 0, 0], [real_num_detection, -1, -1])
        detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(
            detection_masks, detection_boxes, image.shape[0], image.shape[1])
        detection_masks_reframed = tf.cast(
            tf.greater(detection_masks_reframed, 0.5), tf.uint8)
        # Follow the convention by adding back the batch dimension
        tensor_dict['detection_masks'] = tf.expand_dims(
            detection_masks_reframed, 0)
      image_tensor = tf.get_default_graph().get_tensor_by_name('image_tensor:0')

      # Run inference
      output_dict = sess.run(tensor_dict,
                             feed_dict={image_tensor: np.expand_dims(image, 0)}) # [1,100,100,3]

      # all outputs are float32 numpy arrays, so convert types as appropriate
      output_dict['num_detections'] = int(output_dict['num_detections'][0])
      output_dict['detection_classes'] = output_dict['detection_classes'][0].astype(np.uint8)
      output_dict['detection_boxes'] = output_dict['detection_boxes'][0]
      output_dict['detection_scores'] = output_dict['detection_scores'][0]
      if 'detection_masks' in output_dict:
        output_dict['detection_masks'] = output_dict['detection_masks'][0]
  return output_dict


# In[ ]:


for image_path in TEST_IMAGE_PATHS:
  image = Image.open(image_path)
  # the array based representation of the image will be used later in order to prepare the
  # result image with boxes and labels on it.
  image_np = load_image_into_numpy_array(image)
  # Expand dimensions since the model expects images to have shape: [1, None, None, 3]
  image_np_expanded = np.expand_dims(image_np, axis=0) # 在axis维之前，加一维，例如将原[100,100,3]变为[1,100,100,3] 
  # Actual detection.
  output_dict = run_inference_for_single_image(image_np, detection_graph)
  # Visualization of the results of a detection.
  vis_util.visualize_boxes_and_labels_on_image_array(
      image_np,
      output_dict['detection_boxes'],
      output_dict['detection_classes'],
      output_dict['detection_scores'],
      category_index,
      instance_masks=output_dict.get('detection_masks'),
      use_normalized_coordinates=True,
      line_thickness=8)
  plt.figure(figsize=IMAGE_SIZE)
  plt.imshow(image_np)
  plt.savefig(image_path.replace('test_images', 'test_results'))

• 查看结果