# seed 2024 0.7 import torch.utils.data as Data train_idx = Data.TensorDataset(th.arange(0, nb_train, dtype=th.long)) val_idx = Data.TensorDataset(th.arange(nb_train, nb_train + nb_val, dtype=th.long)) test_idx = Data.TensorDataset(th.arange(nb_node - nb_test, nb_node, dtype=th.long)) doc_idx = Data.ConcatDataset([train_idx, val_idx, test_idx]) adj_norm = normalize_adj(adj + sp.eye(adj.shape[0])) print(adj_norm.shape) print(dgl.__version__) g = dgl.from_scipy(adj_norm.astype('float32'), eweight_name='edge_weight') # print(input_ids.shape) # print(attention_mask.shape) model = Hiclass(nb_class_first=nb_class_first, nb_class_second=nb_class_second, pretrained_model=bert_init, m=m, attention_unit_size=attention_unit_size, gcn_layers=gcn_layers, n_hidden=n_hidden, dropout=dropout) input_ids, attention_mask = encode_input(bert_list, model.tokenizer) input_ids = th.cat([input_ids[:-nb_test], th.zeros((nb_word, max_length), dtype=th.long), input_ids[-nb_test:]]) attention_mask = th.cat( [attention_mask[:-nb_test], th.zeros((nb_word, max_length), dtype=th.long), attention_mask[-nb_test:]]) y_level1 = y_train_level1 + y_test_level1 + y_val_level1 y_level2 = y_train_level2 + y_test_level2 + y_val_level2 doc_mask = train_mask + test_mask + val_mask g.ndata['input_ids'], g.ndata['attention_mask'] = input_ids, attention_mask g.ndata['label_level1'], g.ndata['label_level2'], g.ndata['train'], g.ndata['val'], g.ndata['test'] = th.LongTensor( y_level1), th.LongTensor(y_level2), th.FloatTensor(train_mask), th.FloatTensor(val_mask), th.FloatTensor(test_mask) g.ndata['label_train_level1'] = th.LongTensor(y_train_level1) g.ndata['label_train_level2'] = th.LongTensor(y_train_level2) g.ndata['label_test_level1'] = th.LongTensor(y_test_level1) g.ndata['label_test_level2'] = th.LongTensor(y_test_level2) g.ndata['cls_feats'] = th.zeros((nb_node, model.feat_dim)) idx_loader_train = Data.DataLoader(train_idx, batch_size=batch_size, shuffle=True) idx_loader_val = Data.DataLoader(val_idx, batch_size=batch_size) idx_loader_test = Data.DataLoader(test_idx, batch_size=batch_size) idx_loader = Data.DataLoader(doc_idx, batch_size=batch_size, shuffle=True) optimizer = th.optim.Adam([ {'params': model.bert_model.parameters(), 'lr': bert_lr}, {'params': model.hgat.parameters(), 'lr': gcn_lr}, {'params': model.bert_pred.parameters(), 'lr': bert_lr}, ], lr=1e-6 ) l_tra_h = [] l_tra_l = [] l_tra_p = [] l_tra_r = [] l_tra_f = [] l_tra_acc = [] l_tra_roc = [] l_val_h = [] l_val_l = [] l_val_p = [] l_val_r = [] l_val_f = [] l_val_acc = [] l_val_roc = [] l_tes_h = [] l_tes_l = [] l_tes_p = [] l_tes_r = [] l_tes_f = [] l_tes_acc = [] l_tes_roc = [] scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[30], gamma=0.1) Loss_mul = Loss_mutil() trainer = Engine(train_step) @trainer.on(Events.EPOCH_COMPLETED) def reset_graph(trainer): update_feature() evaluator = Engine(test_step) @trainer.on(Events.EPOCH_COMPLETED) def log_training_results(trainer): evaluator.run(idx_loader_train) metrics = evaluator.state.output train_nll, train_hamloss, train_au, train_jaccard, train_p, train_r, train_f, train_acc, train_roc_auc = metrics[ "val_loss"], \ metrics[ "eval_ham_loss"], \ metrics[ "AU(PRC)"], \ metrics[ 'jaccard'], \ metrics[ "precision"], \ metrics[ "recall"], \ metrics[ "F1"], \ metrics[ "Accuracy"], \ metrics[ "ROC-AUC"] evaluator.run(idx_loader_val) metrics = evaluator.state.output val_nll, val_hamloss, val_p, val_r, val_f, val_acc, val_roc_auc = metrics["val_loss"], metrics["eval_ham_loss"], \ metrics["precision"], metrics["recall"], metrics[ "F1"], metrics["Accuracy"], metrics["ROC-AUC"] evaluator.run(idx_loader_test) metrics = evaluator.state.output test_nll, test_hamloss, test_p, test_r, test_f, test_acc, test_roc_auc = metrics["val_loss"], metrics[ "eval_ham_loss"], metrics["precision"], metrics["recall"], metrics["F1"], metrics["Accuracy"], metrics[ "ROC-AUC"] print( "Epoch: {}\nTrain ham_loss: {:.4f} Train precision:{:.4f} Train recall:{:.4f} Train F1:{:.4f}\nTrain Accuracy:{:.4f}\nTrain ROC-AUC:{:.4f}\nval_ham_loss: {:.4f} Val precision:{:.4f} Val recall:{:.4f} Val F1:{:.4f}\nVal Accuracy:{:.4f}\nVal ROC-AUC:{:.4f}\nTest_ham_loss: {:.4f} Test precision:{:.4f} Test recall:{:.4f} Test F1:{:.4f} Test Accuracy:{:.4f}Test ROC-AUC:{:.4f}" .format(trainer.state.epoch, train_hamloss, train_p, train_r, train_f, train_acc, train_roc_auc, val_hamloss, val_p, val_r, val_f, val_acc, val_roc_auc, test_hamloss, test_p, test_r, test_f, test_acc, test_roc_auc)) l_tra_h.append(train_hamloss) l_tra_l.append(train_nll) l_tra_p.append(train_p) l_tra_r.append(train_r) l_tra_f.append(train_f) l_tra_acc.append(train_acc) l_tra_roc.append(train_roc_auc) l_val_h.append(val_hamloss) l_val_l.append(val_nll) l_val_p.append(val_p) l_val_r.append(val_r) l_val_f.append(val_f) l_val_acc.append(val_acc) l_val_roc.append(val_roc_auc) l_tes_h.append(test_hamloss) l_tes_l.append(test_nll) l_tes_p.append(test_p) l_tes_r.append(test_r) l_tes_f.append(test_f) l_tes_acc.append(test_acc) l_tes_roc.append(test_roc_auc) g = update_feature() trainer.run(idx_loader, max_epochs=nb_epochs)