예제 #1
0
def CAKT_main(**kwargs):
    opt = Config()

    for k_, v_ in kwargs.items():
        setattr(opt, k_, v_)

    if opt.vis:
        vis = Visualizer(opt.env)
    else:
        vis = None

    # init_loss_file(opt)
    if opt.data_source == "statics" or opt.data_source == "assist2017":
        opt.fold_dataset = True
    train_path, valid_path, test_path = init_file_path(opt)
    print("data_source:{} fold_dataset:{}".format(opt.data_source,
                                                  opt.fold_dataset))

    # random_state = random.randint(1, 50)
    # print("random_state:", random_state)
    train_dataset = KTData(train_path,
                           fold_dataset=opt.fold_dataset,
                           q_numbers=opt.output_dim,
                           opt='None')
    valid_dataset = KTData(valid_path,
                           fold_dataset=opt.fold_dataset,
                           q_numbers=opt.output_dim,
                           opt='None')
    test_dataset = KTData(test_path,
                          fold_dataset=opt.fold_dataset,
                          q_numbers=opt.output_dim,
                          opt='None')

    # print(train_path, valid_path, test_path)
    print(len(train_dataset), len(valid_dataset), len(test_dataset))

    train_loader = DataLoader(train_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True,
                              num_workers=opt.num_workers,
                              drop_last=True,
                              collate_fn=myutils.collate_fn)
    valid_loader = DataLoader(valid_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True,
                              num_workers=opt.num_workers,
                              drop_last=True,
                              collate_fn=myutils.collate_fn)
    test_loader = DataLoader(test_dataset,
                             batch_size=opt.batch_size,
                             shuffle=True,
                             num_workers=opt.num_workers,
                             drop_last=True,
                             collate_fn=myutils.collate_fn)
    print("model name is {}, next is inital model".format(opt.model_name))
    if opt.model_name == "CAKT_dev":
        model = CAKT_dev(opt.k_frames, opt.knowledge_length,
                         opt.concept_length, opt.knowledge_emb_size,
                         opt.interaction_emb_size, opt.lstm_hidden_dim,
                         opt.lstm_num_layers, opt.batch_size, opt.device)
    elif opt.model_name == "CAKT":
        model = CAKT(opt.k_frames, opt.input_dim, opt.H, opt.embed_dim,
                     opt.hidden_dim, opt.num_layers, opt.output_dim,
                     opt.batch_size, opt.device)
    elif opt.model_name == "CAKT_CI":
        model = CAKT_CI(opt.k_frames, opt.input_dim, opt.H, opt.embed_dim,
                        opt.hidden_dim, opt.num_layers, opt.output_dim,
                        opt.batch_size, opt.device)
    elif opt.model_name == "CAKT_ablation":
        print("initial abaltion model: ", opt.ablation)
        model = CAKT_ablation(opt.k_frames, opt.input_dim, opt.H,
                              opt.embed_dim, opt.hidden_dim, opt.num_layers,
                              opt.output_dim, opt.batch_size, opt.device,
                              opt.ablation)

    lr = opt.lr
    last_epoch = -1

    optimizer = torch.optim.Adam(params=model.parameters(),
                                 lr=lr,
                                 weight_decay=opt.weight_decay,
                                 betas=(0.9, 0.99))
    if opt.model_path:
        map_location = lambda storage, loc: storage
        checkpoint = torch.load(opt.model_path, map_location=map_location)
        model.load_state_dict(checkpoint["model"])
        last_epoch = checkpoint["epoch"]
        lr = checkpoint["lr"]
        optimizer.load_state_dict(checkpoint["optimizer"])

    if torch.cuda.device_count() == 1:
        model = model.to(opt.device)
    elif torch.cuda.device_count() == 2:
        model = nn.DataParallel(model, device_ids=[0, 1])
        model = model.to(opt.device)
    elif torch.cuda.device_count() == 4:
        model = nn.DataParallel(model, device_ids=[0, 1, 2, 3])
        model = model.to(opt.device)

    loss_result = {}
    auc_resilt = {}
    best_test_auc = 0
    # START TRAIN
    for epoch in range(opt.max_epoch):
        torch.cuda.empty_cache()
        if epoch < last_epoch:
            continue

        if opt.model_name == "CAKT" or opt.model_name == "CAKT_CI" or opt.model_name == "CAKT_ablation":
            train_loss_meter, train_auc_meter, train_all_auc, train_loss_list = train_cakt(
                opt, vis, model, train_loader, epoch, lr, optimizer)
            val_loss_meter, val_auc_meter, val_all_auc, val_loss_list = valid_cakt(
                opt, vis, model, valid_loader, epoch)
            test_loss_meter, test_auc_meter, test_all_auc, test_loss_list = test_cakt(
                opt, vis, model, test_loader, epoch)

        loss_result["train_loss"] = train_loss_meter.value()[0]
        # auc_resilt["train_auc"] = train_auc_meter.value()[0]
        auc_resilt["train_auc"] = train_all_auc
        loss_result["val_loss"] = val_loss_meter.value()[0]
        # auc_resilt["val_auc"] = val_auc_meter.value()[0]
        auc_resilt["val_auc"] = val_all_auc
        loss_result["test_loss"] = test_loss_meter.value()[0]
        # auc_resilt["test_auc"] = test_auc_meter.value()[0]
        auc_resilt["test_auc"] = test_all_auc

        for k, v in loss_result.items():
            print("epoch:{epoch}, {k}:{v:.5f}".format(epoch=epoch, k=k, v=v))
            if opt.vis:
                vis.line(X=np.array([epoch]),
                         Y=np.array([v]),
                         win="loss",
                         opts=dict(title="loss", showlegend=True),
                         name=k,
                         update='append')
        for k, v in auc_resilt.items():
            print("epoch:{epoch}, {k}:{v:.5f}".format(epoch=epoch, k=k, v=v))
            if opt.vis:
                vis.line(X=np.array([epoch]),
                         Y=np.array([v]),
                         win="auc",
                         opts=dict(title="auc", showlegend=True),
                         name=k,
                         update='append')

        # best_test_auc = max(best_test_auc, test_auc_meter.value()[0], val_auc_meter.value()[0])
        best_test_auc = max(best_test_auc, test_all_auc, val_all_auc)
        print("best_test_auc is: ", best_test_auc)

        # TODO 每个epoch结束后把loss写入文件
        myutils.save_loss_file(opt, epoch, train_loss_list, val_loss_list,
                               test_loss_list)

        # TODO 每个epoch结束后把AUC写入文件
        myutils.save_auc_file(opt, epoch, train_all_auc, val_all_auc,
                              test_all_auc)

        # TODO 每save_every个epoch结束后保存模型参数+optimizer参数
        # if epoch % opt.save_every == 0:
        if best_test_auc == test_all_auc or best_test_auc == val_all_auc:
            myutils.save_model_weight(opt, model, optimizer, epoch, lr)

        # TODO 做lr_decay
        lr = myutils.adjust_lr(opt, optimizer, epoch,
                               train_loss_meter.value()[0])

    # TODO 结束的时候保存final模型参数
    myutils.save_model_weight(opt, model, optimizer, epoch, lr, is_final=True)

    return best_test_auc
예제 #2
0
def main(**kwargs):
    opt = Config()

    for k_, v_ in kwargs.items():
        setattr(opt, k_, v_)

    if opt.vis:
        vis = Visualizer(opt.env)
    else:
        vis = None

    init_loss_file(opt)
    if opt.data_source == "statics":
        opt.fold_dataset = True
    train_path, valid_path, test_path = init_file_path(opt)
    # print(opt.fold_dataset)

    # random_state = random.randint(1, 50)
    # print("random_state:", random_state)
    train_dataset = KTData(train_path,
                           fold_dataset=opt.fold_dataset,
                           q_numbers=opt.output_dim,
                           opt='None')
    valid_dataset = KTData(valid_path,
                           fold_dataset=opt.fold_dataset,
                           q_numbers=opt.output_dim,
                           opt='None')
    test_dataset = KTData(test_path,
                          fold_dataset=opt.fold_dataset,
                          q_numbers=opt.output_dim,
                          opt='None')

    print(len(train_dataset), len(valid_dataset), len(test_dataset))

    train_loader = DataLoader(train_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True,
                              num_workers=opt.num_workers,
                              drop_last=True,
                              collate_fn=myutils.collate_fn)
    valid_loader = DataLoader(valid_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True,
                              num_workers=opt.num_workers,
                              drop_last=True,
                              collate_fn=myutils.collate_fn)
    test_loader = DataLoader(test_dataset,
                             batch_size=opt.batch_size,
                             shuffle=True,
                             num_workers=opt.num_workers,
                             drop_last=True,
                             collate_fn=myutils.collate_fn)

    if opt.model_name == "EKT":
        model = EKTM_dev(knowledge_length=110,
                         knowledge_emb_size=100,
                         seq_hidden_size=100,
                         is_text=opt.is_text,
                         text_emb_size=100)

    random_text_token = torch.randn((100, ))

    lr = opt.lr
    last_epoch = -1

    optimizer = torch.optim.Adam(params=model.parameters(),
                                 lr=lr,
                                 weight_decay=opt.weight_decay,
                                 betas=(0.9, 0.99))
    if opt.model_path:
        map_location = lambda storage, loc: storage
        checkpoint = torch.load(opt.model_path, map_location=map_location)
        model.load_state_dict(checkpoint["model"])
        last_epoch = checkpoint["epoch"]
        lr = checkpoint["lr"]
        optimizer.load_state_dict(checkpoint["optimizer"])

    model = model.to(opt.device)

    loss_result = {}
    auc_resilt = {}
    best_test_auc = 0
    # START TRAIN
    for epoch in range(opt.max_epoch):
        if epoch < last_epoch:
            continue
        if opt.model_name == "EKT":
            train_loss_meter, train_auc_meter, train_loss_list = run_ekt.train_ekt(
                opt, vis, model, train_loader, epoch, lr, optimizer)
            val_loss_meter, val_auc_meter, val_loss_list = run_ekt.valid_ekt(
                opt, vis, model, valid_loader, epoch)
            test_loss_meter, test_auc_meter, test_loss_list = val_loss_meter, val_auc_meter, val_loss_list
            # test_loss_meter, test_auc_meter, test_loss_list = run_ekt.test_ekt(opt, vis, model, test_loader, epoch)

        loss_result["train_loss"] = train_loss_meter.value()[0]
        auc_resilt["train_auc"] = train_auc_meter.value()[0]
        loss_result["val_loss"] = val_loss_meter.value()[0]
        auc_resilt["val_auc"] = val_auc_meter.value()[0]
        loss_result["test_loss"] = test_loss_meter.value()[0]
        auc_resilt["test_auc"] = test_auc_meter.value()[0]

        for k, v in loss_result.items():
            print("epoch:{epoch}, {k}:{v:.5f}".format(epoch=epoch, k=k, v=v))
            if opt.vis:
                vis.line(X=np.array([epoch]),
                         Y=np.array([v]),
                         win="loss",
                         opts=dict(title="loss", showlegend=True),
                         name=k,
                         update='append')
        for k, v in auc_resilt.items():
            print("epoch:{epoch}, {k}:{v:.5f}".format(epoch=epoch, k=k, v=v))
            if opt.vis:
                vis.line(X=np.array([epoch]),
                         Y=np.array([v]),
                         win="auc",
                         opts=dict(title="auc", showlegend=True),
                         name=k,
                         update='append')

        best_test_auc = max(best_test_auc,
                            test_auc_meter.value()[0],
                            val_auc_meter.value()[0])
        print("best_test_auc is: ", best_test_auc)

        # TODO 每个epoch结束后把loss写入文件
        myutils.save_loss_file(opt, epoch, train_loss_list, val_loss_list,
                               test_loss_list)

        # TODO 每save_every个epoch结束后保存模型参数+optimizer参数
        if epoch % opt.save_every == 0:
            myutils.save_model_weight(opt, model, optimizer, epoch, lr)

        # TODO 做lr_decay
        lr = myutils.adjust_lr(opt, optimizer, epoch,
                               train_loss_meter.value()[0])

    # TODO 结束的时候保存final模型参数
    myutils.save_model_weight(opt, model, optimizer, epoch, lr, is_final=True)
예제 #3
0
def run_one_setting(**kwargs):
    opt = Config()

    for k_, v_ in kwargs.items():
        setattr(opt, k_, v_)

    print(opt.__dict__)

    if opt.vis:
        vis = Visualizer(opt.env)
    else:
        vis = None

    init_loss_file(opt)

    if opt.data_source == "statics":
        opt.fold_dataset = True
    train_path, valid_path, test_path = init_file_path(opt)
    print(opt.fold_dataset)
    print(opt.ablation)
    train_dataset = KTData(train_path,
                           fold_dataset=opt.fold_dataset,
                           q_numbers=opt.output_dim,
                           opt='None')
    test_dataset = KTData(test_path,
                          fold_dataset=opt.fold_dataset,
                          q_numbers=opt.output_dim,
                          opt='None')

    print(len(train_dataset), len(test_dataset))

    train_loader = DataLoader(train_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True,
                              num_workers=opt.num_workers,
                              drop_last=True,
                              collate_fn=myutils.collate_fn)
    test_loader = DataLoader(test_dataset,
                             batch_size=opt.batch_size,
                             shuffle=True,
                             num_workers=opt.num_workers,
                             drop_last=True,
                             collate_fn=myutils.collate_fn)

    if opt.model_name == "CNN_ablation":
        model = CNN_ablation(opt.k_frames, opt.input_dim, opt.embed_dim,
                             opt.hidden_dim, opt.num_layers, opt.output_dim,
                             opt.batch_size, opt.device, opt.ablation)

    lr = opt.lr
    optimizer = torch.optim.Adam(params=model.parameters(),
                                 lr=lr,
                                 weight_decay=opt.weight_decay,
                                 betas=(0.9, 0.99))

    model = model.to(opt.device)

    best_test_auc = 0
    # START TRAIN
    for epoch in range(opt.max_epoch):
        torch.cuda.empty_cache()
        train_loss_meter, train_auc_meter, train_loss_list = train.train(
            opt, vis, model, train_loader, epoch, lr, optimizer)
        torch.cuda.empty_cache()
        test_loss_meter, test_auc_meter, test_loss_list = test.test(
            opt, vis, model, test_loader, epoch)

        print("epoch{}, {k}:{v:.5f}".format(epoch,
                                            k="train_auc",
                                            v=train_auc_meter.value()[0]))
        print("epoch{}, {k}:{v:.5f}".format(epoch,
                                            k="test_auc",
                                            v=test_auc_meter.value()[0]))

        best_test_auc = max(best_test_auc, test_auc_meter.value()[0])
        print("best_test_auc is: ", best_test_auc)

        # TODO 做lr_decay
        lr = myutils.adjust_lr(opt, optimizer, epoch,
                               train_loss_meter.value()[0])

    return best_test_auc
예제 #4
0
def run_train_valid(opt, vis):
    print(opt.__dict__)
    train_path, valid_path, test_path = init_file_path(opt)

    train_dataset = KTData(train_path, opt='None')
    valid_dataset = KTData(valid_path, opt='None')

    print(train_path, valid_path)
    print(len(train_dataset), len(valid_dataset))

    train_loader = DataLoader(train_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True,
                              num_workers=opt.num_workers,
                              drop_last=True,
                              collate_fn=myutils.collate_fn)
    valid_loader = DataLoader(valid_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True,
                              num_workers=opt.num_workers,
                              drop_last=True,
                              collate_fn=myutils.collate_fn)

    if opt.model_name == "CNN":
        model = CNN(opt.input_dim, opt.embed_dim, opt.hidden_dim,
                    opt.num_layers, opt.output_dim, opt.batch_size, opt.device)
    elif opt.model_name == "CNN_3D":
        model = CNN_3D(opt.input_dim, opt.embed_dim, opt.hidden_dim,
                       opt.num_layers, opt.output_dim, opt.batch_size,
                       opt.device)
    else:
        model = RNN_DKT(opt.input_dim, opt.embed_dim, opt.hidden_dim,
                        opt.num_layers, opt.output_dim, opt.batch_size,
                        opt.device)

    lr = opt.lr
    last_epoch = -1
    previous_loss = 1e10

    optimizer = torch.optim.Adam(params=model.parameters(),
                                 lr=lr,
                                 weight_decay=opt.weight_decay,
                                 betas=(0.9, 0.99))
    if opt.model_path:
        map_location = lambda storage, loc: storage
        checkpoint = torch.load(opt.model_path, map_location=map_location)
        model.load_state_dict(checkpoint["model"])
        last_epoch = checkpoint["epoch"]
        lr = checkpoint["lr"]
        optimizer.load_state_dict(checkpoint["optimizer"])

    model = model.to(opt.device)

    train_loss_list = []
    train_auc_list = []
    valid_loss_list = []
    valid_auc_list = []
    # START TRAIN
    for epoch in range(opt.max_epoch):
        if epoch < last_epoch:
            continue

        train_loss_meter, train_auc_meter, _ = train.train_3d(
            opt, vis, model, train_loader, epoch, lr, optimizer)
        val_loss_meter, val_auc_meter, _ = train.valid_3d(
            opt, vis, model, valid_loader, epoch)

        print("epoch: {}, train_auc: {}, val_auc: {}".format(
            epoch,
            train_auc_meter.value()[0],
            val_auc_meter.value()[0]))

        train_loss_list.append(train_loss_meter.value()[0])
        train_auc_list.append(train_auc_meter.value()[0])

        valid_loss_list.append(val_loss_meter.value()[0])
        valid_auc_list.append(val_auc_meter.value()[0])

        # TODO 每save_every个epoch结束后保存模型参数+optimizer参数
        if epoch % opt.save_every == 0:
            myutils.save_model_weight(opt,
                                      model,
                                      optimizer,
                                      epoch,
                                      lr,
                                      is_CV=True)

        # TODO 做lr_decay
        lr = myutils.adjust_lr(opt, optimizer, epoch)

    # TODO 结束的时候保存final模型参数
    myutils.save_model_weight(opt,
                              model,
                              optimizer,
                              epoch,
                              lr,
                              is_final=True,
                              is_CV=True)

    return train_loss_list, train_auc_list, valid_loss_list, valid_auc_list