#open logger

f = open(osp.join(working_dir, args.logs_dir, 'exp_info.txt'), 'w')

f.write('experiment was run with following parameters:\n')

for key, value in vars(args).items():

f.write('{} : {} \n'.format(key, value))

"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""

lr = default_lr * (0.1 ** (epoch // 30))

for param_group in optimizer.param_groups:

normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],

std=[0.229, 0.224, 0.225])

test_transformer = T.Compose([

T.Resize(256),

T.CenterCrop(224),

T.ToTensor(),

normalizer,

])

train_transformer = T.Compose([

T.RandomResizedCrop(224),

T.RandomHorizontalFlip(),

T.ToTensor(),

normalizer,

])

#open annotation_file

val_labels = None

with open(val_ann_file) as infile:

val_labels = infile.readlines()

infile.close()

train_labels = None

with open(train_ann_file) as infile:

train_labels = infile.readlines()

infile.close()

train_loader = DataLoader(

VideoTrainPreprocessor(train_data_dir, train_labels, transform=train_transformer, num_frames = args.n_frames),

batch_size=batch_size, num_workers=workers, shuffle=True,

pin_memory=True, drop_last=True)

val_loader = DataLoader(

VideoTrainPreprocessor(val_data_dir, val_labels, transform=test_transformer),

batch_size=batch_size, num_workers=workers,

shuffle=False, pin_memory=True)

np.random.seed(args.seed)

torch.manual_seed(args.seed)

cudnn.benchmark = True

cudnn.enabled = True

sys.stdout = Logger(osp.join(working_dir, args.logs_dir, 'log.txt'))

dump_exp_inf(args)

train_loader, val_loader = \

get_data(args.train_data_dir, args.train_ann_file,

args.val_data_dir, args.val_ann_file,

args.height, args.width, args.batch_size, args.workers)

model = models.create(args.arch, n_classes = 63)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = nn.DataParallel(model).to(device)

criterion = nn.BCEWithLogitsLoss().to(device)

# define loss function (criterion) and optimizer

optimizer = torch.optim.SGD(model.parameters(), args.lr,

momentum=args.momentum,

weight_decay=args.weight_decay)

if args.evaluate:

validate(val_loader, model, criterion, device)

return

best_prec1 = 0

for epoch in range(args.start_epoch, args.epochs):

adjust_learning_rate(optimizer, epoch, args.lr)

# train for one epoch

train(train_loader, model, criterion, optimizer, epoch, device)

# evaluate on validation set

prec1 = validate(val_loader, model, criterion, device)

# remember best prec@1 and save checkpoint

is_best = prec1 > best_prec1

best_prec1 = max(prec1, best_prec1)

save_checkpoint({

'epoch': epoch + 1,

'arch': args.arch,

'state_dict': model.module.state_dict(),

'best_prec1': best_prec1,

'optimizer' : optimizer.state_dict(),

batch_time = AverageMeter()

data_time = AverageMeter()

losses = AverageMeter()

topk = [AverageMeter() for i in range(4)]

# switch to train mode

model.train()

end = time.time()

for i, (input, target) in enumerate(train_loader):

# measure data loading time

data_time.update(time.time() - end)

target = target.float()

if input.dim() > 4:

input = input.reshape(input.shape[0] * input.shape[1], input.shape[2], input.shape[3], input.shape[4])

#target = target.float()

target = target.reshape(target.shape[0] * target.shape[1], target.shape[2])

#target = torch.from_numpy(target).float()

input = input.to(device)

target = target.to(device)

# compute output

output = model(input)

output = output.cpu()

target = target.cpu()

loss = criterion(output, target)

# measure accuracy and record loss

prec = accuracy(output, target, topk=4)

for k in range(4):

topk[k].update(prec[k], input.size(0))

losses.update(loss.item(), input.size(0))

# compute gradient and do SGD step

optimizer.zero_grad()

loss.backward()

optimizer.step()

# measure elapsed time

batch_time.update(time.time() - end)

end = time.time()

if i % args.print_freq == 0:

print('Epoch: [{0}][{1}/{2}]\t'

'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'

'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'

'Loss {loss.val:.4f} ({loss.avg:.4f})\n'

'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'

'Prec@2 {top2.val:.3f} ({top2.avg:.3f})\t'

'Prec@3 {top3.val:.3f} ({top3.avg:.3f})\t'

'Prec@4 {top4.val:.3f} ({top4.avg:.3f})\t'.format(

epoch, i, len(train_loader), batch_time=batch_time,

data_time=data_time, loss=losses, top1=topk[0], top2=topk[1],

batch_time = AverageMeter()

losses = AverageMeter()

topk = [AverageMeter() for i in range(4)]

# switch to evaluate mode

model.eval()

with torch.no_grad():

end = time.time()

for i, (input, target) in enumerate(val_loader):

if input.dim() > 4:

input = input.reshape(input.shape[0] * input.shape[1], input.shape[2], input.shape[3], input.shape[4])

#target = target.float()

target = target.reshape(target.shape[0] * target.shape[1], target.shape[2])

input = input.to(device)

target = target.to(device)

target = target.float()

# compute output

output = model(input)

loss = criterion(output, target)

# measure accuracy and record loss

output = output.cpu()

target = target.cpu()

prec = accuracy(output, target, topk=4)

for i in range(4):

topk[i].update(prec[i], input.size(0))

losses.update(loss.item(), input.size(0))

# measure elapsed time

batch_time.update(time.time() - end)

end = time.time()

if i % args.print_freq == 0:

print('Test: [{0}/{1}]\t'

'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'

'Loss {loss.val:.4f} ({loss.avg:.4f})\n'

'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'

'Prec@2 {top2.val:.3f} ({top2.avg:.3f})\t'

'Prec@3 {top3.val:.3f} ({top3.avg:.3f})\t'

'Prec@4 {top4.val:.3f} ({top4.avg:.3f})\t'.format(

i, len(val_loader), batch_time=batch_time,

loss=losses, top1=topk[0], top2=topk[1],

top3=topk[2], top4=topk[3]))

print(' * Prec@1 {top1.avg:.3f} Prec@2 {top2.avg:.3f} Prec@3 {top3.avg:.3f} Prec@4 {top4.avg:.3f}'

.format(top1=topk[0], top2=topk[1], top3=topk[2], top4=topk[3]))

res = np.zeros(topk)

for i in range(outputs.shape[0]):

res += ch_metric(outputs[i], tags[i], topk)

res /= outputs.shape[0]

y = tags.numpy().flatten().nonzero()

y = set(y[0])

res = np.zeros(topk)

for i in range(1, topk + 1):

_, pred = output.topk(i)

pred = set(pred.numpy())

res[i - 1] = len(set.intersection(pred, y)) / len(set.union(pred, y))