質問編集履歴

一部修正

2020/02/06 15:16

投稿

gorigori123

スコア12

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -25,467 +25,3 @@
      total [..................................................]  0.33%
 this epoch [#############################.....................] 59.17%
-```Python
-# -*- coding: utf-8 -*-
-"""
-(ChainerCV: MIT License)
-URL: https://github.com/chainer/chainercv/blob/master/examples/ssd/train.py
-"""
-#import sys
-#sys.setdefaultencoding('utf-8')
-from __future__ import division, print_function
-import argparse
-import copy
-import chainer
-import numpy as np
-from chainer import serializers, training
-from chainer.datasets import TransformDataset
-from chainer.optimizer import WeightDecay
-from chainer.training import extensions, triggers
-from chainercv import transforms
-from chainercv.datasets import VOCBboxDataset, voc_bbox_label_names
-from chainercv.extensions import DetectionVOCEvaluator
-from chainercv.links import SSD512
-from chainercv.links.model.ssd import (GradientScaling, multibox_loss,
-                                       random_crop_with_bbox_constraints,
-                                       random_distort,
-                                       resize_with_random_interpolation)
-from image_pyramid_detection_src.bbox_dataset_from_csv import \
-    BboxDatasetFromCsv
-class ConcatenatedDataset(chainer.dataset.DatasetMixin):
-    def __init__(self, *datasets):
-        self._datasets = datasets
-    def __len__(self):
-        return sum(len(dataset) for dataset in self._datasets)
-    def get_example(self, i):
-        if i < 0:
-            raise IndexError
-        for dataset in self._datasets:
-            if i < len(dataset):
-                return dataset[i]
-            i -= len(dataset)
-        raise IndexError
-class MultiboxTrainChain(chainer.Chain):
-    def __init__(self, model, alpha=1, k=3):
-        super(MultiboxTrainChain, self).__init__()
-        with self.init_scope():
-            self.model = model
-        self.alpha = alpha
-        self.k = k
-    def __call__(self, imgs, gt_mb_locs, gt_mb_labels):
-        mb_locs, mb_confs = self.model(imgs)
-        loc_loss, conf_loss = multibox_loss(
-            mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, self.k)
-        loss = loc_loss * self.alpha + conf_loss
-        chainer.reporter.report(
-            {"loss": loss, "loss/loc": loc_loss, "loss/conf": conf_loss},self)
-        return loss
-def get_ft_model(n_class):
-    pretrained_model = SSD512(20,"ssd512_voc0712_trained.npz")
-        return pretrained_model
-    model = SSD512(n_class, "ssd_vgg16_imagenet.npz")
-    model.extractor.copyparams(pretrained_model.extractor)
-    model.multibox.loc.copyparams(pretrained_model.multibox.loc)
-    return model
-class Transform(object):
-    def __init__(self, coder, size, mean):
-        # to send cpu, make a copy
-        self.coder = copy.copy(coder)
-        self.coder.to_cpu()
-        self.size = size
-        self.mean = mean
-    def __call__(self, in_data):
-        # 1. Color augmentation
-        # 2. Random expansion
-        # 3. Random cropping
-        # 4. Resizing with random interpolation
-        # 5. Random horizontal flipping
-        img, bbox, label = in_data
-        # 1. Color augmentation
-        img = random_distort(
-                img,
-                brightness_delta=32,
-                contrast_low=0.2, contrast_high=0.9,
-                saturation_low=0.2, saturation_high=0.9,
-                hue_delta=18)
-        # 2. Random expansion
-        img, param = transforms.random_expand(img, fill=self.mean, return_param=True)
-        bbox = transforms.translate_bbox(
-                bbox, y_offset=param["y_offset"], x_offset=param["x_offset"])
-        # 3. Random croppin
-        img, param = random_crop_with_bbox_constraints(
-            img, bbox, return_param=True)
-        bbox, param = transforms.crop_bbox(
-            bbox, y_slice=param["y_slice"], x_slice=param["x_slice"],
-            allow_outside_center=False, return_param=True)
-        label = label[param["index"]]
-        # 4. Resizing with random interpolatation
-        _, h_size, w_size = img.shape
-        img = resize_with_random_interpolation(img, (self.size, self.size))
-        bbox = transforms.resize_bbox(
-            bbox, (h_size, w_size), (self.size, self.size))
-        # 5. Random horizontal flipping
-        img, params = transforms.random_flip(
-            img, x_random=True, return_param=True)
-        bbox = transforms.flip_bbox(
-            bbox, (self.size, self.size), x_flip=params["x_flip"])
-        img -= self.mean
-        mb_loc, mb_label = self.coder.encode(bbox, label)
-        return img, mb_loc, mb_label
-def run(args):
-    model = get_ft_model(args.n_class)
-    model.use_preset("evaluate")
-    train_chain = MultiboxTrainChain(model)
-    if args.gpu >= 0:
-        chainer.cuda.get_device_from_id(args.gpu).use()
-        model.to_gpu()
-    train = TransformDataset(
-        # VOCBboxDataset(year="2007", split="trainval")
-        BboxDatasetFromCsv(args.input_csv, args.rootdir),
-        Transform(model.coder, model.insize, model.mean))
-    train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
-    if args.validation_csv:
-        test = BboxDatasetFromCsv(args.validation_csv, args.eval_rootdir)
-        test_iter = chainer.iterators.SerialIterator(
-            test, args.batchsize, repeat=False, shuffle=False)
-    optimizer = chainer.optimizers.MomentumSGD()
-    optimizer.setup(train_chain)
-    for param in train_chain.params():
-        if param.name == "b":
-            param.update_rule.add_hook(GradientScaling(2))
-        else:
-            param.update_rule.add_hook(WeightDecay(0.0005))
-    updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
-    trainer = training.Trainer(
-        updater, (args.max_iteration, "iteration"), args.out)
-    trainer.extend(
-        extensions.ExponentialShift("lr", 0.1, init=1e-4),
-        trigger=triggers.ManualScheduleTrigger([], "iteration"))
-    if args.validation_csv:
-        trainer.extend(
-            DetectionVOCEvaluator(
-                test_iter, model, use_07_metric=True,
-                label_names=["Class #" + str(i) for i in range(args.n_class)]),
-            trigger=(args.val_interval, "iteration"))
-    log_interval = 20, "iteration"
-    trainer.extend(extensions.LogReport(trigger=log_interval))
-    trainer.extend(extensions.observe_lr(), trigger=log_interval)
-    trainer.extend(extensions.PrintReport(
-        ["epoch", "iteration", "lr",
-         "main/loss", "main/loss/loc", "main/loss/conf", "validation/main/accuracy"]), trigger=log_interval)
-    trainer.extend(extensions.ProgressBar(update_interval=10))
-    trainer.extend(extensions.snapshot(), trigger=(
-        args.save_interval, "iteration"))
-    trainer.extend(
-        extensions.snapshot_object(model, "model_iter_{.updater.iteration}"),
-        trigger=(args.save_interval, "iteration"))
-    if args.resume:
-        serializers.load_npz(args.resume, trainer)
-    trainer.run()
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-i", "--input-csv", required=True)
-    parser.add_argument("-r", "--rootdir", type=str, default=".")
-    parser.add_argument("-o", "--out", dest="out",
-                        metavar="OUTDIR", default="output_ssd")
-    parser.add_argument("-c", "--n-class", type=int, default=1)
-    parser.add_argument("-S", "--save-interval", type=int, default=2000)
-    parser.add_argument("-M", "--max-iteration", type=int, default=10000)
-    parser.add_argument("-T", "--validation-csv", type=str, default="")
-    parser.add_argument("-e", "--eval-rootdir", type=str, default=".")
-    parser.add_argument("-v","--val-interval", type=int, default=10000)
-    parser.add_argument("-b", "--batchsize",metavar="BATCH_SIZE", type=int, default=32)
-    parser.add_argument("--gpu", type=int, default=-1)
-    parser.add_argument("--resume", metavar="SNAPSHOT")
-    args = parser.parse_args()
-    run(args)
-if __name__ == "__main__":
-    main()
-```