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'
           

1. 測試是否安裝成功

   在model/reseach檔案夾下，打開指令行，輸入

   python object_detection/builders/model_builder_test.py

   出現

   ok

   即為完成

2. 安裝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'))
           

• 檢視結果