def get_model(args):
mean = np.array([640., 476.23620605, 88.2875590389])
std = np.array([227.59802246, 65.00177002, 52.7303319245])
if "scale" not in args.model:
mean, std = mean[:2], std[:2]
logger.info("Mean: {}, std: {}".format(mean, std))
if args.model == "cnn" or args.model == "cnn_scale":
model = CNN(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list)
elif args.model == "cnn_pose" or args.model == "cnn_pose_scale":
model = CNN_Pose(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list)
elif args.model == "cnn_ego" or args.model == "cnn_ego_scale":
model = CNN_Ego(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list, args.ego_type)
elif args.model == "cnn_ego_pose" or args.model == "cnn_ego_pose_scale":
model = CNN_Ego_Pose(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list, args.ego_type)
else:
logger.info("Invalid argument: model={}".format(args.model))
exit(1)
if args.resume != "":
serializers.load_npz(args.resume, model)
if args.gpu >= 0:
model.to_gpu(args.gpu)
return model
def test(args):
np.random.seed(1234)
train, _, test = load_dataset(args.data_dir, valid=args.validation, dataset_seed=args.dataset_seed)
print("N_train:{}".format(train.N))
enc = CNN(n_outputs=args.n_categories, dropout_rate=args.dropout_rate)
chainer.serializers.load_npz(args.trained_model_path, enc)
if args.gpu > -1:
chainer.cuda.get_device(args.gpu).use()
enc.to_gpu()
print("Finetune")
for i in range(args.finetune_iter):
x,_ = train.get(args.batchsize_finetune, gpu=args.gpu)
enc(x)
acc_sum = 0
test_x, test_t = test.get()
N_test = test.N
for i in range(0, N_test, args.batchsize_eval):
x = test_x[i:i + args.batchsize_eval]
t = test_t[i:i + args.batchsize_eval]
if args.gpu > -1:
x, t = cuda.to_gpu(x, device=args.gpu), cuda.to_gpu(t, device=args.gpu)
logit = enc(x, train=False)
acc = F.accuracy(logit, t).data
acc_sum += acc * x.shape[0]
acc_test = acc_sum / N_test
print("test acc: ", acc_test)
def main(args):
print(args.dataset_dir, os.path.isfile(args.dataset_dir))
if os.path.isfile(args.dataset_dir):
paths = [args.dataset_dir]
else:
paths = glob.glob(os.path.join(args.dataset_dir, '**/*.wav'))
print(len(paths))
train_paths, test_path = train_test_split(paths,
train_size=0.9,
test_size=0.1)
train = ESDataset(train_paths, label_index=args.label_index)
test = ESDataset(test_path, label_index=args.label_index)
batchsize = args.batch_size
train_iter = chainer.iterators.SerialIterator(train, batchsize)
test_iter = chainer.iterators.SerialIterator(test, batchsize, False, False)
gpu_id = 0 # Set to -1 if you use CPU
model = CNN()
if args.device >= 0:
model.to_gpu(args.device)
if args.init_weights != '':
chainer.serializers.load_npz(args.init_weights, model)
# Since we do not specify a loss function here, the default 'softmax_cross_entropy' is used.
model = chainer.links.Classifier(model)
# selection of your optimizing method
optimizer = chainer.optimizers.Adam()
# Give the optimizer a reference to the model
optimizer.setup(model)
# Get an updater that uses the Iterator and Optimizer
updater = chainer.training.updaters.StandardUpdater(train_iter,
optimizer,
device=gpu_id)
# Setup a Trainer
trainer = chainer.training.Trainer(updater, (args.epoch, 'epoch'),
out=args.out_dir)
trainer.extend(extensions.Evaluator(test_iter, model, device=args.device))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
"epoch", "main/loss", "validation/main/loss", "main/accuracy",
"validation/main/accuracy", "elapsed_time"
]))
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
x_key='epoch',
file_name='loss.png'))
trainer.extend(
extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'],
x_key='epoch',
file_name='accuracy.png'))
trainer.extend(extensions.snapshot_object(
model.predictor, filename='model_epoch-{.updater.epoch}'),
trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.ProgressBar())
trainer.run()
chainer.serializers.save_npz(os.path.join(args.out_dir, 'weights.npz'),
model)
def train(args):
np.random.seed(args.seed)
train_l, train_ul, test = load_dataset(args.data_dir,
valid=args.validation,
dataset_seed=args.dataset_seed)
print("N_train_labeled:{}, N_train_unlabeled:{}".format(
train_l.N, train_ul.N))
enc = CNN(n_outputs=args.n_categories,
dropout_rate=args.dropout_rate,
top_bn=args.top_bn)
if args.gpu > -1:
chainer.cuda.get_device(args.gpu).use()
enc.to_gpu()
optimizer = optimizers.Adam(alpha=args.lr, beta1=args.mom1)
optimizer.setup(enc)
optimizer.use_cleargrads()
alpha_plan = [args.lr] * args.num_epochs
beta1_plan = [args.mom1] * args.num_epochs
for i in range(args.epoch_decay_start, args.num_epochs):
alpha_plan[i] = float(args.num_epochs - i) / (
args.num_epochs - args.epoch_decay_start) * args.lr
beta1_plan[i] = args.mom2
accs_test = np.zeros(args.num_epochs)
cl_losses = np.zeros(args.num_epochs)
ul_losses = np.zeros(args.num_epochs)
mkdir_p(args.log_dir)
for epoch in range(args.num_epochs):
optimizer.alpha = alpha_plan[epoch]
optimizer.beta1 = beta1_plan[epoch]
sum_loss_l = 0
sum_loss_ul = 0
start = time.time()
for it in range(args.num_iter_per_epoch):
x, t = train_l.get(args.batchsize,
gpu=args.gpu,
aug_trans=args.aug_trans,
aug_flip=args.aug_flip)
loss_l = loss_labeled(enc, Variable(x), Variable(t))
x_u, _ = train_ul.get(args.batchsize_ul,
gpu=args.gpu,
aug_trans=args.aug_trans,
aug_flip=args.aug_flip)
loss_ul = loss_unlabeled(enc, Variable(x_u), args)
loss_total = loss_l + loss_ul
enc.cleargrads()
loss_total.backward()
optimizer.update()
sum_loss_l += loss_l.data
sum_loss_ul += loss_ul.data
end = time.time()
cl_losses[epoch] = sum_loss_l / args.num_iter_per_epoch
ul_losses[epoch] = sum_loss_ul / args.num_iter_per_epoch
if (epoch + 1) % args.eval_freq == 0:
acc_test_sum = 0
test_x, test_t = test.get()
N_test = test_x.shape[0]
for i in range(0, N_test, args.batchsize_eval):
x = test_x[i:i + args.batchsize_eval]
t = test_t[i:i + args.batchsize_eval]
if args.gpu > -1:
x, t = cuda.to_gpu(x, device=args.gpu), cuda.to_gpu(
t, device=args.gpu)
_, acc = loss_test(enc, Variable(x, volatile=True),
Variable(t, volatile=True))
acc_test_sum += acc * x.shape[0]
accs_test[epoch] = acc_test_sum / N_test
print(
"Epoch:{}, classification loss:{}, unlabeled loss:{}, time:{}".
format(epoch, cl_losses[epoch], ul_losses[epoch], end - start))
print("test acc:{}".format(accs_test[epoch]))
sys.stdout.flush()
if (epoch + 1) % args.snapshot_freq == 0:
# Save stats and model
np.savetxt(os.path.join(args.log_dir, 'log.txt'),
np.concatenate([
np.array([['acc', 'cl_loss', 'ul_loss']]),
np.transpose([accs_test, cl_losses, ul_losses])
], 0),
fmt='%s')
serializers.save_npz(
os.path.join(args.log_dir, 'trained_model_ep{}'.format(epoch)),
enc)
# Save final stats and model
np.savetxt(os.path.join(args.log_dir, 'log.txt'),
np.concatenate([
np.array([['acc', 'cl_loss', 'ul_loss']]),
np.transpose([accs_test, cl_losses, ul_losses])
], 0),
fmt='%s')
serializers.save_npz(os.path.join(args.log_dir, 'trained_model_final'),
enc)
