Window下在TensorFlow中安装目标检测API

素颜马尾好姑娘i 2022-02-27 16:50 271阅读 0赞

TensorFlow Object-detection API :[ github地址][github]

这个API的目的是创建一个能够在单个图像中定位和识别多个对象的精确机器学习模型，这在仍然是计算机视觉领域仍然是一个核心挑战。该API是在tensorflow上构造的开源框架，易于构建、训练和部署目标检测模型，谷歌已经应用在公司的视觉项目中，来源是开头的那篇论文，如果有兴趣可以研究一下，主要对比了几种不同的Object Detection神经网络（FasterRCNN RFCN SSD）。

# 一、下载TensorFlow Model模型库 #

TensorFlow 模型库包含了很多开源的模型，包括图像分类、检测、自然语言处理NLP、视频预测、图像理解等等，我们要学习的对象检测ＡＰＩ也包括在这里面，可以用git checkout到本地，也可以直接在github下载[zip包][zip]，本文直接下载的zip包(大概415M，虽然我们只会用到里面很少一部分内容)

下载后，解压到**anaconda中你的envc下，比如我的环境名是tensorflow，那么就把models放到~/tensorflow目录下**，为了与github目录结构一致，我们将models-master目录重命名为models

得到如下目录结构~/tensorflow/models/research/object\_detection

![70][]

# 二、安装 #

## 2.1 依赖库 ##

Tensorflow Object Detection API 依赖如下组件包:

>     Tensorflow　（安装过程参考[《window下搭建TensorFlow运行环境（用Anaconda）》][window_TensorFlow_Anaconda]
> 
>     Protobuf 2.6  
>     Python-tk  
>     Pillow 1.0  
>     lxml  
>     tf Slim (已在 "tensorflow/models/research/" 目录下)  
>     Jupyter notebook  
>     Matplotlib  
>     cocoapi

若你是通过《[window下搭建TensorFlow运行环境（用Anaconda）][window_TensorFlow_Anaconda]》介绍的方式，用anaconda安装的tensorflow，那么这上面的所有依赖项（除了cocoapi）都已经自动安装好，你可以像安装tensorflow一样在anaconda-navigator的搜索框里搜索下上面的组件，检验是否均已安装。

## 2.2 COCO API 安装 ##

coco api主要是用于度量模型在ＣＯＣＯ数据集上的分值（mAP指标等），对于我们学习来说，并没有什么用，所以暂时不需要安装，以后需要的时候可以再参考下面的官方说明安装之。

Download the cocoapi and copy the pycocotools subfolder to the tensorflow/models/research directory if you are interested in using COCO evaluation metrics. The default metrics are based on those used in Pascal VOC evaluation. To use the COCO object detection metrics add metrics\_set: "coco\_detection\_metrics" to the eval\_config message in the config file. To use the COCO instance segmentation metrics add metrics\_set: "coco\_mask\_metrics" to the eval\_config message in the config file.

>  *  git clone https://github.com/cocodataset/cocoapi.git
>  *  cd cocoapi/PythonAPI
>  *  make
>  *  cp -r pycocotools <path\_to\_tensorflow>/models/research/

## 2.3 Protobuf 编译（非常重要） ##

Protocol-buffer，Google开发的一套数据存储、网络通信时用于协议编码的工具库，和XML或json类似，就是把数据以某种结构保存下来，不同之处在于protobuf是二进制的，而且编码的时间和空间开销都降低很多。原理可以参考博客：[majianfei1023][]，

[google protobuf原理][google protobuf]。

使用方法：在[Google的git][Google_git]仓库下载需要的版本：根据前文依赖需要的是Protobuf 2.6，我们只需要它的编解码功能，所以只需要下载win64版本（我电脑是64位的，这里跟据你的电脑版本下在）即可。下载解压发现是一个可执行文件，OK，把它剪切到复制到`..\models\research`文件夹下，然后将该路径加入环境变量：在path中添加exe文件路径，并新建一个proto\_path，路径为exe文件路径。调用cmd，输入protoc发现提示missing input file或者类似不报错的提示都可以，证明已经可以使用了。

![20190328111816766.png][]

![20190328112115453.png][]

Tensorflow Object Detection API 用 Protobufs 来配置模型和训练参数. **在用这个框架之前,必须先编译Protobuf 库**，切换到这个目录下： tensorflow/models/research/，另外，确保当前bash是在anaconda的Tensorflow环境（即你tensorflow所在的环境）中，具体过程如下;\# 在这个目录下： tensorflow/models/research/

*  1. 通过cmd或者Anaconda Prompt进入命令行创口（这里以cmd方式进入）
 *  2. activate TensorFlow \#进入anaconda的TensorFlow环境中
 *  ![20190328105225779.png][]
 *  3.cd ~/tensorflow/models/research/ \#进入Tensorflow安装包所在的目录。anaconda安装在默认路径下的话用该条指令。

\#\#\#我的安装在D盘，所以需要先进入D:，再具体指到该文件下，如下图

![20190328110539830.png][]

*  4. protoc object\_detection/protos/\*.proto --python\_out=. \#`*.proto`表示是对`research`目录下的所有后缀名为`proto`的文件转成.py文件
 *  ![20190328110745687.png][]

\#\#\#不知道为啥我输入这条命令时会报错，没办法只能用最笨的办法——逐个文件更改，把\*处用具体文件名代替，如下

*  ![20190328110946456.png][]

或者写个指令脚本：

import os 
    path_url = os.path.join(os.getcwd(),r"object_detection\protos") 
    print("proto path:",path_url) 
    for file in os.listdir(path_url): 
        cmd = "protoc object_detection\protos\{} --python_out=." 
        if file.endswith(".proto"): 
            command = cmd.format(file) 
            print("excuting command:",command) 
            os.popen(command)

在`..\research`目录下新建一个文件`excuter.py`,把以上代码复制进去，保存运行，稍等一会儿就可以看到`..\research\object_detection\protos`目录下生成了许多`.py`文件，如下图。说明protoc配置成功。

![20190328111058103.png][]

## 2.4 添加环境变量 PYTHONPATH（非常重要） ##

依次打开：`我的电脑`—>`高级系统设置`—>`环境变量`，新建一个系统变量:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70][]

*  2.4.1变量名为PYTHONPATH，该变量名下只有两个值 tensorflow\\models\\research/ 和 `..\research\`slim 的绝对路径。

![20190328113000656.png][]

*  2.4.2 重启电脑让环境变量生效。

## 2.4 测试 ##

>     python object_detection/builders/model_builder_test.py

![20190328115852271.png][]

![20190328120029855.png][]

## 2.5 利用tensorflow自带模型测试 ##

测试的图片是在

> `..\models\research\object_detection\test_images`

我们看到这里有现成的两张图片，当然也可以换成自己的。

测试的脚本是

> ...\\models\\research\\object\_detection\\object\_detection\_tutorial.ipynb

### 2.5.1 python版本的测试模型： ###

这是一个需要用`jupyter notebook`打开的文件，不过好像在`jupyter notebook`运行会有许多毛病。我找到了一个py版本的测试模型，文件内容如下:

> 注意，下面这个demo里第4步“\# What model to download.”是从网络中下载预训练模型文件，若执行的时候速度很慢，将下载部分的代码注释掉，如下图所示。单独去下载这个模型文件，[这里][Link 1]下载，然后解压到object\_detection目录，确保存在object\_detection/ssd\_mobilenet\_v1\_coco\_2017\_11\_17/frozen\_inference\_graph.pb 文件

![20191117123333533.png][]

全部的py代码

import numpy as np
    import os
    import sys
    import tarfile
    import tensorflow as tf
    
    from distutils.version import StrictVersion
    from PIL import Image
    
    # 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!')
    
    from utils import label_map_util
    from utils import visualization_utils as vis_util
    
    
    # What model to download.
    MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17'
    #MODEL_FILE = 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_NAME + '/frozen_inference_graph.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')
    
    #将（frozen）TensorFlow模型载入内存
    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:
    	tar_file.extract(file, os.getcwd())
    
    
    detection_graph = tf.Graph()
    with detection_graph.as_default():
      od_graph_def = tf.GraphDef()
      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='')
    
    #标签图将索引映射到类名称，当我们的卷积预测5时，我们知道它对应飞机。这里我们使用内置函数，但是任何返回将整数映射到恰当字符标签的字典都适用。
    category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)
    
    #辅助代码
    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)
    
    
    # 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) ] #range:图像的数量，有几张写几张
    
    # Size, in inches, of the output images.
    IMAGE_SIZE = (12, 8)
    
    output_num = 1 #保存第一张图像的编号
    output_img_dic = r'\output_images'
    #判断保存测试结果的路径是否存在，不存在就创建
    if not os.path.exists(output_img_dic):
    	os.mkdir(output_img_dic)
    
    
    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)})
    
    	  # 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
    
    
    for image_path in TEST_IMAGE_PATHS:
      image = Image.open(image_path)
      #这个array在之后会被用来准备为图片加上框和标签
      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)
      # 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)
    
      #显示图片
      hck = Image.fromarray(image_np)
      hck.show()
    
      #保存测试结果
      output_img_path = os.path.join(output_img_dic,str(output_num)+".jpg")
      hck.save(output_img_path)
      print("success to save:",output_num)
      output_num +=1

>     运行上述代码需要安装matplotlib库，直接pip install matplotlib安装失败的可以去官网安装与python版本对应的whl文件。安装matplotlib.whl时需要先退出pycharm。

### 2.5.2 jupyter版的测试模型 ###

在你的TensorFlow环境中，将jupyter的默认工作路径修改到目标检测文件里的research文件夹下，修改方法见[这里][Link 2]，运行jupyter notebook。若之前修改过默认工作路径，则需要恢复jupyter的默认路径后（恢复方法见[这里][Link 3]），再做上一步的修改工作路径。然后打开/object\_detection/object\_detection\_tutorial.ipynb

![20190328145335425.png][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 1][]

注意，下面这个demo里第４步是从网络中下载预训练模型文件，若执行的时候速度很慢，可以单独去下载这个[模型文件][Link 1]，然后解压到相应目录，确保存在object\_detection/ssd\_mobilenet\_v1\_coco\_2017\_11\_17/frozen\_inference\_graph.pb 文件，然后屏蔽到代码中下载指令，如图所示，把Download Model代码块设置MarkDown或直接注释掉也可以。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 2][]  
接下就一步步执行里面的代码，看看最后的结果是否如下图，更多的细节和功能大家自己去研究研究吧：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 3][]

# 三、[Jupyter Notebook 快速入门][Jupyter Notebook] #

## 3.1  快捷键操作（***要在非编辑状态下才可以用***） ##

注：**编辑状态下可以按Esc到非编辑状态**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 4][]

**快捷键：**

>  *  在当前cell上方新建cell：A
>  *  在当前cell下方新建cell：B
>  *  执行当前cell，重新计算该单元格，并自动跳到下一个cell：Shift Enter
>  *  执行当前cell，执行后不自动调转到下一个cell：Ctrl-Enter
>  *  自动补齐代码：tab
>  *  显示注释：shift + tab  连按2次
>  *  当前单元格内容增加行号（命令模式下）："L"
>  *  删除单元格：连续两次按 "D"
>  *  保存："S"

## 3.2 工具栏找相应按钮 ##

>  *  如果想删除某个单元格，可以选择该单元格，然后依次点击`Edit` -> `Delete Cell`；
>  *  如果想移动某个单元格，只需要依次点击`Edit` -> `Move cell [up | down]`；
>  *  如果想剪贴某个单元测，可以先点击`Edit` -> `Cut Cell`，然后在点击`Edit` -> `Paste Cell [Above | Below]`；
>  *  如果你的 notebook 中有很多单元格只需要执行一次，或者想一次性执行大段代码，那么可以选择合并这些单元格。点击`Edit` -> `Merge Cell [Above | below]`。

![jupyter 代码执行实例][jupyter]

notebook 有一个非常有趣的特性，就是可以修改之前的单元格，对其重新计算，这样就可以更新整个文档了。试着把光标移回第一个单元格，并将`1 + 2`修改成`2 + 3`，然后按下***`Shift + Enter`*****重新计算该单元格**。你会发现结果马上就更新成了 5。如果你不想重新运行整个脚本，只想用不同的参数测试某个程式的话，这个特性显得尤其强大。不过，你也可以**重新计算整个** **notebook**，只要点击***`Cell` -> `Run all`***即可。

##  3.3 Header单元格和 Markdown单元格。 ##

首先，我们在顶部添加一个 notebook 的标题。选中第一个单元格，然后点击`Insert` -> `Insert单元格above`（在上方插入单元格）。你会发现，文档的顶部马上就出现了一个新的单元格。点击在快捷键栏中的单元格类型，将其变成一个标题单元格（heading cell）：

![变成一个标题 cell][cell]

选中下拉选项中的 Heading。然后会出现一个弹出消息，告诉你如何创建不同层级的标题，这样你就有了一个不同类型的 cell：

![一个不同类型的 cell][cell 1]

这个单元格以`#`标记开头，意味着这是一个一级标题。如果需要子标题，可以使用以下标记表示（改变单元格类型时弹出消息中有解释）：

# : 一级标题
    ## : 二级标题
    ### : 三级标题
    ...

在`#`之后写下文档的标题，然后计算该单元格。你会发现一个样式非常好看的标题。作为示例和练习，我还添加了其他几个标题单元格：

![添加了其他几个标题 cell][cell 2]

添加好标题之后，我们在编写一些解释，介绍每个代码单元格中的情况。为此，我们要在相应的地方插入单元格，然后将其类型变成 Markdown。然后，计算新的单元格。就这样，你的解释文本就漂亮地渲染出来了！

![解释文本就漂亮地渲染出来了][aHR0cDovL3d3MS5zaW5haW1nLmNuL213NjkwLzAwNmZhUU5UZ3cxZjYza2Qwb3E4Z2ozMGlkMGR0d2Y0LmpwZw]

最后，你可以重命名该 notebook，点击`Fiel` -> `Rename`，然后输入新的名称。这样，新的名称将会出现在窗口的左上角，在 Jupyter 的标志旁边。

### 参考资料： ###

[目标检测Tensorflow object detection API之构建自己的模型][Tensorflow object detection API]：好

[利用Tensorflow构建自己的物体识别模型(一)][Tensorflow]：结合上面的看

[Jupyter notebook 常用快捷键（持续更新）][Jupyter notebook][：http://www.cnblogs.com/yxmfighting/p/7642895.html][http_www.cnblogs.com_yxmfighting_p_7642895.html]

[github]: https://github.com/tensorflow/models/tree/master/research/object_detection
[zip]: https://codeload.github.com/tensorflow/models/zip/master
[70]: /images/20220227/db8f7147b71a4021abb1b6c97dbc1db9.png
[window_TensorFlow_Anaconda]: https://mp.csdn.net/postedit/87712141
[majianfei1023]: https://blog.csdn.net/majianfei1023/article/details/45112415
[google protobuf]: https://mp.csdn.net/postedit/88851118
[Google_git]: https://github.com/protocolbuffers/protobuf/releases
[20190328111816766.png]: /images/20220227/7432918ee07b499c9c7f0a8b2ec8cae7.png
[20190328112115453.png]: /images/20220227/42c51d097ab64d3cbd32f521112f99ce.png
[20190328105225779.png]: /images/20220227/f987bdefa1e4432b89c009c1c82a543f.png
[20190328110539830.png]: /images/20220227/069c16018b78470780c12b02df023fab.png
[20190328110745687.png]: /images/20220227/bb0dca2fce5e4bff9ede300e5f5ef59d.png
[20190328110946456.png]: /images/20220227/c87cbfcbad8140fca5426d6f4e5cf71b.png
[20190328111058103.png]: /images/20220227/aff4feca8a6847e3914141c1ad3a801f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70]: /images/20220227/0c0561948fc34fb185a89d39bd2690ec.png
[20190328113000656.png]: /images/20220227/512c4f1c93314a0599f6e24c3a5dce69.png
[20190328115852271.png]: /images/20220227/0656fdb48a164284a9825214576da87f.png
[20190328120029855.png]: /images/20220227/792175d1985d482891f5676cefc8d52b.png
[Link 1]: http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_coco_2017_11_17.tar.gz
[20191117123333533.png]: /images/20220227/5d114f5baddb4904b61f806f3e7baa14.png
[Link 2]: https://blog.csdn.net/yefcion/article/details/79431760
[Link 3]: https://www.jianshu.com/p/db45e5189e7d
[20190328145335425.png]: https://img-blog.csdnimg.cn/20190328145335425.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 1]: /images/20220227/ead83998b9174368a77fd52abaeda63b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 2]: /images/20220227/b84bae9b90a0411d93d4834c9e88446a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 3]: /images/20220227/12ada61d788e4a91a603728657c3a5da.png
[Jupyter Notebook]: https://www.cnblogs.com/nxld/p/6566380.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 4]: /images/20220227/93c340fbdbf14894bdfc41c4a390bed4.png
[jupyter]: /images/20220227/114e3c1b6f994255bafa60a38b908a02.png
[cell]: /images/20220227/62dcf5e6d05243b4a7b79edc3eaa34e2.png
[cell 1]: /images/20220227/f797a82398c9428885390cf27e83b11a.png
[cell 2]: /images/20220227/6251dc26d02e47b782dfc2c1df85a917.png
[aHR0cDovL3d3MS5zaW5haW1nLmNuL213NjkwLzAwNmZhUU5UZ3cxZjYza2Qwb3E4Z2ozMGlkMGR0d2Y0LmpwZw]: /images/20220227/2e0de8217a294513b482f0163b0892bd.png
[Tensorflow object detection API]: https://zhuanlan.zhihu.com/p/35854575
[Tensorflow]: https://www.jianshu.com/p/9c9b908a2b73
[Jupyter notebook]: https://www.cnblogs.com/yxmfighting/p/7642895.html
[http_www.cnblogs.com_yxmfighting_p_7642895.html]: http://www.cnblogs.com/yxmfighting/p/7642895.html