【SSD】用caffe-ssdフレームワークに付属のVGGネットワークで自分のデータセットをトレーニングする

前言#

オンラインにあるチュートリアルはほとんどが翻訳されたものか、直接 VOC データセットを使用しています。

私のデータセットは ILSVRC、ImageNet から取得したもので、色チャンネルが統一されておらず、xml ファイルの内容形式も統一されていません。

全体のプロセスで多くの問題に直面し、多くのスクリプトツールも作成しました。

今、私はそれを一つ一つ記録し、人類のために役立てます！

一、データセットの選定#

まず、ImageNet からカップの画像をすべてダウンロードしました。

次に、ILSVRC2011、ILSVRC2012、ILSVRC2013、ILSVRC2015 データセットから xml 内のカップのコードを検索して、カップを含むデータセットを選びました。

スクリプトツールの参考：【Shell】ILSVRC_DET データセットから特定のクラスの画像と注釈ファイルを抽出する

二、xml ファイルの処理#

私はカップの情報だけが必要で、他の物体の情報は xml ファイルから削除する必要があります。そうしないと、lmdb ファイルを生成する際にエラーが発生し、「Unknown name: xxxxxxxx」と表示されます。xxxx はカップ以外の物体のコードです。

多くの方法を試しましたが、詳細な手順は以下の通りです：

Annotations フォルダの名前を Annos に変更します。
新しい空のフォルダを Annotations という名前で作成します。
以下の名前の「delete_by_name.py」という python ツールのコードを修正します。if not の後の内容だけを変更する必要があります。引用符内は保持したいデータのコードです。
python ツールを実行します。

#!/usr/bin/env python2

-- coding: utf-8 --#

"""
Created on Tue Oct 31 10:03:03 2017

@author: hans

http://blog.csdn.net/renhanchi
"""

import os
import xml.etree.ElementTree as ET

origin_ann_dir = 'Annos/'
new_ann_dir = 'Annotations/'

for dirpaths, dirnames, filenames in os.walk(origin_ann_dir):
for filename in filenames:
if os.path.isfile(r'%s%s' %(origin_ann_dir, filename)):
origin_ann_path = os.path.join(r'%s%s' %(origin_ann_dir, filename))
new_ann_path = os.path.join(r'%s%s' %(new_ann_dir, filename))
tree = ET.parse(origin_ann_path)
```
   root = tree.getroot()
   for object in root.findall('object'):
     name = str(object.find('name').text)
     if not (name == "n03147509" or \
             name == "n03216710" or \
             name == "n03438257" or \
             name == "n03797390" or \
             name == "n04559910" or \
             name == "n07930864"):
       root.remove(object)

   tree.write(new_ann_path)
```

三、訓練セットと検証セットの txt ファイルを生成する#

まず、doc という名前のフォルダを新しく作成します。

以下の「cup_list.sh」という名前のコードは、私が最終的に使用したものではなく、皆さんは自分の状況に応じて適宜修正してください。

#!/bin/sh

classes=(images anno)
root_dir=$(cd $( dirname ${BASH_SOURCE[0]} ) && pwd )

for dataset in train val
do
        if [ $dataset == "train" ]
        then
                data_dir=(WIDER_train)
        fi
        if [ $dataset == "val" ]
        then
                data_dir=(WIDER_val)
        fi
        for cla in ${data_dir[@]}
        do
	        for class in ${classes[@]}
	        do
		        # ls -R $cla/$class/* >> ${class}_${dataset}.txt
                        find ./$cla/$class/ -name "*.jpg" >> ${class}_${dataset}.txt
	        done

                for class in ${classes[@]}
                do
                        # ls -R $cla/$class/* >> ${class}_${dataset}.txt
                        find ./$cla/$class/ -name "*.xml" >> ${class}_${dataset}.txt
                done
        done
        paste -d' ' images_${dataset}.txt anno_${dataset}.txt >> temp_${dataset}.txt
        cat temp_${dataset}.txt | awk 'BEGIN{srand()}{print rand()"\t"$0}' | sort -k1,1 -n | cut -f2- > $dataset.txt
        if [ $dataset == "val" ]
        then
                /home/hans/caffe-ssd/build/tools/get_image_size $root_dir $dataset.txt $dataset"_name_size.txt"
        fi
        rm temp_${dataset}.txt
        rm images_${dataset}.txt
        rm anno_${dataset}.txt
done

四、labelmap_cup.prototxt を書く#

このファイルは doc ディレクトリに置きます。

注意すべき点がいくつかあります。

1.label 0 は必ず background でなければなりません。

2. カップだけを検出していますが、xml ファイル内のカップの name コードは複数あります。

最初はすべての label を 1 に設定しましたが、lmdb ファイルを生成する際にエラーが発生しました。

私は順番に書き続けるしかありませんでしたが、大した問題ではありません。1 から 6 までがカップであることが分かれば大丈夫です。

五、lmdb ファイルを生成する#

最初に上記で述べた Unknown name エラーが発生し、xml を修正することで解決しました。

その後、caffe モジュールの Symbol エラーが発生しましたが、私に従っていれば大丈夫です。

まず、caffe-ssd/scripts/create_annoset.py というファイルを修正します。

次に cup_data.sh を実行します。

cur_dir=$(cd $( dirname ${BASH_SOURCE[0]} ) && pwd )
root_dir=/home/hans/caffe-ssd

redo=1
data_root_dir="${cur_dir}"
dataset_name="doc"
mapfile="${cur_dir}/doc/labelmap_cup.prototxt"
anno_type="detection"
db="lmdb"
min_dim=0
max_dim=0
width=0
height=0

extra_cmd="--encode-type=JPEG --encoded"
if [ $redo ]
then
  extra_cmd="$extra_cmd --redo"
fi
for subset in train val
do
  python $root_dir/scripts/create_annoset.py --anno-type=$anno_type --label-map-file=$mapfile --min-dim=$min_dim \
--max-dim=$max_dim --resize-width=$width --resize-height=$height --check-label $extra_cmd $data_root_dir \
$cur_dir/$dataset_name/$subset.txt $data_root_dir/$dataset_name/$subset"_"$db ln/
done
rm -rf  ln/

六、訓練#

まず、事前訓練モデルをダウンロードして doc ディレクトリに置きます。

ダウンロードリンク：cs.unc.edu/~wliu/projects/ParseNet/VGG_ILSVRC_16_layers_fc_reduced.caffemodel

訓練コードの修正は本当に大変な作業で、パスが多く、問題も多いです。幸い、github の issues は非常に役立ちました。

まず、私の ssd_pascal.py コードを公開します：

from __future__ import print_function
import sys
sys.path.append("/home/hans/caffe-ssd/python")  #####改
import caffe
from caffe.model_libs import *
from google.protobuf import text_format

import math
import os
import shutil
import stat
import subprocess

# "base"ネットワーク（例：VGGNetやInception）の上に追加のレイヤーを追加します。
def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):
    use_relu = True

    # 追加の畳み込み層を追加します。
    # 19 x 19
    from_layer = net.keys()[-1]

    # TODO(weiliu89): 重複を避けるために最後のレイヤーを使用して名前を構築します。
    # 10 x 10
    out_layer = "conv6_1"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 1, 0, 1,
        lr_mult=lr_mult)

    from_layer = out_layer
    out_layer = "conv6_2"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 512, 3, 1, 2,
        lr_mult=lr_mult)

    # 5 x 5
    from_layer = out_layer
    out_layer = "conv7_1"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 128, 1, 0, 1,
      lr_mult=lr_mult)

    from_layer = out_layer
    out_layer = "conv7_2"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 3, 1, 2,
      lr_mult=lr_mult)

    # 3 x 3
    from_layer = out_layer
    out_layer = "conv8_1"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 128, 1, 0, 1,
      lr_mult=lr_mult)

    from_layer = out_layer
    out_layer = "conv8_2"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 3, 0, 1,
      lr_mult=lr_mult)

    # 1 x 1
    from_layer = out_layer
    out_layer = "conv9_1"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 128, 1, 0, 1,
      lr_mult=lr_mult)

    from_layer = out_layer
    out_layer = "conv9_2"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 3, 0, 1,
      lr_mult=lr_mult)

    return net


### 以下のパラメータを適宜修正してください ###
# caffeコードを含むディレクトリ。
# スクリプトをCAFFE_ROOTで実行していると仮定します。
caffe_root = "/home/hans/caffe-ssd"    #####改

# すべてのファイルを生成した後すぐに訓練を開始したい場合はtrueに設定します。
run_soon = True
# 最近保存されたスナップショットから読み込みたい場合はtrueに設定します。
# そうでなければ、以下で定義されたpretrain_modelから読み込みます。
resume_training = True
# trueの場合、古いモデルファイルを削除します。
remove_old_models = False

# 訓練データ用のデータベースファイル。data/VOC0712/create_data.shによって作成されます。
train_data = "/home/hans/data/ImageNet/Detection/cup/doc/train_lmdb"   #########改
# テストデータ用のデータベースファイル。data/VOC0712/create_data.shによって作成されます。
test_data = "/home/hans/data/ImageNet/Detection/cup/doc/val_lmdb"    ########改
# バッチサンプラーを指定します。
resize_width = 300
resize_height = 300
resize = "{}x{}".format(resize_width, resize_height)
batch_sampler = [
        {
                'sampler': {
                        },
                'max_trials': 1,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.1,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.3,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.5,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.7,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.9,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'max_jaccard_overlap': 1.0,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        ]
train_transform_param = {
        'mirror': True,
        'mean_value': [104, 117, 123],
        'force_color': True,  ####改
        'resize_param': {
                'prob': 1,
                'resize_mode': P.Resize.WARP,
                'height': resize_height,
                'width': resize_width,
                'interp_mode': [
                        P.Resize.LINEAR,
                        P.Resize.AREA,
                        P.Resize.NEAREST,
                        P.Resize.CUBIC,
                        P.Resize.LANCZOS4,
                        ],
                },
        'distort_param': {
                'brightness_prob': 0.5,
                'brightness_delta': 32,
                'contrast_prob': 0.5,
                'contrast_lower': 0.5,
                'contrast_upper': 1.5,
                'hue_prob': 0.5,
                'hue_delta': 18,
                'saturation_prob': 0.5,
                'saturation_lower': 0.5,
                'saturation_upper': 1.5,
                'random_order_prob': 0.0,
                },
        'expand_param': {
                'prob': 0.5,
                'max_expand_ratio': 4.0,
                },
        'emit_constraint': {
            'emit_type': caffe_pb2.EmitConstraint.CENTER,
            }
        }
test_transform_param = {
        'mean_value': [104, 117, 123],
        'force_color': True,    ####改
        'resize_param': {
                'prob': 1,
                'resize_mode': P.Resize.WARP,
                'height': resize_height,
                'width': resize_width,
                'interp_mode': [P.Resize.LINEAR],
                },
        }

# もしtrueの場合、すべての新しく追加されたレイヤーにバッチノーマル化を使用します。
# 現在、非バッチノーマルバージョンのみがテストされています。
use_batchnorm = False
lr_mult = 1
# 異なる初期学習率を使用します。
if use_batchnorm:
    base_lr = 0.0004
else:
    # バッチサイズ = 1、GPU数 = 1の学習率。
    base_lr = 0.00004

root = "/home/hans/data/ImageNet/Detection/cup"    ####改
# ジョブ名を変更したい場合は修正してください。
job_name = "SSD_{}".format(resize)   ####改
# モデルの名前。変更したい場合は修正してください。
model_name = "VGG_CUP_{}".format(job_name)    ####改

# モデルの.prototxtファイルを保存するディレクトリ。
save_dir = "{}/doc/{}".format(root, job_name)    ####改
# モデルのスナップショットを保存するディレクトリ。
snapshot_dir = "{}/models/{}".format(root, job_name)    ####改
# ジョブスクリプトとログファイルを保存するディレクトリ。
job_dir = "{}/jobs/{}".format(root, job_name)    ####改
# 検出結果を保存するディレクトリ。
output_result_dir = "{}/results/{}".format(root, job_name)    ####改

# モデル定義ファイル。
train_net_file = "{}/train.prototxt".format(save_dir)
test_net_file = "{}/test.prototxt".format(save_dir)
deploy_net_file = "{}/deploy.prototxt".format(save_dir)
solver_file = "{}/solver.prototxt".format(save_dir)
# スナップショットプレフィックス。
snapshot_prefix = "{}/{}".format(snapshot_dir, model_name)
# ジョブスクリプトパス。
job_file = "{}/{}.sh".format(job_dir, model_name)

# テスト画像の名前とサイズを保存します。data/VOC0712/create_list.shによって作成されます。
name_size_file = "{}/doc/val_name_size.txt".format(root)    ####改
# 事前訓練モデル。完全畳み込みの減少（アトラス）VGGNetを使用します。
pretrain_model = "{}/doc/VGG_ILSVRC_16_layers_fc_reduced.caffemodel".format(root)    ####改
# LabelMapItemを保存します。
label_map_file = "{}/doc/labelmap_cup.prototxt".format(root)    ####改

# MultiBoxLossパラメータ。
num_classes = 7    ####改
share_location = True
background_label_id=0
train_on_diff_gt = True
normalization_mode = P.Loss.VALID
code_type = P.PriorBox.CENTER_SIZE
ignore_cross_boundary_bbox = False
mining_type = P.MultiBoxLoss.MAX_NEGATIVE
neg_pos_ratio = 3.
loc_weight = (neg_pos_ratio + 1.) / 4.
multibox_loss_param = {
    'loc_loss_type': P.MultiBoxLoss.SMOOTH_L1,
    'conf_loss_type': P.MultiBoxLoss.SOFTMAX,
    'loc_weight': loc_weight,
    'num_classes': num_classes,
    'share_location': share_location,
    'match_type': P.MultiBoxLoss.PER_PREDICTION,
    'overlap_threshold': 0.5,
    'use_prior_for_matching': True,
    'background_label_id': background_label_id,
    'use_difficult_gt': train_on_diff_gt,
    'mining_type': mining_type,
    'neg_pos_ratio': neg_pos_ratio,
    'neg_overlap': 0.5,
    'code_type': code_type,
    'ignore_cross_boundary_bbox': ignore_cross_boundary_bbox,
    }
loss_param = {
    'normalization': normalization_mode,
    }

# プライヤーを生成するためのパラメータ。
# 入力画像の最小寸法
min_dim = 300
# conv4_3 ==> 38 x 38
# fc7 ==> 19 x 19
# conv6_2 ==> 10 x 10
# conv7_2 ==> 5 x 5
# conv8_2 ==> 3 x 3
# conv9_2 ==> 1 x 1
mbox_source_layers = ['conv4_3', 'fc7', 'conv6_2', 'conv7_2', 'conv8_2', 'conv9_2']
# パーセントで%
min_ratio = 20
max_ratio = 90
step = int(math.floor((max_ratio - min_ratio) / (len(mbox_source_layers) - 2)))
min_sizes = []
max_sizes = []
for ratio in xrange(min_ratio, max_ratio + 1, step):
  min_sizes.append(min_dim * ratio / 100.)
  max_sizes.append(min_dim * (ratio + step) / 100.)
min_sizes = [min_dim * 10 / 100.] + min_sizes
max_sizes = [min_dim * 20 / 100.] + max_sizes
steps = [8, 16, 32, 64, 100, 300]
aspect_ratios = [[2], [2, 3], [2, 3], [2, 3], [2], [2]]
# conv4_3をL2正規化します。
normalizations = [20, -1, -1, -1, -1, -1]
# プライヤーbboxをエンコード/デコードするために使用される分散。
if code_type == P.PriorBox.CENTER_SIZE:
  prior_variance = [0.1, 0.1, 0.2, 0.2]
else:
  prior_variance = [0.1]
flip = True
clip = False

# ソルバーパラメータ。
# 使用するGPUを定義します。
gpus = "7"    ####改
gpulist = gpus.split(",")
num_gpus = len(gpulist)

# ミニバッチを異なるGPUに分割します。
batch_size = 32
accum_batch_size = 32
iter_size = accum_batch_size / batch_size
solver_mode = P.Solver.CPU
device_id = 0
batch_size_per_device = batch_size
if num_gpus > 0:
  batch_size_per_device = int(math.ceil(float(batch_size) / num_gpus))
  iter_size = int(math.ceil(float(accum_batch_size) / (batch_size_per_device * num_gpus)))
  solver_mode = P.Solver.GPU
  device_id = int(gpulist[0])

if normalization_mode == P.Loss.NONE:
  base_lr /= batch_size_per_device
elif normalization_mode == P.Loss.VALID:
  base_lr *= 25. / loc_weight
elif normalization_mode == P.Loss.FULL:
  # おおよそ、画像ごとに2000のプライヤーbboxがあります。
  # TODO(weiliu89): 正確なプライヤーの数を見積もります。
  base_lr *= 2000.

# 全テストセットで評価します。
num_test_image = 2000    ####改
test_batch_size = 8
# 理想的にはtest_batch_sizeはnum_test_imageで割り切れるべきで、
# そうでない場合、mAPは真の値からわずかにずれることになります。
test_iter = int(math.ceil(float(num_test_image) / test_batch_size))

solver_param = {
    # 訓練パラメータ
    'base_lr': base_lr,
    'weight_decay': 0.0005,
    'lr_policy': "multistep",
    'stepvalue': [80000, 100000, 120000],
    'gamma': 0.1,
    'momentum': 0.9,
    'iter_size': iter_size,
    'max_iter': 120000,
    'snapshot': 80000,
    'display': 10,
    'average_loss': 10,
    'type': "SGD",
    'solver_mode': solver_mode,
    'device_id': device_id,
    'debug_info': False,
    'snapshot_after_train': True,
    # テストパラメータ
    'test_iter': [test_iter],
    'test_interval': 100,
    'eval_type': "detection",
    'ap_version': "11point",
    'test_initialization': True,
    }

# 検出出力を生成するためのパラメータ。
det_out_param = {
    'num_classes': num_classes,
    'share_location': share_location,
    'background_label_id': background_label_id,
    'nms_param': {'nms_threshold': 0.45, 'top_k': 400},
    'save_output_param': {
        'output_directory': output_result_dir,
        'output_name_prefix': "comp4_det_test_",
        'output_format': "VOC",
        'label_map_file': label_map_file,
        'name_size_file': name_size_file,
        'num_test_image': num_test_image,
        },
    'keep_top_k': 200,
    'confidence_threshold': 0.01,
    'code_type': code_type,
    }

# 検出結果を評価するためのパラメータ。
det_eval_param = {
    'num_classes': num_classes,
    'background_label_id': background_label_id,
    'overlap_threshold': 0.5,
    'evaluate_difficult_gt': False,
    'name_size_file': name_size_file,
    }

### 以下の内容は変更する必要がないことを願っています ###
# ファイルをチェックします。
check_if_exist(train_data)
check_if_exist(test_data)
check_if_exist(label_map_file)
check_if_exist(pretrain_model)
make_if_not_exist(save_dir)
make_if_not_exist(job_dir)
make_if_not_exist(snapshot_dir)

# 訓練ネットを作成します。
net = caffe.NetSpec()
net.data, net.label = CreateAnnotatedDataLayer(train_data, batch_size=batch_size_per_device,
        train=True, output_label=True, label_map_file=label_map_file,
        transform_param=train_transform_param, batch_sampler=batch_sampler)

VGGNetBody(net, from_layer='data', fully_conv=True, reduced=True, dilated=True,
    dropout=False)

AddExtraLayers(net, use_batchnorm, lr_mult=lr_mult)

mbox_layers = CreateMultiBoxHead(net, data_layer='data', from_layers=mbox_source_layers,
        use_batchnorm=use_batchnorm, min_sizes=min_sizes, max_sizes=max_sizes,
        aspect_ratios=aspect_ratios, steps=steps, normalizations=normalizations,
        num_classes=num_classes, share_location=share_location, flip=flip, clip=clip,
        prior_variance=prior_variance, kernel_size=3, pad=1, lr_mult=lr_mult)

# MultiBoxLossLayerを作成します。
name = "mbox_loss"
mbox_layers.append(net.label)
net[name] = L.MultiBoxLoss(*mbox_layers, multibox_loss_param=multibox_loss_param,
        loss_param=loss_param, include=dict(phase=caffe_pb2.Phase.Value('TRAIN')),
        propagate_down=[True, True, False, False])

with open(train_net_file, 'w') as f:
    print('name: "{}_train"'.format(model_name), file=f)
    print(net.to_proto(), file=f)
shutil.copy(train_net_file, job_dir)

# テストネットを作成します。
net = caffe.NetSpec()
net.data, net.label = CreateAnnotatedDataLayer(test_data, batch_size=test_batch_size,
        train=False, output_label=True, label_map_file=label_map_file,
        transform_param=test_transform_param)

VGGNetBody(net, from_layer='data', fully_conv=True, reduced=True, dilated=True,
    dropout=False)

AddExtraLayers(net, use_batchnorm, lr_mult=lr_mult)

mbox_layers = CreateMultiBoxHead(net, data_layer='data', from_layers=mbox_source_layers,
        use_batchnorm=use_batchnorm, min_sizes=min_sizes, max_sizes=max_sizes,
        aspect_ratios=aspect_ratios, steps=steps, normalizations=normalizations,
        num_classes=num_classes, share_location=share_location, flip=flip, clip=clip,
        prior_variance=prior_variance, kernel_size=3, pad=1, lr_mult=lr_mult)

conf_name = "mbox_conf"
if multibox_loss_param["conf_loss_type"] == P.MultiBoxLoss.SOFTMAX:
  reshape_name = "{}_reshape".format(conf_name)
  net[reshape_name] = L.Reshape(net[conf_name], shape=dict(dim=[0, -1, num_classes]))
  softmax_name = "{}_softmax".format(conf_name)
  net[softmax_name] = L.Softmax(net[reshape_name], axis=2)
  flatten_name = "{}_flatten".format(conf_name)
  net[flatten_name] = L.Flatten(net[softmax_name], axis=1)
  mbox_layers[1] = net[flatten_name]
elif multibox_loss_param["conf_loss_type"] == P.MultiBoxLoss.LOGISTIC:
  sigmoid_name = "{}_sigmoid".format(conf_name)
  net[sigmoid_name] = L.Sigmoid(net[conf_name])
  mbox_layers[1] = net[sigmoid_name]

net.detection_out = L.DetectionOutput(*mbox_layers,
    detection_output_param=det_out_param,
    include=dict(phase=caffe_pb2.Phase.Value('TEST')))
net.detection_eval = L.DetectionEvaluate(net.detection_out, net.label,
    detection_evaluate_param=det_eval_param,
    include=dict(phase=caffe_pb2.Phase.Value('TEST')))

with open(test_net_file, 'w') as f:
    print('name: "{}_test"'.format(model_name), file=f)
    print(net.to_proto(), file=f)
shutil.copy(test_net_file, job_dir);

# デプロイネットを作成します。
# テストネットから最初と最後のレイヤーを削除します。
deploy_net = net
with open(deploy_net_file, 'w') as f:
    net_param = deploy_net.to_proto()
    # テストネットから最初（AnnotatedData）と最後（DetectionEvaluate）レイヤーを削除します。
    del net_param.layer[0]
    del net_param.layer[-1]
    net_param.name = '{}_deploy'.format(model_name)
    net_param.input.extend(['data'])
    net_param.input_shape.extend([
        caffe_pb2.BlobShape(dim=[1, 3, resize_height, resize_width])])
    print(net_param, file=f)
shutil.copy(deploy_net_file, job_dir)

# ソルバーを作成します。
solver = caffe_pb2.SolverParameter(
        train_net=train_net_file,
        test_net=[test_net_file],
        snapshot_prefix=snapshot_prefix,
        **solver_param)

with open(solver_file, 'w') as f:
    print(solver, file=f)
shutil.copy(solver_file, job_dir)

max_iter = 0
# 最も最近のスナップショットを見つけます。
for file in os.listdir(snapshot_dir):
  if file.endswith(".solverstate"):
    basename = os.path.splitext(file)[0]
    iter = int(basename.split("{}_iter_".format(model_name))[1])
    if iter > max_iter:
      max_iter = iter

train_src_param = '--weights="{}" \\\n'.format(pretrain_model)
if resume_training:
  if max_iter > 0:
    train_src_param = '--snapshot="{}_iter_{}.solverstate" \\\n'.format(snapshot_prefix, max_iter)

if remove_old_models:
  # max_iterより小さいスナップショットを削除します。
  for file in os.listdir(snapshot_dir):
    if file.endswith(".solverstate"):
      basename = os.path.splitext(file)[0]
      iter = int(basename.split("{}_iter_".format(model_name))[1])
      if max_iter > iter:
        os.remove("{}/{}".format(snapshot_dir, file))
    if file.endswith(".caffemodel"):
      basename = os.path.splitext(file)[0]
      iter = int(basename.split("{}_iter_".format(model_name))[1])
      if max_iter > iter:
        os.remove("{}/{}".format(snapshot_dir, file))

# ジョブファイルを作成します。
with open(job_file, 'w') as f:
  f.write('cd {}\n'.format(caffe_root))
  f.write('./build/tools/caffe train \\\n')
  f.write('--solver="{}" \\\n'.format(solver_file))
  f.write(train_src_param)
  if solver_param['solver_mode'] == P.Solver.GPU:
    f.write('--gpu {} 2>&1 | tee {}/{}.log\n'.format(gpus, job_dir, model_name))
  else:
    f.write('2>&1 | tee {}/{}.log\n'.format(job_dir, model_name))

# pythonスクリプトをjob_dirにコピーします。
py_file = os.path.abspath(__file__)
shutil.copy(py_file, job_dir)

# ジョブを実行します。
os.chmod(job_file, stat.S_IRWXU)
if run_soon:
  subprocess.call(job_file, shell=True)

上記の 237 行から 267 行はゆっくりと進めてください。もちろん、私のフォルダ構成に従っている場合は、237 行だけを修正すれば大丈夫です。

179 行を修正するのは、訓練段階で「OpenCV Error: Assertion failed ((scn == 3 || scn == 4) && (depth == CV_8U ||............" というエラーが発生したためです。

216 行を修正するのは、検証段階で「Check failed:std::equal (top_shape.begin ()+1,top_shape.begin ()+4,shape.begin ()+1)」というエラーが発生したためです。

270 行を修正するのは、クラス数 + 1 です。このクラス数は labelmap_cup.prototxt の最大インデックス + 1 です。

363 行を修正するのは、テストセットの画像数です。

他に修正が必要なものは上記のコードを見てください。すべてマークしています。

残りのパラメータ調整は自分でコードを見て修正してください。難しくはありません。

最後に訓練を開始します。

七、訓練出力の可視化（2017.11.02）#

以前 caffe 用に作成したものを修正しました。

一つの変更点は、出力の変動が大きすぎる場合に、一定の倍数で平均を取るための倍数 time の変数を追加したことです。

最初のパラメータは log ファイルのパスです。

コード内の display と test_interval の値を solver.prototxt と一致させる必要があります。

time は倍数で、元のデータ曲線を見たい場合は 1 に設定します。

コード：

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Thu Nov  2 14:35:42 2017

@author: hans

http://blog.csdn.net/renhanchi
"""

import matplotlib.pyplot as plt
import numpy as np
import commands
import argparse

parser = argparse.ArgumentParser()
parser.add_argument(
    '-p','--log_path',
    type = str,
    default = '',
    help = """\
    logファイルへのパス\
    """
)

FLAGS = parser.parse_args()

train_log_file = FLAGS.log_path


display = 10 #solver
test_interval = 100 #solver

time = 5

train_output = commands.getoutput("cat " + train_log_file + " | grep 'Train net output #0' | awk '{print $11}'")  #train mbox_loss
accu_output = commands.getoutput("cat " + train_log_file + " | grep 'Test net output #0' | awk '{print $11}'") #test detection_eval

train_loss = train_output.split("\n")
test_accu = accu_output.split("\n")
  
def reduce_data(data):
  iteration = len(data)/time*time
  _data = data[0:iteration]
  if time > 1:
    data_ = []
    for i in np.arange(len(data)/time):
      sum_data = 0
      for j in np.arange(time):
        index = i*time + j
        sum_data += float(_data[index])
      data_.append(sum_data/float(time))
  else:
    data_ = data
  return data_

train_loss_ = reduce_data(train_loss)
test_accu_ = reduce_data(test_accu)

_,ax1 = plt.subplots()
ax2 = ax1.twinx()

ax1.plot(time*display*np.arange(len(train_loss_)), train_loss_)
ax2.plot(time*test_interval*np.arange(len(test_accu_)), test_accu_, 'r')

ax1.set_xlabel('Iteration')
ax1.set_ylabel('Train Loss')
ax2.set_ylabel('Test Accuracy')
plt.show()

八、モデルの効果をテストする（2017.11.03）#

モデルの訓練が完了したら、最終的な効果を確認します。

元の著者が提供した python ツールは使いにくいと感じました。自分で確認することもできますが、名前は「ssd_pascal_webcam.py」です。

以下は手動で検出を行う手順です：

まず、deploy.prototxt、labelmap_cup.prototxt、xxxxx.caffemodel の 3 つのファイルを準備します。

deploy.prototxt ファイルの最初のレイヤーと最後のレイヤーを修正します：

name: "VGG_VOC0712_SSD_300x300_test"
layer {
  name: "data"
  type: "VideoData"
  top: "data"
  transform_param {
    mean_value: 104.0
    mean_value: 117.0
    mean_value: 123.0
    resize_param {
      prob: 1.0
      resize_mode: WARP
      height: 300
      width: 300
      interp_mode: LINEAR
    }
  }
  data_param {
    batch_size: 1
  }
  video_data_param {
    video_type: WEBCAM
    device_id: 0 ####カメラ番号
    skip_frames: 0 ####フレームをスキップするか
  }
}
layer {
  name: "conv1_1"
  type: "Convolution"
  bottom: "data"
  top: "conv1_1"
...
...
...
...
...
...
layer {
  name: "mbox_conf_flatten"
  type: "Flatten"
  bottom: "mbox_conf_softmax"
  top: "mbox_conf_flatten"
  flatten_param {
    axis: 1
  }
}
layer {
  name: "detection_out"
  type: "DetectionOutput"
  bottom: "mbox_loc"
  bottom: "mbox_conf_flatten"
  bottom: "mbox_priorbox"
  bottom: "data"
  top: "detection_out"
  include {
    phase: TEST
  }
  transform_param {
    mean_value: 104.0
    mean_value: 117.0
    mean_value: 123.0
    resize_param {
      prob: 1.0
      resize_mode: WARP
      height: 480  ####カメラの高さと幅を設定できます。大きく表示されます。
      width: 640
      interp_mode: LINEAR
    }
  }
  detection_output_param {
    num_classes: 7  ####クラス数 + 1
    share_location: true
    background_label_id: 0
    nms_param {
      nms_threshold: 0.449999988079
      top_k: 400
    }
    save_output_param {
      label_map_file: "labelmap_cup.prototxt"  #####改
    }
    code_type: CENTER_SIZE
    keep_top_k: 200
    confidence_threshold: 0.899999976158
    visualize: true
    visualize_threshold: 0.600000023842  ###この値よりも信頼度が高い結果のみを表示
  }
}
layer {
  name: "slience"
  type: "Silence"
  bottom: "detection_out"
  include {
    phase: TEST
  }
}

以下はテスト用のスクリプト内容：

/home/hans/caffe-ssd/build/tools/caffe test \
--model="deploy.prototxt" \
--weights="xxxxx.caffemodel" \
--iterations="536870911" \
--gpu 0

iteration は int 型の最大値です。

標準的なカップは非常に安定しており、時々柱状物を検出します。

現在のモデルは最終的なものではなく、私の検証セットでの detection_eval は約 0.72 です。

後記#

このブログは引き続き更新します。出力結果の分析、可視化、ネットワークモデルの変更などを含みます。

今回は VGGnet を使用しましたが、今後は mobileNet も使用する予定です。

一つの問題は平均計算で、caffe に付属の creat_mean.sh が使いやすいかどうかはまだテストしていません。

----【2017.11.20 平均問題の解決】--------------------------------------

自動生成の make_mean.sh では平均を求めることができず、lmdb 変換ツールが 2 つあることが判明しました。一つは注釈付き、もう一つは注釈なしです。ssd が使用するのは注釈付きの変換ツールです。

より具体的な内容については、末尾を参照してください：【SSD】用 caffe-ssd 框架 MobileNet ネットワークで自分のデータセットを訓練する

---- 【2017.11.2 更新】 ----- 複数 GPU----------------------------------------

このフレームワークは直接複数の GPU で実行できるようです。まだ検証していません。

私のサーバーにはすでに nccl がインストールされていますが、make 時にすべてが正常にコンパイルされたと通知されました。

私はあまり気にせず、3 つの GPU で試してみましたが、問題ありませんでした！ただし、centos kernel: BUG: soft lockup - CPU#3 stuck for 23s! というエラーが発生しました。
[kworker/3:0:14900]

驚きました！別の GPU がデータを処理していました。

その後、2 つの GPU で実行したところ、0 回目のイテレーションは正常でしたが、最初のイテレーションで loss が nan になりました。何度かパラメータを変更しましたが、効果はありませんでした。

やはり 1 つのカードで実行するのが良いでしょう～～