基于Tensorflow Object Detection API 的哆啦A梦检测

最新推荐文章于 2022-04-28 13:54:31 发布
最新推荐文章于 2022-04-28 13:54:31 发布
阅读量1.7k 收藏 2
点赞数 2
分类专栏： 计算机视觉 文章标签： object detection 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28637799/article/details/81391639
版权

简介

Doraemon-detection-result
哆啦A梦是小时候动画片中很喜欢的卡通人物，他那么的可爱，还有一个无所不能的口袋。在思考利用Tensorflow Object Detection API（以下简称TODA） 在自定义数据上做一个简单的练习时，脑海里突然冒出了哆啦A梦的形象，在这篇博客中记录了利用TODA对哆啦A梦的检测，主要包括以下流程（前提是安装好TODA，可以参考官方文档）：
1. 搜集图片
2. 数据标注
3. 将图片转换为tfrecord格式
4. 下载预训练好的模型
5. 编辑labelmap.pbtxt 和模型配置文件
6. 模型训练
7. ckpt模型转换为pb模型
8. 模型测试
文件目录：在TODA目录的基础上添加了以下目录及文件：
dir-screenshot

1.搜集图片

这里利用了Bing Image Search api，使用前需要获取API KEY。用Python脚本下载所需的哆啦A梦图片，这里下载了500张哆啦A梦图片，对应的下载数量为脚本中的MAX_RESULTS=500, 脚本search_bing_api.py内容如下:

# USAGE
# python search_bing_api.py --query "doraemon" --output dataset/doraemon

# import the necessary packages
from requests import exceptions
import argparse
import requests
import cv2
import os

# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-q", "--query", required=True,
    help="search query to search Bing Image API for")
ap.add_argument("-o", "--output", required=True,
    help="path to output directory of images")
args = vars(ap.parse_args())

# set your Microsoft Cognitive Services API key along with (1) the
# maximum number of results for a given search and (2) the group size
# for results (maximum of 50 per request)
API_KEY = "Your API-key"
MAX_RESULTS = 500
GROUP_SIZE = 50

# set the endpoint API URL
URL = "https://api.cognitive.microsoft.com/bing/v7.0/images/search"

# when attemping to download images from the web both the Python
# programming language and the requests library have a number of
# exceptions that can be thrown so let's build a list of them now
# so we can filter on them
EXCEPTIONS = set([IOError, FileNotFoundError,
    exceptions.RequestException, exceptions.HTTPError,
    exceptions.ConnectionError, exceptions.Timeout])

# store the search term in a convenience variable then set the
# headers and search parameters
term = args["query"]
headers = {"Ocp-Apim-Subscription-Key" : API_KEY}
params = {"q": term, "offset": 0, "count": GROUP_SIZE}

# make the search
print("[INFO] searching Bing API for '{}'".format(term))
search = requests.get(URL, headers=headers, params=params)
search.raise_for_status()

# grab the results from the search, including the total number of
# estimated results returned by the Bing API
results = search.json()
estNumResults = min(results["totalEstimatedMatches"], MAX_RESULTS)
print("[INFO] {} total results for '{}'".format(estNumResults,
    term))

# initialize the total number of images downloaded thus far
total = 0

# loop over the estimated number of results in `GROUP_SIZE` groups
for offset in range(0, estNumResults, GROUP_SIZE):
    # update the search parameters using the current offset, then
    # make the request to fetch the results
    print("[INFO] making request for group {}-{} of {}...".format(
        offset, offset + GROUP_SIZE, estNumResults))
    params["offset"] = offset
    search = requests.get(URL, headers=headers, params=params)
    search.raise_for_status()
    results = search.json()
    print("[INFO] saving images for group {}-{} of {}...".format(
        offset, offset + GROUP_SIZE, estNumResults))

    # loop over the results
    for v in results["value"]:
        # try to download the image
        try:
            # make a request to download the image
            print("[INFO] fetching: {}".format(v["contentUrl"]))
            r = requests.get(v["contentUrl"], timeout=30)

            # build the path to the output image
            ext = v["contentUrl"][v["contentUrl"].rfind("."):]
            p = os.path.sep.join([args["output"], "{}{}".format(
                str(total).zfill(8), ext)])

            # write the image to disk
            f = open(p, "wb")
            f.write(r.content)
            f.close()

        # catch any errors that would not unable us to download the
        # image
        except Exception as e:
            # check to see if our exception is in our list of
            # exceptions to check for
            if type(e) in EXCEPTIONS:
                print("[INFO] skipping: {}".format(v["contentUrl"]))
                continue

        # try to load the image from disk
        image = cv2.imread(p)

        # if the image is `None` then we could not properly load the
        # image from disk (so it should be ignored)
        if image is None:
            print("[INFO] deleting: {}".format(p))
            os.remove(p)
            continue

        # update the counter
        total += 1

将下载得到的图片分为训练数据和测试数据，分别存放在 images/train 和 images/test 目录下。

2.数据标注

利用开源图片标注工具 LabelImg 分别对训练数据和测试数据进行标注，每张图片会得到一个对应的XML标注结果文件，将其保存在和图片相同的目录下。
doraemon-labelimg

3.将图片转换为tfrecord格式

首先，由标注得到的XML文件生成CSV文件，从而可以利用已有的工具从CSV文件生成训练所需的 tfrecord 格式文件。利用主目录下的 xml_to_csv.py ，修改对应的数据目录即可得到训练和测试数据的CSV文件。xml_to_csv.py 内容如下：

import os
import glob
import pandas as pd
import xml.etree.ElementTree as ET


def xml_to_csv(path):
    xml_list = []
    for xml_file in glob.glob(path + '/*.xml'):
        tree = ET.parse(xml_file)
        root = tree.getroot()
        for member in root.findall('object'):
            value = (root.find('filename').text+root.find('path').text[-4:],
                     int(root.find('size')[0].text),
                     int(root.find('size')[1].text),
                     member[0].text,
                     int(member[4][0].text),
                     int(member[4][1].text),
                     int(member[4][2].text),
                     int(member[4][3].text)
                     )
            xml_list.append(value)
    column_name = ['filename', 'width', 'height', 'class', 'xmin', 'ymin', 'xmax', 'ymax']
    xml_df = pd.DataFrame(xml_list, columns=column_name)
    return xml_df

def main():
    for folder in ['train','test']:
        image_path = os.path.join(os.getcwd(), ('images/' + folder))
        xml_df = xml_to_csv(image_path)
        xml_df.to_csv(('images/' + folder + '_labels.csv'), index=None)
        print('Successfully converted xml to csv.')

main()

python xml_to_csv.py
生成tfrecord

利用generate_tfrecord.py 内容：

"""
Usage:
  # From tensorflow/models/
  # Create train data:
  python generate_tfrecord.py --csv_input=images/train_labels.csv --image_dir=images/train --output_path=train.record

  # Create test data:
  python generate_tfrecord.py --csv_input=images/test_labels.csv  --image_dir=images/test --output_path=test.record
"""
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import

import os
import io
import pandas as pd
import tensorflow as tf

from PIL import Image
from object_detection.utils import dataset_util
from collections import namedtuple, OrderedDict

flags = tf.app.flags
flags.DEFINE_string('csv_input', '', 'Path to the CSV input')
flags.DEFINE_string('image_dir', '', 'Path to the image directory')
flags.DEFINE_string('output_path', '', 'Path to output TFRecord')
FLAGS = flags.FLAGS


# TO-DO replace this with label map
def class_text_to_int(row_label):
    if row_label == 'Doraemon':
        return 1
    else:
        None


def split(df, group):
    data = namedtuple('data', ['filename', 'object'])
    gb = df.groupby(group)
    return [data(filename, gb.get_group(x)) for filename, x in zip(gb.groups.keys(), gb.groups)]


def create_tf_example(group, path):
    with tf.gfile.GFile(os.path.join(path, '{}'.format(group.filename)), 'rb') as fid:
        encoded_jpg = fid.read()
    encoded_jpg_io = io.BytesIO(encoded_jpg)
    image = Image.open(encoded_jpg_io)
    width, height = image.size

    filename = group.filename.encode('utf8')
    image_format = b'jpg'
    xmins = []
    xmaxs = []
    ymins = []
    ymaxs = []
    classes_text = []
    classes = []

    for index, row in group.object.iterrows():
        xmins.append(row['xmin'] / width)
        xmaxs.append(row['xmax'] / width)
        ymins.append(row['ymin'] / height)
        ymaxs.append(row['ymax'] / height)
        classes_text.append(row['class'].encode('utf8'))
        classes.append(class_text_to_int(row['class']))
        #print("Classes: ", classes)

    tf_example = tf.train.Example(features=tf.train.Features(feature={
        'image/height': dataset_util.int64_feature(height),
        'image/width': dataset_util.int64_feature(width),
        'image/filename': dataset_util.bytes_feature(filename),
        'image/source_id': dataset_util.bytes_feature(filename),
        'image/encoded': dataset_util.bytes_feature(encoded_jpg),
        'image/format': dataset_util.bytes_feature(image_format),
        'image/object/bbox/xmin': dataset_util.float_list_feature(xmins),
        'image/object/bbox/xmax': dataset_util.float_list_feature(xmaxs),
        'image/object/bbox/ymin': dataset_util.float_list_feature(ymins),
        'image/object/bbox/ymax': dataset_util.float_list_feature(ymaxs),
        'image/object/class/text': dataset_util.bytes_list_feature(classes_text),
        'image/object/class/label': dataset_util.int64_list_feature(classes),
    }))
    return tf_example

def main(_):
    writer = tf.python_io.TFRecordWriter(FLAGS.output_path)
    path = os.path.join(os.getcwd(), FLAGS.image_dir)
    examples = pd.read_csv(FLAGS.csv_input)
    grouped = split(examples, 'filename')
    for group in grouped:
        tf_example = create_tf_example(group, path)
        writer.write(tf_example.SerializeToString())

    writer.close()
    output_path = os.path.join(os.getcwd(), FLAGS.output_path)
    print('Successfully created the TFRecords: {}'.format(output_path))

if __name__ == '__main__':
    tf.app.run()
训练数据
python generate_tfrecord.py --csv_input=images/train_labels.csv --image_dir=images/train --output_path=train.record
测试数据
python generate_tfrecord.py --csv_input=images/test_labels.csv  --image_dir=images/test --output_path=test.record

4.下载预训练好的模型

使用预训练的模型做迁移学习能够更快的训练得到一个不错的模型，这里选择的是faster_rcnn_inception_v2_coco_2018_01_28 模型，可以在这里下载得到，或者在Tensorflow detection model zoo 中下载其他预训练好的模型。将下载文件解压存放在faster_rcnn_inception_v2_coco_2018_01_28目录下，该文件夹下的文件应为：
faster-rcnn-dir-content

5.编辑labelmap.pbtxt 和模型配置文件

labelmap.pbtxt及模型配置文件faster_rcnn_inception_doraemon.config都存放在training目录下。

(1)labelmap.pbtxt
item {
  id: 1
  name: 'Doraemon'
}
(2)faster_rcnn_inception_doraemon.config
# Faster R-CNN with Inception v2, configured for Oxford-IIIT Pets Dataset.
# Users should configure the fine_tune_checkpoint field in the train config as
# well as the label_map_path and input_path fields in the train_input_reader and
# eval_input_reader. Search for "PATH_TO_BE_CONFIGURED" to find the fields that
# should be configured.

model {
  faster_rcnn {
    num_classes: 1
    image_resizer {
      keep_aspect_ratio_resizer {
        min_dimension: 600
        max_dimension: 1024
      }
    }
    feature_extractor {
      type: 'faster_rcnn_inception_v2'
      first_stage_features_stride: 16
    }
    first_stage_anchor_generator {
      grid_anchor_generator {
        scales: [0.125, 0.25, 0.5, 1.0, 2.0]
        aspect_ratios: [0.25, 0.5, 1.0, 2.0]
        height_stride: 16
        width_stride: 16
      }
    }
    first_stage_box_predictor_conv_hyperparams {
      op: CONV
      regularizer {
        l2_regularizer {
          weight: 0.0
        }
      }
      initializer {
        truncated_normal_initializer {
          stddev: 0.01
        }
      }
    }
    first_stage_nms_score_threshold: 0.0
    first_stage_nms_iou_threshold: 0.7
    first_stage_max_proposals: 300
    first_stage_localization_loss_weight: 2.0
    first_stage_objectness_loss_weight: 1.0
    initial_crop_size: 14
    maxpool_kernel_size: 2
    maxpool_stride: 2
    second_stage_box_predictor {
      mask_rcnn_box_predictor {
        use_dropout: false
        dropout_keep_probability: 1.0
        fc_hyperparams {
          op: FC
          regularizer {
            l2_regularizer {
              weight: 0.0
            }
          }
          initializer {
            variance_scaling_initializer {
              factor: 1.0
              uniform: true
              mode: FAN_AVG
            }
          }
        }
      }
    }
    second_stage_post_processing {
      batch_non_max_suppression {
        score_threshold: 0.0
        iou_threshold: 0.6
        max_detections_per_class: 100
        max_total_detections: 300
      }
      score_converter: SOFTMAX
    }
    second_stage_localization_loss_weight: 2.0
    second_stage_classification_loss_weight: 1.0
  }
}

train_config: {
  batch_size: 1
  optimizer {
    momentum_optimizer: {
      learning_rate: {
        manual_step_learning_rate {
          initial_learning_rate: 0.0003
          schedule {
            step: 10000
            learning_rate: .00003
          }
          schedule {
            step: 20000
            learning_rate: .000003
          }
        }
      }
      momentum_optimizer_value: 0.9
    }
    use_moving_average: false
  }
  gradient_clipping_by_norm: 10.0
  fine_tune_checkpoint: "C:/ObjectDetect/models/research/object_detection/faster_rcnn_inception_v2_coco_2018_01_28/model.ckpt"
  from_detection_checkpoint: true
  # Note: The below line limits the training process to 200K steps, which we
  # empirically found to be sufficient enough to train the pets dataset. This
  # effectively bypasses the learning rate schedule (the learning rate will
  # never decay). Remove the below line to train indefinitely.
  num_steps: 200000
  data_augmentation_options {
    random_horizontal_flip {
    }
  }
}


train_input_reader: {
  tf_record_input_reader {
    input_path: "C:/ObjectDetect/models/research/object_detection/train.record"
  }
  label_map_path: "C:/ObjectDetect/models/research/object_detection/training/labelmap.pbtxt"
}

eval_config: {
  num_examples: 27
  # Note: The below line limits the evaluation process to 10 evaluations.
  # Remove the below line to evaluate indefinitely.
  max_evals: 10
}

eval_input_reader: {
  tf_record_input_reader {
    input_path: "C:/ObjectDetect/models/research/object_detection/test.record"
  }
  label_map_path: "C:/ObjectDetect/models/research/object_detection/training/labelmap.pbtxt"
  shuffle: false
  num_readers: 1
}

6. 模型训练

已有的模型训练脚本：

# Copyright 2017 The TensorFlow Authors. 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.
# ==============================================================================

r"""Training executable for detection models.

This executable is used to train DetectionModels. There are two ways of
configuring the training job:

1) A single pipeline_pb2.TrainEvalPipelineConfig configuration file
can be specified by --pipeline_config_path.

Example usage:
    ./train \
        --logtostderr \
        --train_dir=path/to/train_dir \
        --pipeline_config_path=pipeline_config.pbtxt

2) Three configuration files can be provided: a model_pb2.DetectionModel
configuration file to define what type of DetectionModel is being trained, an
input_reader_pb2.InputReader file to specify what training data will be used and
a train_pb2.TrainConfig file to configure training parameters.

Example usage:
    ./train \
        --logtostderr \
        --train_dir=path/to/train_dir \
        --model_config_path=model_config.pbtxt \
        --train_config_path=train_config.pbtxt \
        --input_config_path=train_input_config.pbtxt
"""

import functools
import json
import os
import tensorflow as tf

from object_detection import trainer
from object_detection.builders import dataset_builder
from object_detection.builders import graph_rewriter_builder
from object_detection.builders import model_builder
from object_detection.utils import config_util
from object_detection.utils import dataset_util

tf.logging.set_verbosity(tf.logging.INFO)

flags = tf.app.flags
flags.DEFINE_string('master', '', 'Name of the TensorFlow master to use.')
flags.DEFINE_integer('task', 0, 'task id')
flags.DEFINE_integer('num_clones', 1, 'Number of clones to deploy per worker.')
flags.DEFINE_boolean('clone_on_cpu', False,
                     'Force clones to be deployed on CPU.  Note that even if '
                     'set to False (allowing ops to run on gpu), some ops may '
                     'still be run on the CPU if they have no GPU kernel.')
flags.DEFINE_integer('worker_replicas', 1, 'Number of worker+trainer '
                     'replicas.')
flags.DEFINE_integer('ps_tasks', 0,
                     'Number of parameter server tasks. If None, does not use '
                     'a parameter server.')
flags.DEFINE_string('train_dir', '',
                    'Directory to save the checkpoints and training summaries.')

flags.DEFINE_string('pipeline_config_path', '',
                    'Path to a pipeline_pb2.TrainEvalPipelineConfig config '
                    'file. If provided, other configs are ignored')

flags.DEFINE_string('train_config_path', '',
                    'Path to a train_pb2.TrainConfig config file.')
flags.DEFINE_string('input_config_path', '',
                    'Path to an input_reader_pb2.InputReader config file.')
flags.DEFINE_string('model_config_path', '',
                    'Path to a model_pb2.DetectionModel config file.')

FLAGS = flags.FLAGS


def main(_):
  assert FLAGS.train_dir, '`train_dir` is missing.'
  if FLAGS.task == 0: tf.gfile.MakeDirs(FLAGS.train_dir)
  if FLAGS.pipeline_config_path:
    configs = config_util.get_configs_from_pipeline_file(
        FLAGS.pipeline_config_path)
    if FLAGS.task == 0:
      tf.gfile.Copy(FLAGS.pipeline_config_path,
                    os.path.join(FLAGS.train_dir, 'pipeline.config'),
                    overwrite=True)
  else:
    configs = config_util.get_configs_from_multiple_files(
        model_config_path=FLAGS.model_config_path,
        train_config_path=FLAGS.train_config_path,
        train_input_config_path=FLAGS.input_config_path)
    if FLAGS.task == 0:
      for name, config in [('model.config', FLAGS.model_config_path),
                           ('train.config', FLAGS.train_config_path),
                           ('input.config', FLAGS.input_config_path)]:
        tf.gfile.Copy(config, os.path.join(FLAGS.train_dir, name),
                      overwrite=True)

  model_config = configs['model']
  train_config = configs['train_config']
  input_config = configs['train_input_config']

  model_fn = functools.partial(
      model_builder.build,
      model_config=model_config,
      is_training=True)

  def get_next(config):
    return dataset_util.make_initializable_iterator(
        dataset_builder.build(config)).get_next()

  create_input_dict_fn = functools.partial(get_next, input_config)

  env = json.loads(os.environ.get('TF_CONFIG', '{}'))
  cluster_data = env.get('cluster', None)
  cluster = tf.train.ClusterSpec(cluster_data) if cluster_data else None
  task_data = env.get('task', None) or {'type': 'master', 'index': 0}
  task_info = type('TaskSpec', (object,), task_data)

  # Parameters for a single worker.
  ps_tasks = 0
  worker_replicas = 1
  worker_job_name = 'lonely_worker'
  task = 0
  is_chief = True
  master = ''

  if cluster_data and 'worker' in cluster_data:
    # Number of total worker replicas include "worker"s and the "master".
    worker_replicas = len(cluster_data['worker']) + 1
  if cluster_data and 'ps' in cluster_data:
    ps_tasks = len(cluster_data['ps'])

  if worker_replicas > 1 and ps_tasks < 1:
    raise ValueError('At least 1 ps task is needed for distributed training.')

  if worker_replicas >= 1 and ps_tasks > 0:
    # Set up distributed training.
    server = tf.train.Server(tf.train.ClusterSpec(cluster), protocol='grpc',
                             job_name=task_info.type,
                             task_index=task_info.index)
    if task_info.type == 'ps':
      server.join()
      return

    worker_job_name = '%s/task:%d' % (task_info.type, task_info.index)
    task = task_info.index
    is_chief = (task_info.type == 'master')
    master = server.target

  graph_rewriter_fn = None
  if 'graph_rewriter_config' in configs:
    graph_rewriter_fn = graph_rewriter_builder.build(
        configs['graph_rewriter_config'], is_training=True)

  trainer.train(
      create_input_dict_fn,
      model_fn,
      train_config,
      master,
      task,
      FLAGS.num_clones,
      worker_replicas,
      FLAGS.clone_on_cpu,
      ps_tasks,
      worker_job_name,
      is_chief,
      FLAGS.train_dir,
      graph_hook_fn=graph_rewriter_fn)

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

确保以上步骤无误后可以开始训练

python train.py --logtostderr --train_dir=training/ --pipeline_config_path=training/faster_rcnn_inception_doraemon.config

在TODA目录下打开tensorboard

tensorboard --logdir=training

在经过8000 steps 后可以看到的训练情况为：
doraemon-training-tensorboard

7. ckpt模型转换为pb模型

使用tensorflow训练模型，ckpt作为tensorflow训练生成的模型，可以在tensorflow内部使用。但是如果想要永久保存，最好将其导出成pb的形式。利用export_inference_graph.py 将modle.ckpt-8234转换为pb模型文件，代码如下：

# Copyright 2017 The TensorFlow Authors. 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.
# ==============================================================================

r"""Tool to export an object detection model for inference.

Prepares an object detection tensorflow graph for inference using model
configuration and an optional trained checkpoint. Outputs inference
graph, associated checkpoint files, a frozen inference graph and a
SavedModel (https://tensorflow.github.io/serving/serving_basic.html).

The inference graph contains one of three input nodes depending on the user
specified option.
  * `image_tensor`: Accepts a uint8 4-D tensor of shape [None, None, None, 3]
  * `encoded_image_string_tensor`: Accepts a 1-D string tensor of shape [None]
    containing encoded PNG or JPEG images. Image resolutions are expected to be
    the same if more than 1 image is provided.
  * `tf_example`: Accepts a 1-D string tensor of shape [None] containing
    serialized TFExample protos. Image resolutions are expected to be the same
    if more than 1 image is provided.

and the following output nodes returned by the model.postprocess(..):
  * `num_detections`: Outputs float32 tensors of the form [batch]
      that specifies the number of valid boxes per image in the batch.
  * `detection_boxes`: Outputs float32 tensors of the form
      [batch, num_boxes, 4] containing detected boxes.
  * `detection_scores`: Outputs float32 tensors of the form
      [batch, num_boxes] containing class scores for the detections.
  * `detection_classes`: Outputs float32 tensors of the form
      [batch, num_boxes] containing classes for the detections.
  * `detection_masks`: Outputs float32 tensors of the form
      [batch, num_boxes, mask_height, mask_width] containing predicted instance
      masks for each box if its present in the dictionary of postprocessed
      tensors returned by the model.

Notes:
 * This tool uses `use_moving_averages` from eval_config to decide which
   weights to freeze.

Example Usage:
python export_inference_graph.py --input_type image_tensor --pipeline_config_path training_D/faster_rcnn_inception_doraemon.config --trained_checkpoint_prefix training_D/model.ckpt-6993 --output_directory inference_graphD
--------------
python export_inference_graph \
    --input_type image_tensor \
    --pipeline_config_path path/to/ssd_inception_v2.config \
    --trained_checkpoint_prefix path/to/model.ckpt \
    --output_directory path/to/exported_model_directory

The expected output would be in the directory
path/to/exported_model_directory (which is created if it does not exist)
with contents:
 - graph.pbtxt
 - model.ckpt.data-00000-of-00001
 - model.ckpt.info
 - model.ckpt.meta
 - frozen_inference_graph.pb
 + saved_model (a directory)

Config overrides (see the `config_override` flag) are text protobufs
(also of type pipeline_pb2.TrainEvalPipelineConfig) which are used to override
certain fields in the provided pipeline_config_path.  These are useful for
making small changes to the inference graph that differ from the training or
eval config.

Example Usage (in which we change the second stage post-processing score
threshold to be 0.5):

python export_inference_graph \
    --input_type image_tensor \
    --pipeline_config_path path/to/ssd_inception_v2.config \
    --trained_checkpoint_prefix path/to/model.ckpt \
    --output_directory path/to/exported_model_directory \
    --config_override " \
            model{ \
              faster_rcnn { \
                second_stage_post_processing { \
                  batch_non_max_suppression { \
                    score_threshold: 0.5 \
                  } \
                } \
              } \
            }"
"""
import tensorflow as tf
from google.protobuf import text_format
from object_detection import exporter
from object_detection.protos import pipeline_pb2

slim = tf.contrib.slim
flags = tf.app.flags

flags.DEFINE_string('input_type', 'image_tensor', 'Type of input node. Can be '
                    'one of [`image_tensor`, `encoded_image_string_tensor`, '
                    '`tf_example`]')
flags.DEFINE_string('input_shape', None,
                    'If input_type is `image_tensor`, this can explicitly set '
                    'the shape of this input tensor to a fixed size. The '
                    'dimensions are to be provided as a comma-separated list '
                    'of integers. A value of -1 can be used for unknown '
                    'dimensions. If not specified, for an `image_tensor, the '
                    'default shape will be partially specified as '
                    '`[None, None, None, 3]`.')
flags.DEFINE_string('pipeline_config_path', None,
                    'Path to a pipeline_pb2.TrainEvalPipelineConfig config '
                    'file.')
flags.DEFINE_string('trained_checkpoint_prefix', None,
                    'Path to trained checkpoint, typically of the form '
                    'path/to/model.ckpt')
flags.DEFINE_string('output_directory', None, 'Path to write outputs.')
flags.DEFINE_string('config_override', '',
                    'pipeline_pb2.TrainEvalPipelineConfig '
                    'text proto to override pipeline_config_path.')
tf.app.flags.mark_flag_as_required('pipeline_config_path')
tf.app.flags.mark_flag_as_required('trained_checkpoint_prefix')
tf.app.flags.mark_flag_as_required('output_directory')
FLAGS = flags.FLAGS


def main(_):
  pipeline_config = pipeline_pb2.TrainEvalPipelineConfig()
  with tf.gfile.GFile(FLAGS.pipeline_config_path, 'r') as f:
    text_format.Merge(f.read(), pipeline_config)
  text_format.Merge(FLAGS.config_override, pipeline_config)
  if FLAGS.input_shape:
    input_shape = [
        int(dim) if dim != '-1' else None
        for dim in FLAGS.input_shape.split(',')
    ]
  else:
    input_shape = None
  exporter.export_inference_graph(FLAGS.input_type, pipeline_config,
                                  FLAGS.trained_checkpoint_prefix,
                                  FLAGS.output_directory, input_shape)

if __name__ == '__main__':
  tf.app.run()
python export_inference_graph.py --input_type image_tensor --pipeline_config_path training/faster_rcnn_inception_doraemon.config --trained_checkpoint_prefix training_D/model.ckpt-8243 --output_directory inference_graph

此时inference_graph目录下的文件为：
inference-graph-contents

8. 模型测试

python 脚本Object_detection_image.py ：

######## Image Object Detection Using Tensorflow-trained Classifier #########
#
# Author: Evan Juras
# Date: 1/15/18
# Description: 
# This program uses a TensorFlow-trained classifier to perform object detection.
# It loads the classifier uses it to perform object detection on an image.
# It draws boxes and scores around the objects of interest in the image.

## Some of the code is copied from Google's example at
## https://github.com/tensorflow/models/blob/master/research/object_detection/object_detection_tutorial.ipynb

## and some is copied from Dat Tran's example at
## https://github.com/datitran/object_detector_app/blob/master/object_detection_app.py

## but I changed it to make it more understandable to me.

# Import packages
import os
import cv2
import numpy as np
import tensorflow as tf
import sys

# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")

# Import utilites
from utils import label_map_util
from utils import visualization_utils as vis_util

# Name of the directory containing the object detection module we're using
MODEL_NAME = 'inference_graph'
IMAGE_NAME = './images/test/00000391.jpg'

# Grab path to current working directory
CWD_PATH = os.getcwd()

# Path to frozen detection graph .pb file, which contains the model that is used
# for object detection.
PATH_TO_CKPT = os.path.join(CWD_PATH,MODEL_NAME,'frozen_inference_graph.pb')

# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH,'training','labelmap.pbtxt')

# Path to image
PATH_TO_IMAGE = os.path.join(CWD_PATH,IMAGE_NAME)

# Number of classes the object detector can identify
NUM_CLASSES = 1

# Load the label map.
# Label maps map indices to category names, so that when our convolution
# network predicts `5`, we know that this corresponds to `king`.
# Here we use internal utility functions, but anything that returns a
# dictionary mapping integers to appropriate string labels would be fine
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)

# Load the Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
    od_graph_def = tf.GraphDef()
    with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
        serialized_graph = fid.read()
        od_graph_def.ParseFromString(serialized_graph)
        tf.import_graph_def(od_graph_def, name='')

    sess = tf.Session(graph=detection_graph)

# Define input and output tensors (i.e. data) for the object detection classifier

# Input tensor is the image
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')

# Output tensors are the detection boxes, scores, and classes
# Each box represents a part of the image where a particular object was detected
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')

# Each score represents level of confidence for each of the objects.
# The score is shown on the result image, together with the class label.
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')

# Number of objects detected
num_detections = detection_graph.get_tensor_by_name('num_detections:0')

# Load image using OpenCV and
# expand image dimensions to have shape: [1, None, None, 3]
# i.e. a single-column array, where each item in the column has the pixel RGB value
image = cv2.imread(PATH_TO_IMAGE)
image_expanded = np.expand_dims(image, axis=0)

# Perform the actual detection by running the model with the image as input
(boxes, scores, classes, num) = sess.run(
[detection_boxes, detection_scores, detection_classes, num_detections],
feed_dict={image_tensor: image_expanded})

# Draw the results of the detection (aka 'visulaize the results')

vis_util.visualize_boxes_and_labels_on_image_array(
        image,
        np.squeeze(boxes),
        np.squeeze(classes).astype(np.int32),
        np.squeeze(scores),
        category_index,
        use_normalized_coordinates=True,
        line_thickness=1,
        min_score_thresh=0.50)

    # All the results have been drawn on image. Now display the image.
cv2.imshow('Object detector', image)

# Press any key to close the image
if cv2.waitKey(0) & 0xFF == ord('q'):
    break
    cv2.imwrite("doraemon_result.png", image)
# Clean up
    cv2.destroyAllWindows()

测试

python Object_detection_image.py

得到doraemon_result.png 结果图片为：
doraemon-detection-result

总结

  • 在 Tensorflow Object Detction API 基础之上
  • 搜集图片、标注图片、转换为tfrecord格式
  • 编辑labelmap.pbtxt和模型配置文件
流程跑通之后的调参工作可以参考相关算法及改进的论文，实践出真知，这个需要时间和项目的磨练与总结和思考。最后，一首歪诗表达我在学习AI过程中的实践观：

初入深度学习，
时常一脸懵逼。
不妨多多实践，
万变自在心田。

绿桂圆
关注
专栏目录
Tensorflow-gpu & Object Detection API & Tensorflow Serving 配置过程
qq_38593211的博客
10-24 823
系统环境：Centos 7.3（ubuntu大同小异，亲测Ubuntu16.04） Nvidia 驱动 1.安装kernel yum -y install gcc kernel-devel kernel-headers 2.导入公共密钥 rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org 3.安装ELRepo rpm ...
树莓派4B与Android之缘——Android应用MiniChat聊天软件
qq_44707992的博客
06-03 2046
MiniChat是一款聊天软件，你可以通过此软件进行聊天， 本应用集成了融云模块，从而实现集成通讯。主要功能是账号注册，登录，好友添加，好友间发送文字、文件信息。
哆啦A梦的数据分析百宝箱
12-21 1183
大雄和朋友们聚在一起。谈论自己的理想。小夫问大雄，你以后想干什么呢？大雄张大嘴巴，说不出来。小静甜甜地说：“大雄，你卖和服吧，这样，我需要什么漂亮的和服，就可以去找你啦。”大雄开心地回应：“好啊，好啊，我以后就做和服生意”。其他人听了，都嘲笑大雄，胖虎一手捂着肚子，一手指着大雄说：“大雄，你...
android QQ第三方登陆 错误 登陆授权失败（错误码：110406）
热门推荐
代码君
05-08 1万+
第一次授权是可以的，第二次就出现这个，我把开发的app名字改一下，又可以了，或者换一下登录的qq号也是可以了，具体原因还没能明白，先记录下来，有遇到问题的朋友可以先试试这个方法
Android原生态实现分享转发功能（分享图片到其他APP）
美奇软件开发工作室
12-06 9111
导读： 之前刚学安卓时，写过一篇“Android调用系统shareAPI实现分享转发功能”的文章，随着安卓版本的迭代更新以及其他APP的优化，安卓的这个shareAPI好像失效了，不怎么好使，已经获取不到有分享功能的APP列表，点击分享也会直接崩溃。并不是说我之前那篇文章的代码有错，只能说是时代有了变化，旧的方法已经不能满足新的需求，我并不打算删掉原来的那篇文章，旧文章地址如下（仅作参考）： Android调用系统shareAPI实现分享转发功能_美奇软件开发工作室-CSDN博客需求分析：在开发APP
tensorflow object detection API models.zip
05-26
TensorFlow Object Detection API 是一个强大的工具包，专为在图像数据上执行目标检测任务而设计。这个API构建在TensorFlow深度学习框架之上，允许开发者和研究人员轻松地训练和部署多种预训练模型，以识别和定位...
基于TensorFlow Object Detection API 进行实时目标检测（基于SSD模型）
最新发布
07-13
【作品名称】：基于TensorFlow Object Detection API 进行实时目标检测（基于SSD模型） 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项...
基于SSD模型的TensorFlow Object Detection API 进行实时目标检测系统.zip
06-20
本次实验使用的是 TensorFlow Object Detection API，根据官方文档介绍，需要安装以下库： Protobuf 3.0.0 Python-tk Pillow 1.0 lxml tf Slim (which is included in the “tensorflow/models/research/“ checkout...
TensorFlow Object Detection API所涉及文件.zip
05-14
TensorFlow Object Detection API所涉及文件，包含Git-2.26.2-64-bit.exe，models.zip，protoc-3.3.0-win32.zip和python-3.5.2-amd64.exe。配套本人的博客《修正<对于谷歌开源的TensorFlow Object Detection API视频...
使用TensorFlow Object Detection API 进行实时目标检测（基于SSD模型）.zip
02-18
在本项目中，我们将探索如何使用TensorFlow Object Detection API进行实时目标检测，特别是基于Single Shot Multibox Detector (SSD)模型。TensorFlow Object Detection API是一个强大的工具，它为开发人员提供了一...
Tensorflow_Object_Detection_with_Tensorflow_2.0:使用带有Google Colab的TensorFlow 2对象检测API的Soccer Player识别
03-30
Tensorflow_Object_Detection_with_Tensorflow_2.0 使用带有Google Colab的TensorFlow 2对象检测API的Soccer Player识别 在此项目中，我使用了Google Colab（用于模型训练），Google Drive（用于存储）和Local machine（用于模型测试）。 创建自己的数据集。 使用labelimg进行注释，并以xml格式保存。 使用脚本将XML转换为CSV。 此脚本将用于将csv转换为TFRecord格式。 我使用ssd_mobilenet_v2_320x320_coco17_tpu预训练模型进行训练和配置，如下所示： num_classes：3 fine_tune_checkpoint：“ ssd_mobilenet_v2_320x320_coco17_tpu-8 / checkpoint
TensorflowAPI的使用以及 使用自己的数据集进行目标检测
weixin_44268208的博客
08-03 461
TensorflowAPI的使用以及 使用自己的数据集进行目标检测 参考链接： 中文： 中文参考链接 英文：英文参考链接 一：下载对应的模型 模型下载地址： 上网自行搜索COCO-trained models {#coco-models}选择对应的模型 在这里我下载使用的是 faster_rcnn_inception_v2_coco_2018_01_28.tar.gz 并将faster_rcnn_inception_v2_coco_2018_01_28文件夹解压缩至C：\ tensorflow1 \
机械臂项目2 不同数据集和模型效果比较
CoCoNutNut的博客
07-29 987
数据集 原图：100 扩充后：600 训练集：480 测试集：120 模型 ssdlite_mobilenet_v2_coco_2018_05_09 I0729 11:48:05.138240 4638664128 learning.py:507] global step 1: loss = 17.8064 (15.097 sec/step) I0729 11:48:08.143901 4638...
faster-rcnn参数介绍
wubingwei12的博客
03-05 4417
最近想写的东西有点多，先随便写点吧，也让我屡屡思路——说白了就是太懒 model { faster_rcnn { num_classes: 3 //获取要识别的类数 image_resizer { keep_aspect_ratio_resizer { min_dimension: 128 //最小的图片像素 max_dime...
TensorFlow Object Detection API 技术手册（3）——运行Demo程序
Friedrich Yuan的博客
11-07 6493
TensorFlow Object Detection API 技术手册（3）——运行Demo程序（一）打开示例程序（二）代码解读及修正（三）使用其他预训练模型（四）使用预训练模型预测自己的图片 （一）打开示例程序 在（research/object_detection/）目录下按住shift键，点击右键打开powershell窗口，输入命令： &amp;amp;amp;amp;gt;&amp;amp;amp;amp;gt;&amp;amp;amp;amp;gt;jupyter no
一、Tensorflow 2.0版本以上：Object_detection API【运行样例】
菜鸟要爱学习
04-28 1278
目标检测之运行样例
【tensorflow2】object detection API 环境搭建
qq_44703886的博客
09-29 1200
前面刚写完tensorflow1.15+ssd_mobilenet_v2的环境搭建，发现tensorflow2.0+早已经支持Tensorflow object detection API，因此肯定要与时俱进，下面就开始tensorflow2.0的环境搭建吧。 首先申明，以下搭建步骤采纳同门师弟博客，文末附上原文链接，但因人而异，还是些许步骤不同，在此做个人的环境搭建总结。 1.环境创建 conda create -n tf2 pip python=3.8 conda activate tf2 # 激活
tensorflow object detection api macos
02-01
TensorFlow Object Detection API 是一个开源项目，它提供了一系列基于 TensorFlow 的工具和库，用于实现目标检测任务。对于 macOS 系统，我们可以通过以下步骤来使用 TensorFlow Object Detection API： 1. 安装 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值