def run(args):
tag = 'bamos.smooth-topk.seed={}.{}'.format(args.seed, args.dataset)
if args.dataset == 'cifar100':
tag += '.noise={}'.format(args.noise_labels)
elif args.dataset == 'imagenet':
tag += '-{}'.format(args.train_size)
setproctitle(tag)
set_seed(args.seed)
xp = create_experiment(args)
train_loader, val_loader, test_loader = get_loaders(args)
loss = get_loss(xp, args)
model = get_model(args)
if args.load_model:
load_model(model, args.load_model)
if args.cuda:
if args.parallel_gpu:
model = torch.nn.DataParallel(model).cuda()
else:
torch.cuda.set_device(args.device)
model.cuda()
loss.cuda()
optimizer = get_optimizer(model, args.mu, args.lr_0, xp)
if args.load_optimizer:
load_optimizer(optimizer, args.load_optimizer, args.lr_0)
with logger.stdout_to("{}_log.txt".format(args.out_name)):
clock = -time.time()
for _ in range(args.epochs):
xp.Epoch.update(1).log()
optimizer = update_optimizer(args.lr_schedule, optimizer,
model, loss, xp)
xp.Learning_Rate.update().log()
xp.Mu.update().log()
xp.Temperature.update().log()
train(model, loss, optimizer, train_loader, xp, args)
test(model, loss, val_loader, xp, args)
test(model, loss, test_loader, xp, args)
clock += time.time()
print("\nEvaluation time: \t {0:.2g} min".format(clock * 1. / 60))
def main(args):
set_seed(args)
dataset_train, dataset_val, dataset_test = get_datasets(args)
optimizer = get_optimizer(args)
obj = get_objective(args, optimizer.hparams)
xp = get_xp(args, optimizer)
for i in range(args.epochs):
xp.Epoch.update(1).log()
train(obj, optimizer, dataset_train, xp, args, i)
test(obj, optimizer, dataset_val, xp, args, i)
test(obj, optimizer, dataset_test, xp, args, i)
print_total_time(xp)
def run(args):
set_seed(args.seed)
xp = create_experiment(args)
train_loader, val_loader, test_loader = get_loaders(args)
loss = get_loss(xp, args)
model = get_model(args)
if args.load_model:
load_model(model, args.load_model)
if args.cuda:
if args.parallel_gpu:
model = torch.nn.DataParallel(model).cuda()
else:
torch.cuda.set_device(args.device)
model.cuda()
loss.cuda()
optimizer = get_optimizer(model, args.mu, args.lr_0, xp)
if args.load_optimizer:
load_optimizer(optimizer, args.load_optimizer, args.lr_0)
with logger.stdout_to("{}_log.txt".format(args.out_name)):
clock = -time.time()
for _ in range(args.epochs):
xp.Epoch.update(1).log()
optimizer = update_optimizer(args.lr_schedule, optimizer, model,
loss, xp)
xp.Learning_Rate.update().log()
xp.Mu.update().log()
xp.Temperature.update().log()
train(model, loss, optimizer, train_loader, xp, args)
test(model, loss, val_loader, xp, args)
test(model, loss, test_loader, xp, args)
clock += time.time()
print("\nEvaluation time: \t {0:.2g} min".format(clock * 1. / 60))
def main(args):
set_cuda(args)
set_seed(args)
loader_train, loader_val, loader_test = get_data_loaders(args)
loss = get_loss(args)
model = get_model(args)
optimizer = get_optimizer(args, parameters=model.parameters())
xp = get_xp(args, model, optimizer)
for i in range(args.epochs):
xp.Epoch.update(1).log()
train(model, loss, optimizer, loader_train, xp, args)
test(model, loader_val, xp, args)
if (i + 1) in args.T:
decay_optimizer(optimizer, args.decay_factor)
load_best_model(model, xp)
test(model, loader_test, xp, args)
def main(args):
set_cuda(args)
set_seed(args)
loader_train, loader_val, loader_test = get_data_loaders(args)
loss = get_loss(args)
model = get_model(args)
optimizer = get_optimizer(args, model, loss, parameters=model.parameters())
xp = setup_xp(args, model, optimizer)
for i in range(args.epochs):
xp.epoch.update(i)
train(model, loss, optimizer, loader_train, args, xp)
test(model, optimizer, loader_val, args, xp)
if (i + 1) in args.T:
decay_optimizer(optimizer, args.decay_factor)
load_best_model(model, '{}/best_model.pkl'.format(args.xp_name))
test(model, optimizer, loader_val, args, xp)
test(model, optimizer, loader_test, args, xp)
def main(config):
if config.model == 'c3d':
model, params = C3D(config)
elif config.model == 'convlstm':
model, params = ConvLSTM(config)
elif config.model == 'densenet':
model, params = densenet(config)
elif config.model == 'densenet_lean':
model, params = densenet_lean(config)
elif config.model == 'resnext':
model, params = resnext(config)
else:
model, params = densenet_lean(config)
dataset = config.dataset
sample_size = config.sample_size
stride = config.stride
sample_duration = config.sample_duration
cv = config.num_cv
# crop_method = GroupRandomScaleCenterCrop(size=sample_size)
crop_method = MultiScaleRandomCrop(config.scales, config.sample_size[0])
# norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
norm = Normalize([114.7748, 107.7354, 99.475], [1, 1, 1])
# spatial_transform = Compose(
# [crop_method,
# GroupRandomHorizontalFlip(),
# ToTensor(1), norm])
spatial_transform = Compose([
RandomHorizontalFlip(), crop_method,
ToTensor(config.norm_value), norm
])
# temporal_transform = RandomCrop(size=sample_duration, stride=stride)
temporal_transform = TemporalRandomCrop(config.sample_duration,
config.downsample)
target_transform = Label()
train_batch = config.train_batch
train_data = RWF2000('/content/RWF_2000/frames/',
g_path + '/RWF-2000.json', 'training',
spatial_transform, temporal_transform,
target_transform, dataset)
train_loader = DataLoader(train_data,
batch_size=train_batch,
shuffle=True,
num_workers=4,
pin_memory=True)
crop_method = GroupScaleCenterCrop(size=sample_size)
norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
spatial_transform = Compose([crop_method, ToTensor(), norm])
temporal_transform = CenterCrop(size=sample_duration, stride=stride)
target_transform = Label()
val_batch = config.val_batch
val_data = RWF2000('/content/RWF_2000/frames/', g_path + '/RWF-2000.json',
'validation', spatial_transform, temporal_transform,
target_transform, dataset)
val_loader = DataLoader(val_data,
batch_size=val_batch,
shuffle=False,
num_workers=4,
pin_memory=True)
if not os.path.exists('{}/pth'.format(config.output)):
os.mkdir('{}/pth'.format(config.output))
if not os.path.exists('{}/log'.format(config.output)):
os.mkdir('{}/log'.format(config.output))
batch_log = Log(
'{}/log/{}_fps{}_{}_batch{}.log'.format(
config.output,
config.model,
sample_duration,
dataset,
cv,
), ['epoch', 'batch', 'iter', 'loss', 'acc', 'lr'])
epoch_log = Log(
'{}/log/{}_fps{}_{}_epoch{}.log'.format(config.output, config.model,
sample_duration, dataset, cv),
['epoch', 'loss', 'acc', 'lr'])
val_log = Log(
'{}/log/{}_fps{}_{}_val{}.log'.format(config.output, config.model,
sample_duration, dataset, cv),
['epoch', 'loss', 'acc'])
criterion = nn.CrossEntropyLoss().to(device)
# criterion = nn.BCELoss().to(device)
learning_rate = config.learning_rate
momentum = config.momentum
weight_decay = config.weight_decay
optimizer = torch.optim.SGD(params=params,
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay,
dampening=False,
nesterov=False)
# optimizer = torch.optim.Adam(params=params, lr = learning_rate, weight_decay= weight_decay)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer, verbose=True, factor=config.factor, min_lr=config.min_lr)
acc_baseline = config.acc_baseline
loss_baseline = 1
for p in range(1, config.num_prune):
if p > 0:
model = torch.load('{}/pth/prune_{}.pth'.format(
config.output, p - 1))
print(f"Prune {p}/{config.num_prune}")
params = sum([np.prod(p.size()) for p in model.parameters()])
print("Number of Parameters: %.1fM" % (params / 1e6))
model = prune_model(model)
params = sum([np.prod(p.size()) for p in model.parameters()])
print("Number of Parameters: %.1fM" % (params / 1e6))
model.to(config.device)
acc_baseline = 0
for i in range(5):
train(i, train_loader, model, criterion, optimizer, device,
batch_log, epoch_log)
val_loss, val_acc = val(i, val_loader, model, criterion, device,
val_log)
scheduler.step(val_loss)
if val_acc > acc_baseline or (val_acc >= acc_baseline
and val_loss < loss_baseline):
# torch.save(
# model.state_dict(),
# '{}/pth/prune_{}_{}_fps{}_{}{}_{}_{:.4f}_{:.6f}.pth'.format(
# config.output, p, config.model, sample_duration, dataset, cv, i, val_acc,
# val_loss))
torch.save(model,
'{}/pth/prune_{}.pth'.format(config.output, p))
def main(args):
# Network Builders
builder = ModelBuilder()
net_sound = builder.build_sound(
arch=args.arch_sound,
fc_dim=args.num_channels,
)
net_frame = builder.build_frame(
arch=args.arch_frame,
fc_dim=args.num_channels,
pool_type=args.img_pool,
)
nets = (net_sound, net_frame)
crit = builder.build_criterion(arch=args.loss)
# Dataset and Loader
dataset_train = RAWDataset(args.list_train, args, split='train')
dataset_val = STFTDataset(args.list_val,
args,
max_sample=args.num_val,
split='val')
loader_train = torch.utils.data.DataLoader(dataset_train,
batch_size=args.batch_size,
shuffle=True,
num_workers=int(args.workers),
drop_last=True)
loader_val = torch.utils.data.DataLoader(dataset_val,
batch_size=args.batch_size,
shuffle=False,
num_workers=2,
drop_last=False)
args.epoch_iters = len(loader_train)
args.disp_iter = len(loader_train) // args.disp_iter
print('1 Epoch = {} iters'.format(args.epoch_iters))
# Wrap networks
netWrapper = NetWrapper(nets, crit, checkpoint)
netWrapper = torch.nn.DataParallel(netWrapper,
device_ids=range(args.num_gpus))
netWrapper.to(args.device)
# Set up optimizer
optimizer = create_optimizer(nets, args, checkpoint)
# History of peroformance
history = {
'train': {
'epoch': [],
'err': []
},
'val': {
'epoch': [],
'err': [],
'sdr': [],
'sir': [],
'sar': []
}
} if checkpoint is None else checkpoint['history']
from epoch import train, evaluate
# Eval mode
# evaluate(netWrapper, loader_val, history, 0, args)
# if args.mode == 'eval':
# print('Evaluation Done!')
# return
# Training loop
init_epoch = 1 if checkpoint is None else checkpoint['epoch']
print('Training start at ', init_epoch)
for epoch in range(1, args.num_epoch + 1):
train(netWrapper, loader_train, optimizer, history, epoch, args)
# Evaluation and visualization
if epoch % args.eval_epoch == 0:
evaluate(netWrapper, loader_val, history, epoch, args)
# checkpointing
from utils import save_checkpoint
save_checkpoint(nets, history, optimizer, epoch, args)
# drop learning rate
if epoch in args.lr_steps:
adjust_learning_rate(optimizer, args)
print('Training Done!')
def main(config):
# load model
if config.model == 'resnet50':
model, params = VioNet_Resnet(config)
elif config.model == 'densenet2D':
model, params = VioNet_Densenet2D(config)
# dataset
dataset = config.dataset
stride = config.stride
sample_duration = config.sample_duration
# cross validation phase
cv = config.num_cv
input_mode = config.input_mode
temp_transform = config.temporal_transform
if dataset == "protest":
train_loader, val_loader = load_protest_dataset(config)
elif dataset == "hockey":
train_loader, val_loader = load_hockey_dataset(config)
log_path = getFolder('VioNet_log')
chk_path = getFolder('VioNet_pth')
tsb_path = getFolder('VioNet_tensorboard_log')
log_tsb_dir = tsb_path + '/{}_fps{}_{}_split{}_input({})_tempTransform({})_Info({})'.format(config.model, sample_duration,
dataset, cv, input_mode, temp_transform, config.additional_info)
for pth in [log_path, chk_path, tsb_path, log_tsb_dir]:
# make dir
if not os.path.exists(pth):
os.mkdir(pth)
print('tensorboard dir:', log_tsb_dir)
writer = SummaryWriter(log_tsb_dir)
# log
batch_log = Log(
log_path+'/{}_fps{}_{}_batch{}_input({})_tempTransform({})_Info({}).log.csv'.format(
config.model,
sample_duration,
dataset,
cv,
input_mode, temp_transform, config.additional_info
), ['epoch', 'batch', 'iter', 'loss', 'acc', 'lr'])
epoch_log = Log(
log_path+'/{}_fps{}_{}_epoch{}_input({})_tempTransform({})_Info({}).log.csv'.format(config.model, sample_duration,
dataset, cv, input_mode, temp_transform, config.additional_info),
['epoch', 'loss', 'acc', 'lr'])
val_log = Log(
log_path+'/{}_fps{}_{}_val{}_input({})_tempTransform({})_Info({}).log.csv'.format(config.model, sample_duration,
dataset, cv, input_mode, temp_transform, config.additional_info),
['epoch', 'loss', 'acc'])
train_val_log = Log(log_path+'/{}_fps{}_{}_split{}_input({})_tempTransform({})_Info({}).LOG.csv'.format(config.model, sample_duration,
dataset, cv, input_mode, temp_transform, config.additional_info),
['epoch', 'train_loss', 'train_acc', 'lr', 'val_loss', 'val_acc'])
# prepare
criterion = nn.CrossEntropyLoss().to(device)
learning_rate = config.learning_rate
momentum = config.momentum
weight_decay = config.weight_decay
optimizer = torch.optim.SGD(params=params,
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
verbose=True,
factor=config.factor,
min_lr=config.min_lr)
acc_baseline = config.acc_baseline
loss_baseline = 1
# for i, (inputs, targets) in enumerate(val_loader):
# print('inputs:', inputs.size())
for i in range(config.num_epoch):
train_loss, train_acc, lr = train(i, train_loader, model, criterion, optimizer, device, batch_log,
epoch_log)
val_loss, val_acc = val(i, val_loader, model, criterion, device,
val_log)
epoch = i+1
train_val_log.log({'epoch': epoch, 'train_loss': train_loss, 'train_acc': train_acc, 'lr': lr, 'val_loss': val_loss, 'val_acc': val_acc})
writer.add_scalar('training loss',
train_loss,
epoch)
writer.add_scalar('training accuracy',
train_acc,
epoch)
writer.add_scalar('validation loss',
val_loss,
epoch)
writer.add_scalar('validation accuracy',
val_acc,
epoch)
scheduler.step(val_loss)
if val_acc > acc_baseline or (val_acc >= acc_baseline and
val_loss < loss_baseline):
torch.save(
model.state_dict(),
chk_path+'/{}_fps{}_{}{}_{}_{:.4f}_{:.6f}.pth'.format(
config.model, sample_duration, dataset, cv, i, val_acc,
val_loss))
acc_baseline = val_acc
loss_baseline = val_loss
def main(config):
# load model
if config.model == 'c3d':
model, params = VioNet_C3D(config)
elif config.model == 'convlstm':
model, params = VioNet_ConvLSTM(config)
elif config.model == 'densenet':
model, params = VioNet_densenet(config)
elif config.model == 'densenet_lean':
model, params = VioNet_densenet_lean(config)
# default densenet
else:
model, params = VioNet_densenet_lean(config)
# dataset
dataset = config.dataset
sample_size = config.sample_size
stride = config.stride
sample_duration = config.sample_duration
# cross validation phase
cv = config.num_cv
# train set
crop_method = GroupRandomScaleCenterCrop(size=sample_size)
norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
spatial_transform = Compose(
[crop_method,
GroupRandomHorizontalFlip(),
ToTensor(), norm])
temporal_transform = RandomCrop(size=sample_duration, stride=stride)
target_transform = Label()
train_batch = config.train_batch
train_data = VioDB('../VioDB/{}_jpg/'.format(dataset),
'../VioDB/{}_jpg{}.json'.format(dataset,
cv), 'training',
spatial_transform, temporal_transform, target_transform)
train_loader = DataLoader(train_data,
batch_size=train_batch,
shuffle=True,
num_workers=4,
pin_memory=True)
# val set
crop_method = GroupScaleCenterCrop(size=sample_size)
norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
spatial_transform = Compose([crop_method, ToTensor(), norm])
temporal_transform = CenterCrop(size=sample_duration, stride=stride)
target_transform = Label()
val_batch = config.val_batch
val_data = VioDB('../VioDB/{}_jpg/'.format(dataset),
'../VioDB/{}_jpg{}.json'.format(dataset,
cv), 'validation',
spatial_transform, temporal_transform, target_transform)
val_loader = DataLoader(val_data,
batch_size=val_batch,
shuffle=False,
num_workers=4,
pin_memory=True)
# make dir
if not os.path.exists('./pth'):
os.mkdir('./pth')
if not os.path.exists('./log'):
os.mkdir('./log')
# log
batch_log = Log(
'./log/{}_fps{}_{}_batch{}.log'.format(
config.model,
sample_duration,
dataset,
cv,
), ['epoch', 'batch', 'iter', 'loss', 'acc', 'lr'])
epoch_log = Log(
'./log/{}_fps{}_{}_epoch{}.log'.format(config.model, sample_duration,
dataset, cv),
['epoch', 'loss', 'acc', 'lr'])
val_log = Log(
'./log/{}_fps{}_{}_val{}.log'.format(config.model, sample_duration,
dataset, cv),
['epoch', 'loss', 'acc'])
# prepare
criterion = nn.CrossEntropyLoss().to(device)
learning_rate = config.learning_rate
momentum = config.momentum
weight_decay = config.weight_decay
optimizer = torch.optim.SGD(params=params,
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer, verbose=True, factor=config.factor, min_lr=config.min_lr)
acc_baseline = config.acc_baseline
loss_baseline = 1
for i in range(config.num_epoch):
train(i, train_loader, model, criterion, optimizer, device, batch_log,
epoch_log)
val_loss, val_acc = val(i, val_loader, model, criterion, device,
val_log)
scheduler.step(val_loss)
if val_acc > acc_baseline or (val_acc >= acc_baseline
and val_loss < loss_baseline):
torch.save(
model.state_dict(),
'./pth/{}_fps{}_{}{}_{}_{:.4f}_{:.6f}.pth'.format(
config.model, sample_duration, dataset, cv, i, val_acc,
val_loss))
acc_baseline = val_acc
loss_baseline = val_loss
def main(config: Config, root, annotation_path):
if config.model == 'resnet50':
model, params = VioNet_Resnet(config)
elif config.model == 'densenet2D':
model, params = VioNet_Densenet2D(config)
elif config.model == 'resnetXT':
model, params = VioNet_ResnetXT(config)
log_path = getFolder('VioNet_log')
chk_path = getFolder('VioNet_pth')
tsb_path = getFolder('VioNet_tensorboard_log')
log_tsb_dir = tsb_path + '/{}_fps{}_{}_split{}_input({})_Info({})'.format(
config.model, config.sample_duration, config.dataset, config.num_cv,
config.input_mode, config.additional_info)
for pth in [log_path, chk_path, tsb_path, log_tsb_dir]:
# make dir
if not os.path.exists(pth):
os.mkdir(pth)
print('tensorboard dir:', log_tsb_dir)
writer = SummaryWriter(log_tsb_dir)
# log
batch_log = Log(
log_path + '/{}_fps{}_{}_batch{}_input({})_Info({}).log.csv'.format(
config.model, config.sample_duration, config.dataset,
config.num_cv, config.input_mode, config.additional_info),
['epoch', 'batch', 'iter', 'loss', 'acc', 'lr'])
epoch_log = Log(
log_path + '/{}_fps{}_{}_epoch{}_input({})_Info({}).log.csv'.format(
config.model, config.sample_duration, config.dataset,
config.num_cv, config.input_mode, config.additional_info),
['epoch', 'loss', 'acc', 'lr'])
val_log = Log(
log_path + '/{}_fps{}_{}_val{}_input({})_Info({}).log.csv'.format(
config.model, config.sample_duration, config.dataset,
config.num_cv, config.input_mode, config.additional_info),
['epoch', 'loss', 'acc'])
train_val_log = Log(
log_path + '/{}_fps{}_{}_split{}_input({})_Info({}).LOG.csv'.format(
config.model, config.sample_duration, config.dataset,
config.num_cv, config.input_mode, config.additional_info),
['epoch', 'train_loss', 'train_acc', 'lr', 'val_loss', 'val_acc'])
criterion = nn.CrossEntropyLoss().to(device)
learning_rate = config.learning_rate
momentum = config.momentum
weight_decay = config.weight_decay
optimizer = torch.optim.SGD(params=params,
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer, verbose=True, factor=config.factor, min_lr=config.min_lr)
acc_baseline = config.acc_baseline
loss_baseline = 1
train_loader, val_loader = laod_HMDB51_frames_dataset(
config, root, annotation_path)
for i in range(config.num_epoch):
train_loss, train_acc, lr = train(i, train_loader, model, criterion,
optimizer, device, batch_log,
epoch_log)
val_loss, val_acc = val(i, val_loader, model, criterion, device,
val_log)
epoch = i + 1
train_val_log.log({
'epoch': epoch,
'train_loss': train_loss,
'train_acc': train_acc,
'lr': lr,
'val_loss': val_loss,
'val_acc': val_acc
})
writer.add_scalar('training loss', train_loss, epoch)
writer.add_scalar('training accuracy', train_acc, epoch)
writer.add_scalar('validation loss', val_loss, epoch)
writer.add_scalar('validation accuracy', val_acc, epoch)
scheduler.step(val_loss)
if val_acc > acc_baseline or (val_acc >= acc_baseline
and val_loss < loss_baseline):
torch.save(
model.state_dict(), chk_path +
'/{}_fps{}_{}{}_{}_{:.4f}_{:.6f}_config({}).pth'.format(
config.model, config.sample_duration, config.dataset,
config.num_cv, i, val_acc, val_loss,
config.additional_info))
acc_baseline = val_acc
loss_baseline = val_loss
def main(config, home_path):
# load model
if config.model == 'c3d':
model, params = VioNet_C3D(config, home_path)
elif config.model == 'convlstm':
model, params = VioNet_ConvLSTM(config)
elif config.model == 'densenet':
model, params = VioNet_densenet(config, home_path)
elif config.model == 'densenet_lean':
model, params = VioNet_densenet_lean(config, home_path)
elif config.model == 'resnet50':
model, params = VioNet_Resnet(config, home_path)
elif config.model == 'densenet2D':
model, params = VioNet_Densenet2D(config)
elif config.model == 'i3d':
model, params = VioNet_I3D(config)
elif config.model == 's3d':
model, params = VioNet_S3D(config)
else:
model, params = VioNet_densenet_lean(config, home_path)
# dataset
dataset = config.dataset
# sample_size = config.sample_size
stride = config.stride
sample_duration = config.sample_duration
# cross validation phase
cv = config.num_cv
input_mode = config.input_type
sample_size, norm = build_transforms_parameters(model_type=config.model)
# train set
crop_method = GroupRandomScaleCenterCrop(size=sample_size)
# if input_mode == 'rgb':
# norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
# elif input_mode == 'dynamic-images':
# # norm = Normalize([0.49778724, 0.49780366, 0.49776983], [0.09050678, 0.09017131, 0.0898702 ])
# norm = Normalize([38.756858/255, 3.88248729/255, 40.02898126/255], [110.6366688/255, 103.16065604/255, 96.29023126/255])
# else:
# norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
train_temporal_transform = build_temporal_transformation(
config, config.train_temporal_transform)
spatial_transform = Compose(
[crop_method,
GroupRandomHorizontalFlip(),
ToTensor(), norm])
target_transform = Label()
train_batch = config.train_batch
if dataset == RWF_DATASET:
# train_data = VioDB(g_path + '/VioDB/{}_jpg/frames/'.format(dataset),
# g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv), 'training',
# spatial_transform, temporal_transform, target_transform, dataset,
# tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path))
train_data = VioDB(
os.path.join(home_path, RWF_DATASET.upper(), 'frames/'),
os.path.join(home_path, VIO_DB_DATASETS, "rwf-2000_jpg1.json"),
'training',
spatial_transform,
train_temporal_transform,
target_transform,
dataset,
tmp_annotation_path=os.path.join(g_path,
config.temp_annotation_path),
input_type=config.input_type)
else:
train_data = VioDB(
os.path.join(home_path, VIO_DB_DATASETS, dataset +
'_jpg'), #g_path + '/VioDB/{}_jpg/'.format(dataset),
os.path.join(home_path, VIO_DB_DATASETS, '{}_jpg{}.json'.format(
dataset,
cv)), #g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv),
'training',
spatial_transform,
train_temporal_transform,
target_transform,
dataset,
tmp_annotation_path=os.path.join(g_path,
config.temp_annotation_path),
input_type=config.input_type)
train_loader = DataLoader(train_data,
batch_size=train_batch,
shuffle=True,
num_workers=0,
pin_memory=True)
# val set
crop_method = GroupScaleCenterCrop(size=sample_size)
# if input_mode == 'rgb':
# norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
# elif input_mode == 'dynamic-images':
# norm = Normalize([0.49778724, 0.49780366, 0.49776983], [0.09050678, 0.09017131, 0.0898702 ])
val_temporal_transform = build_temporal_transformation(
config, config.val_temporal_transform)
spatial_transform = Compose([crop_method, ToTensor(), norm])
target_transform = Label()
val_batch = config.val_batch
if dataset == RWF_DATASET:
# val_data = VioDB(g_path + '/VioDB/{}_jpg/frames/'.format(dataset),
# g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv), 'validation',
# spatial_transform, temporal_transform, target_transform, dataset,
# tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path))
val_data = VioDB(
os.path.join(home_path, RWF_DATASET.upper(), 'frames/'),
os.path.join(home_path, VIO_DB_DATASETS, "rwf-2000_jpg1.json"),
'validation',
spatial_transform,
val_temporal_transform,
target_transform,
dataset,
tmp_annotation_path=os.path.join(g_path,
config.temp_annotation_path),
input_type=config.input_type)
else:
val_data = VioDB(
os.path.join(home_path, VIO_DB_DATASETS, dataset +
'_jpg'), #g_path + '/VioDB/{}_jpg/'.format(dataset),
os.path.join(home_path, VIO_DB_DATASETS, '{}_jpg{}.json'.format(
dataset,
cv)), #g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv),
'validation',
spatial_transform,
val_temporal_transform,
target_transform,
dataset,
tmp_annotation_path=os.path.join(g_path,
config.temp_annotation_path),
input_type=config.input_type)
val_loader = DataLoader(val_data,
batch_size=val_batch,
shuffle=False,
num_workers=4,
pin_memory=True)
template = '{}_fps{}_{}_split({})_input({})_TmpTransform({})_Info({})'.format(
config.model, sample_duration, dataset, cv, input_mode,
config.train_temporal_transform, config.additional_info)
log_path = os.path.join(home_path, PATH_LOG, template)
# chk_path = os.path.join(PATH_CHECKPOINT, template)
tsb_path = os.path.join(home_path, PATH_TENSORBOARD, template)
for pth in [log_path, tsb_path]:
if not os.path.exists(pth):
os.mkdir(pth)
print('tensorboard dir:', tsb_path)
writer = SummaryWriter(tsb_path)
# log
batch_log = Log(log_path + '/batch_log.csv',
['epoch', 'batch', 'iter', 'loss', 'acc', 'lr'])
epoch_log = Log(log_path + '/epoch_log.csv',
['epoch', 'loss', 'acc', 'lr'])
val_log = Log(log_path + '/val_log.csv', ['epoch', 'loss', 'acc'])
train_val_log = Log(
log_path + '/train_val_LOG.csv',
['epoch', 'train_loss', 'train_acc', 'lr', 'val_loss', 'val_acc'])
# prepare
criterion = nn.CrossEntropyLoss().to(device)
learning_rate = config.learning_rate
momentum = config.momentum
weight_decay = config.weight_decay
optimizer = torch.optim.SGD(params=params,
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer, verbose=True, factor=config.factor, min_lr=config.min_lr)
acc_baseline = config.acc_baseline
loss_baseline = 1
for i in range(config.num_epoch):
train_loss, train_acc, lr = train(i, train_loader, model, criterion,
optimizer, device, batch_log,
epoch_log)
val_loss, val_acc = val(i, val_loader, model, criterion, device,
val_log)
epoch = i + 1
train_val_log.log({
'epoch': epoch,
'train_loss': train_loss,
'train_acc': train_acc,
'lr': lr,
'val_loss': val_loss,
'val_acc': val_acc
})
writer.add_scalar('training loss', train_loss, epoch)
writer.add_scalar('training accuracy', train_acc, epoch)
writer.add_scalar('validation loss', val_loss, epoch)
writer.add_scalar('validation accuracy', val_acc, epoch)
scheduler.step(val_loss)
if val_acc > acc_baseline or (val_acc >= acc_baseline
and val_loss < loss_baseline):
torch.save(
model.state_dict(),
os.path.join(
home_path, PATH_CHECKPOINT,
'{}_fps{}_{}{}_{}_{:.4f}_{:.6f}.pth'.format(
config.model, sample_duration, dataset, cv, epoch,
val_acc, val_loss)))
acc_baseline = val_acc
loss_baseline = val_loss
