예제 #1
0
def main(args):
    rePrint('-------------------------------------------------------------------------------------')
    vadDict = pickle.load(open(args.vad_file, 'rb'))
    validFile = os.path.join(args.valid_path, args.valid_file.format(args.split_num-1))
    rePrint('  [LoadModelData {:s}]'.format(validFile))
    #validData = LoadModelData(validFile, 'valid')
    validData = LoadModelDataVAD(validFile, vadDict, args.alpha, 'valid')
    validLoad = torch.utils.data.DataLoader(validData,
                        batch_size=args.batch_size, shuffle=False, num_workers=4)

    rePrint('  [Create model: {:s} num_classes: {:d}]'.format(args.model, args.num_classes))
    net = eval(args.model)(num_classes=args.num_classes)
    net = net.cuda()

    optimizer = torch.optim.SGD(net.parameters(), lr=args.lr,
                                momentum=args.momentum,
                                weight_decay=args.weight_decay)

    scheduler = ReduceLROnPlateau(optimizer, mode='min',
                                  factor=args.factor,
                                  patience=args.patience,
                                  verbose=False, threshold=1e-6,
                                  threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-8)

    rePrint('')
    rePrint('-------------------------------------------------------------------------------------')
    rePrint('  [Train {:s}]'.format(args.model))
    rePrint('-------------------------------------------------------------------------------------')
    modelPath = os.path.join(args.model_path, args.model+args.fea_type)
    make_path(modelPath)
    for epoch in range(args.epochs):
        #print type(epoch), epoch
        save_file = os.path.join(modelPath, args.model_file).format(epoch)

        for splitID in range(args.split_num-1):
            train_file = os.path.join(args.train_path, args.train_file.format(splitID))
            rePrint('  [LoadModelData {:s}]'.format(train_file))
            #trainData = LoadModelData(train_file, 'train')
            trainData = LoadModelDataVAD(train_file, vadDict, args.alpha, 'train')
            trainLoad = torch.utils.data.DataLoader(trainData,
                                batch_size=args.batch_size, shuffle=True, num_workers=4)

            net = train_model(net=net,
                        trainLoad=trainLoad,
                        optimizer=optimizer,
                        log_interval=args.log_interval,
                        epoch=epoch,
                        batch_size=args.batch_size,
                        lr=optimizer.param_groups[0]['lr'],
                        save_file=None)

        torch.save(net.state_dict(), save_file)
        rePrint(save_file)    

        eval_loss = valid_model(net=net, validLoad=validLoad)
        scheduler.step(eval_loss)

        rePrint('-------------------------------------------------------------------------------------')
    rePrint('  [Done]')
    rePrint('-------------------------------------------------------------------------------------')
예제 #2
0
def main(args):
    rePrint(
        '-------------------------------------------------------------------------------------'
    )
    rePrint('  [LoadModelData {:s}]'.format(args.train_file))
    trainData = LoadModelData(args.train_file, 'train')
    trainLoad = torch.utils.data.DataLoader(trainData,
                                            batch_size=args.batch_size,
                                            shuffle=True,
                                            num_workers=4)

    rePrint('  [LoadModelData {:s}]'.format(args.valid_file))
    validData = LoadModelData(args.valid_file, 'valid')
    validLoad = torch.utils.data.DataLoader(validData,
                                            batch_size=args.batch_size,
                                            shuffle=False,
                                            num_workers=4)

    rePrint('  [Create model: {:s} num_classes: {:d}]'.format(
        args.model, args.num_classes))
    net = eval(args.model)(num_classes=args.num_classes)
    net = net.cuda()

    optimizer = torch.optim.SGD(net.parameters(),
                                lr=args.lr,
                                momentum=args.momentum,
                                weight_decay=args.weight_decay)

    scheduler = ReduceLROnPlateau(optimizer,
                                  mode='min',
                                  factor=args.factor,
                                  patience=args.patience,
                                  verbose=False,
                                  threshold=1e-6,
                                  threshold_mode='rel',
                                  cooldown=0,
                                  min_lr=0,
                                  eps=1e-8)

    rePrint('')
    rePrint(
        '-------------------------------------------------------------------------------------'
    )
    rePrint('  [Train {:s}]'.format(args.model))
    rePrint(
        '-------------------------------------------------------------------------------------'
    )
    make_path(os.path.join(args.model_path, args.model))
    for epoch in range(args.epochs):
        save_file = os.path.join(args.model_path, args.model,
                                 args.model_file).format(epoch)
        train_model(net=net,
                    trainLoad=trainLoad,
                    optimizer=optimizer,
                    log_interval=args.log_interval,
                    epoch=epoch,
                    batch_size=args.batch_size,
                    lr=optimizer.param_groups[0]['lr'],
                    save_file=save_file)
        eval_loss = valid_model(net=net, validLoad=validLoad)
        scheduler.step(eval_loss)
        rePrint(
            '-------------------------------------------------------------------------------------'
        )
    rePrint('  [Done]')
    rePrint(
        '-------------------------------------------------------------------------------------'
    )