def __init__(self):
self.net = ET_Net()
if (ARGS['gpu']):
self.net = DataParallel(module=self.net.cuda())
self.net.load_state_dict(torch.load(ARGS['weight']))
self.train_dataset = get_dataset(dataset_name=ARGS['dataset'],
part='train')
self.val_dataset = get_dataset(dataset_name=ARGS['dataset'],
part='val')
def __init__(self):
self.net = ET_Net()
if (ARGS['weight']):
self.net.load_state_dict(torch.load(ARGS['weight']))
else:
self.net.load_encoder_weight()
if (ARGS['gpu']):
self.net = DataParallel(module=self.net.cuda())
self.train_dataset = get_dataset(dataset_name=ARGS['dataset'],
part='train')
self.val_dataset = get_dataset(dataset_name=ARGS['dataset'],
part='val')
self.optimizer = Adam(self.net.parameters(), lr=ARGS['lr'])
# Use / to get an approximate result, // to get an accurate result
total_iters = len(
self.train_dataset) // ARGS['batch_size'] * ARGS['num_epochs']
self.lr_scheduler = LambdaLR(
self.optimizer,
lr_lambda=lambda iter:
(1 - iter / total_iters)**ARGS['scheduler_power'])
self.writer = SummaryWriter()
def main():
args = parser()
# 時間読み込み
now = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
# 保存ディレクトリ先
save_dir = Path('result') / now
log_dir = save_dir / 'log'
model_dir = save_dir / 'model'
snap_dir = save_dir / 'snap'
matrix_dir = save_dir / 'matrix'
# 保存ディレクトリ先作成
save_dir.mkdir(exist_ok=True, parents=True)
log_dir.mkdir(exist_ok=True, parents=True)
model_dir.mkdir(exist_ok=True, parents=True)
snap_dir.mkdir(exist_ok=True, parents=True)
matrix_dir.mkdir(exist_ok=True, parents=True)
# Dataset読み込み
root = args.dataset
dir_list = os.listdir(root)
dir_list.sort()
if 'mean.npy' in dir_list:
dir_list.remove('mean.npy')
# datasetに画像ファイルとラベルを読み込む
print('dataset loading ...')
datasets = DirectoryParsingLabelDataset(root)
print('finish!')
# クラス数
class_num = len(set(datasets.labels))
print('class number : {}'.format(class_num))
# fold数
k_fold = args.kfold
print('k_fold : {}'.format(k_fold))
X = np.array([image_paths for image_paths in datasets.img_paths])
y = np.array([label for label in datasets.labels])
kfold = StratifiedKFold(n_splits=k_fold, shuffle=True, random_state=402).split(X, y)
for k, (train_idx, val_idx) in enumerate(kfold):
print("============= {} fold training =============".format(k + 1))
X_train, y_train = X[train_idx], y[train_idx]
X_val, y_val = X[val_idx], y[val_idx]
# 画像とラベルをセットにしたデータセットを作る
train = LabeledImageDataset([(x, y) for x, y in zip(X_train, y_train)])
validation = LabeledImageDataset([(x, y) for x, y in zip(X_val, y_val)])
train, validation, mean = get_dataset(train, validation, root, datasets, use_mean=False)
# model setup
model = StabilityClassifer(archs[args.arch](output=class_num))
#model = ABNClassifier(archs[args.arch](output=class_num))
lr = args.lr
optimizer = chainer.optimizers.MomentumSGD(lr)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0001))
# using GPU
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# setup iterators
train_iter = chainer.iterators.MultithreadIterator(train, args.batchsize, n_threads=8)
validation_iter = chainer.iterators.MultithreadIterator(validation, args.batchsize,
repeat=False, shuffle=False, n_threads=8)
# setup updater and trainer
updater = training.StandardUpdater(
train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(
updater, (args.epoch, 'epoch'), out=save_dir)
# set extensions
log_trigger = (1, 'epoch')
target = 'lr'
trainer.extend(CosineShift(target, args.epoch, 1),
trigger=(1, "epoch"))
trainer.extend(extensions.Evaluator(validation_iter, model, device=args.gpu),
trigger=log_trigger)
snap_name = '{}-{}_fold_model.npz'.format(k_fold, k+1)
trainer.extend(extensions.snapshot_object(model, str(snap_name)),
trigger=chainer.training.triggers.MaxValueTrigger(
key='validation/main/accuracy', trigger=(1, 'epoch')))
log_name = '{}-{}_fold_log.json'.format(k_fold, k+1)
trainer.extend(extensions.LogReport(
log_name=str(log_name), trigger=log_trigger))
trainer.extend(extensions.observe_lr(), trigger=log_trigger)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration',
'main/loss','main/lossL2', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy',
'elapsed_time', 'lr'
]), trigger=(1, 'epoch'))
trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',file_name='loss{}.png'.format(k+1)))
trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'],
'epoch', file_name='accuracy{}.png'.format(k+1)))
trainer.extend(extensions.ProgressBar(update_interval=10))
#if args.resume:
#chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
snap_file = save_dir / snap_name
shutil.move(str(snap_file), str(snap_dir))
log_file = save_dir / log_name
shutil.move(str(log_file), str(log_dir))
# model save
save_model = model_dir / "{}_{}-{}_fold.npz".format(now, k_fold, k + 1)
chainer.serializers.save_npz(str(save_model), model)
print("============= {} fold Evaluation =============".format(k + 1))
# 画像フォルダ
dnames = glob.glob('{}/*'.format(root))
labels_list = []
for d in dnames:
p_dir = Path(d)
labels_list.append(p_dir.name)
if 'mean.npy' in labels_list:
labels_list.remove('mean.npy')
confusion_matrix_cocoa(validation, args.gpu, 8,
model, matrix_dir, k, labels_list)
features = []
with torch.no_grad():
for batch, _ in tqdm(loader):
if torch.cuda.is_available():
batch = batch.cuda()
b_features = model(batch).detach().cpu().numpy()
features += [f for f in b_features]
return features
if __name__ == '__main__':
args = parser.parse_args()
register_logger()
ret_dataset, ret_loader = get_dataset(args)
ret_paths = [a[0] for a in ret_dataset.imgs]
cifar_dataset, cifar_loader = get_cifar100(args)
cifar_images = cifar_dataset.data
vgg = VGG(use_cuda=torch.cuda.is_available(), pretrained_path=args.vgg_path)
cifar_features = get_features(model=vgg, loader=cifar_loader)
ret_features = get_features(model=vgg, loader=ret_loader)
knn = KNN()
knn.fit(x=cifar_images, x_features=cifar_features)
rets_neighbors = knn.predict(ret_features, k=7)
for i, (orig_path, neighbors) in enumerate(zip(ret_paths, rets_neighbors)):
neighbors_imgs = [knn[n] for n in neighbors]