def train()

in train_modular.py [0:0]

• 42 lines of code
• 9 McCabe index (conditional complexity)

def train(epoch):

    model.train()
    lossmeter = utils.AverageMeter()
    lossauxmeter = utils.AverageMeter()
    accmeter = utils.AverageMeter()

    train_loss = 0.0
    for idx, data in enumerate(trainloader):
        data = [d.cuda() for d in data]
        loss, all_losses, acc, _ = model(data)
        if acc is not None:
            accmeter.update(acc, data[0].shape[0])

        mainloss = all_losses['main_loss']
        lossmeter.update(mainloss.item(), data[0].shape[0])
        if 'aux_loss' in all_losses.keys():
            loss_aux = all_losses['aux_loss']
            lossauxmeter.update(loss_aux.item(), data[0].shape[0])

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss += loss.item()
        if idx % args.print_every == 0:
            print(
                'Epoch: {} Iter: {}/{} | Loss: {:.3f}, Loss Aux: {:.3f}, Acc: {:.2f}'.
                format(epoch, idx, len(trainloader), lossmeter.avg,
                       lossauxmeter.avg, accmeter.avg))
            print(','.join([
                '{}: {:.02f}  '.format(k, v.item())
                for k, v in all_losses.items()
            ]))

    train_loss = train_loss / len(trainloader)
    logger.add_scalar('train_loss', train_loss, epoch)
    for k, v in all_losses.items():
        logger.add_scalar('train_{}'.format(k), v.item(), epoch)
    print('Epoch: {} | Loss: {} | Acc: {}'.format(epoch, lossmeter.avg,
                                                  accmeter.avg))
    if epoch % args.save_every == 0:
        state = {
            'net': model.state_dict(),
            'epoch': epoch,
        }
        torch.save(state,
                   args.cv_dir + '/{}/ckpt_E_{}.t7'.format(args.name, epoch))