def test_sub_dataset(self):
original = [1, 2, 3, 4, 5]
subset = datasets.SubDataset(original, 1, 4)
self.assertEqual(len(subset), 3)
self.assertEqual(subset[0], 2)
self.assertEqual(subset[1], 3)
self.assertEqual(subset[2], 4)
def __init__(self, n_units, n_out):
super(MLP, self).__init__()
with self.init_scope():
self.l1 = L.Linear(None, n_units) # n_in -> n_units
self.l2 = L.Linear(None, n_units) # n_units -> n_units
self.l3 = L.Linear(None, n_out) # n_units -> n_out
def __call__(self, x):
h1 = F.relu(self.l1(x))
h2 = F.relu(self.l2(h1))
return self.l3(h2)
batchsize = 10
train, test = datasets.get_mnist()
train = datasets.SubDataset(train, 0, 100)
test = datasets.SubDataset(test, 0, 100)
train_iter = chainer.iterators.SerialIterator(train, batchsize)
test_iter = chainer.iterators.SerialIterator(test, batchsize,
repeat=False, shuffle=False)
model = L.Classifier(MLP(784, 10))
opt = chainer.optimizers.Adam()
opt.setup(model)
epoch = 2
# Set up a trainer
updater = training.StandardUpdater(train_iter, opt, device=-1)
trainer = training.Trainer(updater, (epoch, 'epoch'), out='/tmp/result')
def train(settings: dict, output_path: PosixPath):
"""Main."""
gpu_num = len(settings["gpu_devices"])
# # make dataset
# # # read meta info.
train_df = pd.read_csv(
config.PROC_DATA /
"train_add-{}fold-index.csv".format(settings["n_folds"]))
# # # make label arr
train_labels_arr = train_df[config.COMP_NAMES].values.astype("i")
# # # make train set
if settings["val_fold"] != -1:
train_dataset = datasets.LabeledImageDataset(
pairs=list(
zip((train_df[train_df["fold"] != settings["val_fold"]]
["image_id"] + ".png").tolist(),
train_labels_arr[train_df["fold"] != settings["val_fold"],
...])),
root=config.TRAIN_IMAGES_DIR.as_posix())
else:
train_dataset = datasets.LabeledImageDataset(
pairs=list(
zip((train_df["image_id"] + ".png").tolist(),
train_labels_arr)),
root=config.TRAIN_IMAGES_DIR.as_posix())
train_dataset = datasets.TransformDataset(
train_dataset,
nn_training.ImageTransformer(settings["training_transforms"]))
if gpu_num > 1:
# # if using multi-gpu, split train set into gpu_num.
train_sub_dataset_list = []
total_size = len(train_dataset)
subset_size = (total_size + gpu_num - 1) // gpu_num
np.random.seed(1086)
random_order = np.random.permutation(len(train_dataset))
for i in range(gpu_num):
start_idx = min(i * subset_size, total_size - subset_size)
end_idx = min((i + 1) * subset_size, total_size)
print(i, start_idx, end_idx)
train_sub_dataset_list.append(
datasets.SubDataset(train_dataset,
start=start_idx,
finish=end_idx,
order=random_order))
train_dataset = train_sub_dataset_list
for i, subset in enumerate(train_dataset):
print("subset{}: {}".format(i, len(subset)))
# # # # validation set
if settings["val_fold"] != -1:
val_dataset = datasets.LabeledImageDataset(
pairs=list(
zip((train_df[train_df["fold"] == settings["val_fold"]]
["image_id"] + ".png").tolist(),
train_labels_arr[train_df["fold"] == settings["val_fold"],
...])),
root=config.TRAIN_IMAGES_DIR.as_posix())
else:
# # if train models using all train data, calc loss for all data at the evaluation step.
val_dataset = datasets.LabeledImageDataset(
pairs=list(
zip((train_df["image_id"] + ".png").tolist(),
train_labels_arr)),
root=config.TRAIN_IMAGES_DIR.as_posix())
val_dataset = datasets.TransformDataset(
val_dataset,
nn_training.ImageTransformer(settings["inference_transforms"]))
print("[make dataset] train: {}, val: {}".format(len(train_dataset),
len(val_dataset)))
# # initialize model.
model = nn_training.ImageClassificationModel(
extractor=getattr(
backborn_chains,
settings["backborn_class"])(**settings["backborn_kwargs"]),
global_pooling=None if settings["pooling_class"] is None else getattr(
global_pooling_chains, settings["pooling_class"])(
**settings["pooling_kwargs"]),
classifier=getattr(classifer_chains,
settings["head_class"])(**settings["head_kwargs"]))
model.name = settings["model_name"]
# # set training wrapper.
train_model = nn_training.CustomClassifier(
predictor=model,
lossfun=getattr(
nn_training,
settings["loss_function"][0])(**settings["loss_function"][1]),
evalfun_dict={
"SCE_{}".format(i): getattr(nn_training, name)(**param)
for i, (name, param) in enumerate(settings["eval_functions"])
})
settings["eval_func_names"] = [
"SCE_{}".format(i) for i in range(len(settings["eval_functions"]))
]
gc.collect()
# # training.
# # # create trainer.
utils.set_random_seed(settings["seed"])
trainer = nn_training.create_trainer(settings, output_path.as_posix(),
train_model, train_dataset,
val_dataset)
trainer.run()
# # # save model of last epoch,
model = trainer.updater.get_optimizer('main').target.predictor
serializers.save_npz(output_path / "model_snapshot_last_epoch.npz", model)
del trainer
del train_model
gc.collect()
# # inference validation data by the model of last epoch.
_, val_iter, _ = nn_training.create_iterator(settings, None, val_dataset,
None)
val_pred, val_label = nn_training.inference_test_data(
model, val_iter, gpu_device=settings["gpu_devices"][0])
np.save(output_path / "val_pred_arr_fold{}".format(settings["val_fold"]),
val_pred)
# # calc validation score
score_list = [[] for i in range(2)]
for i in range(len(config.N_CLASSES)):
y_pred_subset = val_pred[:, config.COMP_INDEXS[i]:config.
COMP_INDEXS[i + 1]].argmax(axis=1)
y_true_subset = val_label[:, i]
score_list[0].append(
recall_score(y_true_subset,
y_pred_subset,
average='macro',
zero_division=0))
score_list[1].append(
recall_score(y_true_subset,
y_pred_subset,
average='macro',
zero_division=1))
score_list[0].append(np.average(score_list[0], weights=[2, 1, 1]))
score_list[1].append(np.average(score_list[1], weights=[2, 1, 1]))
score_df = pd.DataFrame(score_list, columns=config.COMP_NAMES + ["score"])
print(score_df)
score_df.to_csv(output_path / "score.csv", index=False)
def test_permuted_sub_dataset_len_mismatch(self):
original = [1, 2, 3, 4, 5]
with self.assertRaises(ValueError):
datasets.SubDataset(original, 1, 4, [2, 0, 3, 1])
def test_sub_dataset_overrun(self):
original = [1, 2, 3, 4, 5]
subset = datasets.SubDataset(original, 1, 4)
with self.assertRaises(IndexError):
subset[len(subset)]
l2=L.Linear(None, n_units), # n_units -> n_units
l3=L.Linear(None, n_out), # n_units -> n_out
)
def __call__(self, x):
h1 = F.relu(self.l1(x))
h2 = F.relu(self.l2(h1))
return self.l3(h2)
# create model
model = L.Classifier(MLP(100, 10))
# load dataset
train_full, test_full = chainer.datasets.get_mnist()
train = datasets.SubDataset(train_full, 0, 1000)
test = datasets.SubDataset(test_full, 0, 1000)
# Set up a iterator
batchsize = 100
train_iter = chainer.iterators.SerialIterator(train, batchsize)
test_iter = chainer.iterators.SerialIterator(test,
batchsize,
repeat=False,
shuffle=False)
# Set up an optimizer
# Set up an updater
# Set up a trainer
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpus', type=str, default="-1")
parser.add_argument('--batchsize', type=int, default=2)
parser.add_argument('--epoch', type=int, default=10)
parser.add_argument('--mini', action="store_true")
args = parser.parse_args()
gpus = list(filter(lambda x: x >= 0, map(int, args.gpus.split(","))))
num_class = len(voc_bbox_label_names)
data_augmentation_transform = DataAugmentationTransform(512)
center_detection_transform = CenterDetectionTransform(512, num_class, 4)
train = TransformDataset(
ConcatenatedDataset(
VOCBboxDataset(year='2007', split='trainval'),
VOCBboxDataset(year='2012', split='trainval')
),
data_augmentation_transform
)
train = TransformDataset(train, center_detection_transform)
if args.mini:
train = datasets.SubDataset(train, 0, 100)
train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize)
test = VOCBboxDataset(
year='2007', split='test',
use_difficult=True, return_difficult=True)
if args.mini:
test = datasets.SubDataset(test, 0, 20)
test_iter = chainer.iterators.SerialIterator(
test, args.batchsize // len(gpus), repeat=False, shuffle=False)
detector = CenterDetector(HourglassNet, 512, num_class)
train_chain = CenterDetectorTrain(detector, 1, 0.1, 1)
gpus.sort()
first_gpu = gpus[0]
remain_gpu = gpus[1:]
train_chain.to_gpu(first_gpu)
optimizer = Adam(amsgrad=True)
optimizer.setup(train_chain)
devices = {
"main": first_gpu
}
for i, gpu in enumerate(remain_gpu):
devices[f"{i + 2}"] = gpu
updater = training.updaters.ParallelUpdater(
train_iter,
optimizer,
devices=devices,
)
log_interval = 1, 'epoch'
trainer = Trainer(updater, (args.epoch, 'epoch'))
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/hm_loss', 'main/wh_loss', 'main/offset_loss',
'validation/main/map',
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(
DetectionVOCEvaluator(
test_iter, detector, use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=(1, 'epoch'))
trainer.extend(
extensions.snapshot_object(detector, 'detector{.updater.epoch:03}.npz'),
trigger=(1, 'epoch')
)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=2)
parser.add_argument('--epoch', type=int, default=10)
parser.add_argument('--mini', action="store_true")
parser.add_argument('--input_size', type=int, default=512)
args = parser.parse_args()
dtype = np.float32
num_class = len(voc_bbox_label_names)
data_augmentation_transform = DataAugmentationTransform(args.input_size)
center_detection_transform = CenterDetectionTransform(args.input_size,
num_class,
4,
dtype=dtype)
train = TransformDataset(
ConcatenatedDataset(VOCBboxDataset(year='2007', split='trainval'),
VOCBboxDataset(year='2012', split='trainval')),
data_augmentation_transform)
train = TransformDataset(train, center_detection_transform)
if args.mini:
train = datasets.SubDataset(train, 0, 100)
train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize)
test = VOCBboxDataset(year='2007',
split='test',
use_difficult=True,
return_difficult=True)
if args.mini:
test = datasets.SubDataset(test, 0, 20)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
detector = CenterDetector(HourglassNet,
args.input_size,
num_class,
dtype=dtype)
#detector = CenterDetector(SimpleCNN, args.input_size, num_class)
train_chain = CenterDetectorTrain(detector, 1, 0.1, 1)
#train_chain = CenterDetectorTrain(detector, 1, 0, 0)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
train_chain.to_gpu(args.gpu)
optimizer = Adam(alpha=1.25e-4)
#optimizer = SGD()
optimizer.setup(train_chain)
updater = StandardUpdater(train_iter, optimizer, device=args.gpu)
log_interval = 1, 'epoch'
log_interval_mini = 500, 'iteration'
trainer = Trainer(updater, (args.epoch, 'epoch'), out=f"result{args.gpu}")
trainer.extend(extensions.LogReport(trigger=log_interval_mini))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'lr',
'main/loss',
'main/hm_loss',
'main/wh_loss',
'main/offset_loss',
'main/hm_mae',
'main/hm_pos_loss',
'main/hm_neg_loss',
'validation/main/map',
]),
trigger=log_interval_mini)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(DetectionVOCEvaluator(test_iter,
detector,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=(1, 'epoch'))
trainer.extend(extensions.snapshot_object(
detector, 'detector{.updater.epoch:03}.npz'),
trigger=(1, 'epoch'))
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=4)
parser.add_argument('--epoch', type=int, default=10)
parser.add_argument('--mini', action="store_true")
args = parser.parse_args()
if hasattr(multiprocessing, 'set_start_method'):
multiprocessing.set_start_method('forkserver')
p = multiprocessing.Process()
p.start()
p.join()
comm = chainermn.create_communicator('pure_nccl')
print(comm.size)
device = comm.intra_rank
num_class = len(voc_bbox_label_names)
data_augmentation_transform = DataAugmentationTransform(512)
center_detection_transform = CenterDetectionTransform(512, num_class, 4)
train = TransformDataset(
ConcatenatedDataset(VOCBboxDataset(year='2007', split='trainval'),
VOCBboxDataset(year='2012', split='trainval')),
data_augmentation_transform)
if comm.rank == 0:
train = TransformDataset(train, center_detection_transform)
if args.mini:
train = datasets.SubDataset(train, 0, 100)
else:
train = None
train = chainermn.scatter_dataset(train, comm, shuffle=True)
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize //
comm.size,
n_processes=2)
if comm.rank == 0:
test = VOCBboxDataset(year='2007',
split='test',
use_difficult=True,
return_difficult=True)
if args.mini:
test = datasets.SubDataset(test, 0, 20)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
detector = CenterDetector(HourglassNet, 512, num_class)
train_chain = CenterDetectorTrain(detector, 1, 0.1, 1, comm=comm)
chainer.cuda.get_device_from_id(device).use()
train_chain.to_gpu()
optimizer = chainermn.create_multi_node_optimizer(Adam(amsgrad=True), comm)
optimizer.setup(train_chain)
updater = StandardUpdater(train_iter, optimizer, device=device)
trainer = Trainer(updater, (args.epoch, 'epoch'))
if comm.rank == 0:
log_interval = 1, 'epoch'
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/hm_loss',
'main/wh_loss',
'main/offset_loss',
'validation/main/map',
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(DetectionVOCEvaluator(test_iter,
detector,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=(1, 'epoch'))
trainer.extend(extensions.snapshot_object(
detector, 'detector{.updator.epoch:03}.npz'),
trigger=(1, 'epoch'))
trainer.run()
