def load_data(self):
self.args = get_args()
self.args.inductive = self.args.dataset in ['reddit', 'ppi']
self.args.sigmoid = self.args.dataset in ['ppi']
start_time = perf_counter()
if not self.args.inductive:
self.graph, self.feats, self.labels, self.label_max, self.idx, _ = load_citation(
self.args.dataset)
else:
self.graph, self.graph_test, self.feats, self.labels, self.label_max, self.idx = load_inductive_dataset(
self.args.dataset)
print("Data load and preprocess done: {:.4f}s".format(perf_counter() -
start_time))
parser.add_argument('--order_1', type=int, default=1)
parser.add_argument('--sct_inx1', type=int, default=1)
parser.add_argument('--order_2', type=int, default=1)
parser.add_argument('--sct_inx2', type=int, default=3)
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# Load data
#adj, features, labels, idx_train, idx_val, idx_test = load_data()
adj, A_tilde, adj_sct1, adj_sct2, adj_sct4, features, labels, idx_train, idx_val, idx_test = load_citation(
args.dataset, args.normalization, args.cuda)
# Model and optimizer
model = GCN(nfeat=features.shape[1],
para3=args.hid1,
para4=args.hid2,
nclass=labels.max().item() + 1,
dropout=args.dropout,
smoo=args.smoo)
PATH = "state_dict_model.pt"
model.load_state_dict(torch.load(PATH))
if args.cuda:
model = model.cuda()
features = features.cuda()
A_tilde = A_tilde.cuda()
adj = adj.cuda()
# Arguments
args = get_citation_args()
if args.tuned:
if args.model == "SGC":
with open("{}-tuning/{}.txt".format(args.model, args.dataset),
'rb') as f:
args.weight_decay = pkl.load(f)['weight_decay']
print("using tuned weight decay: {}".format(args.weight_decay))
else:
raise NotImplemented
# setting random seeds
set_seed(args.seed, args.cuda)
adj, features, labels, idx_train, idx_val, idx_test = load_citation(
args.dataset, args.normalization, args.cuda)
model = get_model(args.model, features.size(1),
labels.max().item() + 1, args.hidden, args.dropout,
args.cuda)
if args.model == "SGC":
features, precompute_time = sgc_precompute(features, adj, args.degree,
args.alpha)
print("{:.4f}s".format(precompute_time))
def train_regression(model,
train_features,
train_labels,
val_features,
def train():
acc_test_list = []
for ii in range(args.run_time):
#seed = gen_seeds()
seed = args.seed
print("dataset:{}, epochs:{}, weight_decay:{},lr:{},dropout:{},seed:{}, alpha:{}, features_perturbation: rate1:{},lambda1:{}; adj_pertubation: rate2:{},lambda2:{}".format(
args.dataset, args.epochs, args.weight_decay, args.lr, args.dropout, seed, args.alpha, args.rate1, args.lambda1, args.rate2,args.lambda2))
args.cuda = not args.no_cuda and torch.cuda.is_available()
np.random.seed(seed)
torch.manual_seed(seed)
if args.cuda:
torch.cuda.manual_seed(seed)
#torch.cuda.manual_seed(seed)
if args.dataset == "R8":
adj, features, labels, idx_train, idx_val, idx_test = load_corpus(args.dataset, args.normalization,args.cuda)
else:
adj, features, labels, idx_train, idx_val, idx_test, indices = load_citation(args.dataset, args.normalization, args.cuda)
model = GCN(nfeat=features.shape[1],
nhid=args.hidden,
nclass=labels.max().item() + 1,
dropout=args.dropout)
if args.cuda:
model.cuda()
features = features.cuda()
adj = adj.cuda()
labels = labels.cuda()
idx_train = idx_train.cuda()
idx_val = idx_val.cuda()
idx_test = idx_test.cuda()
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
global x,y,z
x,y,z=0,0,0
win = vis.line(X=np.array([x]),
Y=np.array([y]),
opts=dict(title='loss_CE'))
global b_1,b_2
b_0,b_1,b_2=0,0,0
win_b0 = vis.line(X=np.array([x]),
Y=np.array([b_0]),
opts=dict(title='b'))
def train(epoch):
t = time.time()
model.train()
optimizer.zero_grad()
output = model(features, adj)
output = F.log_softmax(output, dim=1)
loss_CE = F.nll_loss(output[idx_train], labels[idx_train])
#l2_reg = sum(torch.sum(param ** 2) for param in model.reg_params)
acc_train = accuracy(output[idx_train], labels[idx_train])
x = epoch
y = loss_CE.detach().cpu().numpy()
vis.line(X=np.array([x]),
Y=np.array([y]),
win=win,
update='append')
#loss_train = loss_CE + args.weight_decay /2 *l2_reg
loss_train = loss_CE
loss_train.backward()
optimizer.step()
if not args.fastmode:
model.eval()
output = model(features, adj)
output = F.log_softmax(output, dim=1)
loss_val = F.nll_loss(output[idx_val], labels[idx_val])
acc_val = accuracy(output[idx_val], labels[idx_val])
if ii == 0:
if epoch%10==0:
print('Epoch: {:04d}'.format(epoch + 1),
'loss_train: {:.4f}'.format(loss_train.item()),
'loss_CE: {:.4f}'.format(loss_CE.item()),
'acc_train: {:.4f}'.format(acc_train.item()),
#'loss_0: {:.4f}'.format(loss_0.item()),
# 'loss_fx: {:.4f}'.format(loss_fx.item()),
# 'loss_logfx: {:.4f}'.format(loss_logfx.item()),
# 'acc_train: {:.4f}'.format(acc_train.item()),
'loss_val: {:.4f}'.format(loss_val.item()),
'acc_val: {:.4f}'.format(acc_val.item()),
'time: {:.4f}s'.format(time.time() - t))
return loss_val.item()
def test():
model.eval()
output = model(features,adj)
output = F.log_softmax(output, dim=1)
loss_test = F.nll_loss(output[idx_test], labels[idx_test])
acc_test = accuracy(output[idx_test], labels[idx_test])
print("Test set results:",
"loss_test= {:.4f}".format(loss_test.item()),
"accuracy= {:.4f}".format(acc_test.item()))
return acc_test
t_total = time.time()
loss_values = []
# bad_counter = 0
# best = args.epochs+1
# best_epoch=0
# for epoch in range(args.epochs):
#
# loss_values.append(train(epoch))
# torch.save(model.state_dict(), './checkpoints/{}/{}.pkl'.format(args.dataset, epoch))
# if loss_values[-1] < best:
# best = loss_values[-1]
# best_epoch = epoch
# bad_counter = 0
# else:
# bad_counter += 1
# if bad_counter == args.patience:
# break
# files = glob.glob('./checkpoints/{}/*.pkl'.format(args.dataset)) # =[/checkpoints/{}/{}/0.pkl]
# for file in files:
# epoch_nb = int(file.split('.')[-2].split('/')[-1])
# if epoch_nb < best_epoch:
# os.remove(file)
# files = glob.glob('./checkpoints/{}/*.pkl'.format(args.dataset))
# for file in files:
# epoch_nb = int(file.split('.')[-2].split('/')[-1])
# if epoch_nb > best_epoch:
# os.remove(file)
# print("Optimization Finished!")
# print("Total time elapsed: {:.4f}s".format(time.time() - t_total))
#
# # Testing
# print('Loading {}th epoch'.format(best_epoch))
# model.load_state_dict(torch.load('./checkpoints/{}/{}.pkl'.format(args.dataset, best_epoch)))
for epoch in range(args.epochs):
loss_values.append(train(epoch))
if epoch>args.early_stop and loss_values[-1] > np.mean(loss_values[-(args.early_stop+1):-1]):
print("Early stopping...")
break
#train(epoch)
print("Optimization Finished!")
print("Total time elapsed: {:.4f}s".format(time.time() - t_total))
acc_test = test()
acc_test_list.append(acc_test)
acc_test = acc_test.view(1, 1)
acc_test = acc_test.cpu().numpy()
with open("./results/{}/{}.txt".format(args.dataset, args.dataset), 'a') as f:
# f.write("不丢弃dropout,加上b= {:.07f}×(output-output_1),epoch : {:04d},weight_decacy={},系数lam ={:.07f}".format
f.write("dataset{} epoch : {:04d},weight_decacy={}, lr{},seed{},dropout{},features_perturbation: rate1:{},lambda1:{}; adj_pertubation: rate2:{},lambda2:{}".format
(args.dataset, args.epochs, args.weight_decay, args.lr, seed, args.dropout,args.rate1,args.lambda1,args.rate2,args.lambda2))
np.savetxt(f, acc_test, fmt="%.6f")
acc_test_list = torch.FloatTensor(acc_test_list)
acc_test_std = torch.std(acc_test_list)
avg_test = torch.mean(acc_test_list)
avg_test = avg_test.view(1, 1)
avg_test = avg_test.cpu().numpy()
acc_test_std = acc_test_std.view(1, 1)
acc_test_std = acc_test_std.cpu().numpy()
print("总共做类{}次实验，平均值为：{:.04f}".format(args.run_time, avg_test.item()))
print("总共做类{}次实验，误差值为：{:.04f}".format(args.run_time,acc_test_std.item()))
with open("./results/{}/{}.txt".format(args.dataset, args.dataset), 'a') as f:
f.write("总共做类{}次实验，平均值为：{:.04f}\n".format(args.run_time, avg_test.item()))
f.write("总共做类{}次实验，误差值为：{:.04f}\n".format(args.run_time, acc_test_std.item()))
def main():
args = get_citation_args()
n_way = args.n_way
train_shot = args.train_shot
test_shot = args.test_shot
step = args.step
node_num = args.node_num
iteration = args.iteration
accuracy_meta_test = []
total_accuracy_meta_test = []
set_seed(args.seed, args.cuda)
adj, features, labels = load_citation(args.dataset, args.normalization,
args.cuda)
if args.dataset == 'cora':
class_label = [0, 1, 2, 3, 4, 5, 6]
combination = list(combinations(class_label, n_way))
elif args.dataset == 'citeseer':
node_num = 3327
iteration = 15
class_label = [0, 1, 2, 3, 4, 5]
combination = list(combinations(class_label, n_way))
if args.model == 'SGC':
features = sgc_precompute(features, adj, args.degree)
for i in range(len(combination)):
print('Cross_Validation: ', i + 1)
test_label = list(combination[i])
train_label = [n for n in class_label if n not in test_label]
print('Cross_Validation {} Train_Label_List {}: '.format(
i + 1, train_label))
print('Cross_Validation {} Test_Label_List {}: '.format(
i + 1, test_label))
model = get_model(args.model, features.size(1), n_way, args.cuda)
for j in range(iteration):
labels_local = labels.clone().detach()
select_class = random.sample(train_label, n_way)
print('Cross_Validation {} ITERATION {} Train_Label: {}'.format(
i + 1, j + 1, select_class))
class1_idx = []
class2_idx = []
for k in range(node_num):
if (labels_local[k] == select_class[0]):
class1_idx.append(k)
labels_local[k] = 0
elif (labels_local[k] == select_class[1]):
class2_idx.append(k)
labels_local[k] = 1
for m in range(step):
class1_train = random.sample(class1_idx, train_shot)
class2_train = random.sample(class2_idx, train_shot)
class1_test = [
n1 for n1 in class1_idx if n1 not in class1_train
]
class2_test = [
n2 for n2 in class2_idx if n2 not in class2_train
]
train_idx = class1_train + class2_train
random.shuffle(train_idx)
test_idx = class1_test + class2_test
random.shuffle(test_idx)
model = train_regression(model, features[train_idx],
labels_local[train_idx], args.epochs,
args.weight_decay, args.lr)
acc_query = test_regression(model, features[test_idx],
labels_local[test_idx])
reset_array()
torch.save(model.state_dict(), 'model.pkl')
labels_local = labels.clone().detach()
select_class = random.sample(test_label, 2)
class1_idx = []
class2_idx = []
reset_array()
print('Cross_Validation {} Test_Label {}: '.format(
i + 1, select_class))
for k in range(node_num):
if (labels_local[k] == select_class[0]):
class1_idx.append(k)
labels_local[k] = 0
elif (labels_local[k] == select_class[1]):
class2_idx.append(k)
labels_local[k] = 1
for m in range(step):
class1_train = random.sample(class1_idx, test_shot)
class2_train = random.sample(class2_idx, test_shot)
class1_test = [n1 for n1 in class1_idx if n1 not in class1_train]
class2_test = [n2 for n2 in class2_idx if n2 not in class2_train]
train_idx = class1_train + class2_train
random.shuffle(train_idx)
test_idx = class1_test + class2_test
random.shuffle(test_idx)
model_meta_trained = get_model(args.model, features.size(1), n_way,
args.cuda).cuda()
model_meta_trained.load_state_dict(torch.load('model.pkl'))
model_meta_trained = train_regression(model_meta_trained,
features[train_idx],
labels_local[train_idx],
args.epochs,
args.weight_decay, args.lr)
acc_test = test_regression(model_meta_trained, features[test_idx],
labels_local[test_idx])
accuracy_meta_test.append(acc_test)
total_accuracy_meta_test.append(acc_test)
reset_array()
if args.dataset == 'cora':
with open('cora.txt', 'a') as f:
f.write('Cross_Validation: {} Meta-Test_Accuracy: {}'.format(
i + 1,
torch.tensor(accuracy_meta_test).numpy().mean()))
f.write('\n')
elif args.dataset == 'citeseer':
with open('citeseer.txt', 'a') as f:
f.write('Cross_Validation: {} Meta-Test_Accuracy: {}'.format(
i + 1,
torch.tensor(accuracy_meta_test).numpy().mean()))
f.write('\n')
accuracy_meta_test = []
if args.dataset == 'cora':
with open('cora.txt', 'a') as f:
f.write('Dataset: {}, Train_Shot: {}, Test_Shot: {}'.format(
args.dataset, train_shot, test_shot))
f.write('\n')
f.write('Total_Meta-Test_Accuracy: {}'.format(
torch.tensor(total_accuracy_meta_test).numpy().mean()))
f.write('\n')
f.write('\n\n\n')
elif args.dataset == 'citeseer':
with open('citeseer.txt', 'a') as f:
f.write('Dataset: {}, Train_Shot: {}, Test_Shot: {}'.format(
args.dataset, train_shot, test_shot))
f.write('\n')
f.write('Total_Meta-Test_Accuracy: {}'.format(
torch.tensor(total_accuracy_meta_test).numpy().mean()))
f.write('\n')
f.write('\n\n\n')
if args.tuned:
if args.model == "SGC" or args.model == "KGCN":
with open("{}-tuning/{}.txt".format(args.model, args.dataset), 'rb') as f:
args.weight_decay = pkl.load(f)['weight_decay']
print("using tuned weight decay: {}".format(args.weight_decay))
else:
raise NotImplemented
# setting random seeds
set_seed(args.seed, args.cuda)
adj, features, labels, idx_train,\
idx_val, idx_test = load_citation(args.dataset,
args.normalization,
args.cuda,
args.invlap_alpha,
args.shuffle)
### NOISE TO FEATURES
if args.noise != "None":
features = features.numpy()
if args.noise == "gaussian":
features = gaussian(features,
mean=args.gaussian_opt[0],
std=args.gaussian_opt[1])
if args.noise == "gaussian_mimic":
features = gaussian_mimic(features)
if args.noise == "add_gaussian":
features = gaussian(features,
parser.add_argument('--dev', type=int, default=0, help='device id')
parser.add_argument('--alpha', type=float, default=0.1, help='decay factor')
parser.add_argument('--rmax', type=float, default=1e-5, help='threshold.')
parser.add_argument('--rrz', type=float, default=0.0, help='r.')
parser.add_argument('--bias', default='none', help='bias.')
parser.add_argument('--batch', type=int, default=64, help='batch size')
args = parser.parse_args()
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
print("--------------------------")
print(args)
features, labels, idx_train, idx_val, idx_test = load_citation(
args.data, args.alpha, args.rmax, args.rrz)
checkpt_file = 'pretrained/' + uuid.uuid4().hex + '.pt'
model = GnnBP(nfeat=features.shape[1],
nlayers=args.layer,
nhidden=args.hidden,
nclass=int(labels.max()) + 1,
dropout=args.dropout,
bias=args.bias).cuda(args.dev)
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
loss_fn = nn.CrossEntropyLoss()
train_time = perf_counter() - start_time
return model, train_time
def test_model(model, feats, labels, test_idx):
start_time = perf_counter()
model.eval()
output = model(feats)
acc_mic, acc_mac = calc_f1(labels[test_idx], output[test_idx])
test_time = perf_counter() - start_time
return acc_mic, acc_mac, test_time
start_time = perf_counter()
if not args.inductive:
graph, feats, labels, label_max, idx, _ = load_citation(args.dataset)
else:
graph, graph_test, feats, labels, label_max, idx = load_inductive_dataset(
args.dataset)
trial = 10
acc_acc = 0
acc_train_time = 0
acc_test_time = 0
for _ in range(trial):
model = get_auto_model(feats.size(1), graph, args.hidden_dim,
args.step_num, args.sample_num, args.nonlinear,
args.aggregator, label_max, args.dropout)
model, train_time = train_model(model, feats, labels, idx["train"],
idx["val"], args.epochs, args.weight_decay,
import os
print(os.getcwd())
if not args.non_tuned:
if args.model == "SGC":
with open("{}-tuning/{}.txt".format(args.model, args.dataset),
'rb') as f:
args.weight_decay = pkl.load(f)['weight_decay']
print("using tuned weight decay: {}".format(args.weight_decay))
else:
raise NotImplemented
# setting random seeds
set_seed(args.seed, args.cuda)
adj, features, labels, idx_train, idx_val, idx_test = load_citation(
args.dataset, args.normalization, args.cuda, args.modified, args.attacked)
model = get_model(args.model, features.size(1),
labels.max().item() + 1, args.hidden, args.dropout,
args.cuda)
if args.model == "SGC":
features, precompute_time = sgc_precompute(features, adj, args.degree)
print("{:.4f}s".format(precompute_time))
model_file = 'model_save/' + args.dataset + '.pkl'
def train_regression(model,
train_features,
train_labels,
val_features,
def main(args):
step = args.step
set_seed(args.seed)
adj, features, labels = load_citation(args.dataset, args.normalization)
features = sgc_precompute(features, adj, args.degree)
if args.dataset == 'citeseer':
node_num = 3327
class_label = [0, 1, 2, 3, 4, 5]
combination = list(combinations(class_label, 2))
elif args.dataset == 'cora':
node_num = 2708
class_label = [0, 1, 2, 3, 4, 5, 6]
combination = list(combinations(class_label, 2))
config = [('linear', [args.hidden, features.size(1)]),
('linear', [args.n_way, args.hidden])]
device = torch.device('cuda')
for i in range(len(combination)):
print("Cross Validation: {}".format((i + 1)))
maml = Meta(args, config).to(device)
test_label = list(combination[i])
train_label = [n for n in class_label if n not in test_label]
print('Cross Validation {} Train_Label_List: {} '.format(
i + 1, train_label))
print('Cross Validation {} Test_Label_List: {} '.format(
i + 1, test_label))
for j in range(args.epoch):
x_spt, y_spt, x_qry, y_qry = sgc_data_generator(
features, labels, node_num, train_label, args.task_num,
args.n_way, args.k_spt, args.k_qry)
accs = maml.forward(x_spt, y_spt, x_qry, y_qry)
print('Step:', j, '\tMeta_Training_Accuracy:', accs)
if j % 100 == 0:
torch.save(maml.state_dict(), 'maml.pkl')
meta_test_acc = []
for k in range(step):
model_meta_trained = Meta(args, config).to(device)
model_meta_trained.load_state_dict(torch.load('maml.pkl'))
model_meta_trained.eval()
x_spt, y_spt, x_qry, y_qry = sgc_data_generator(
features, labels, node_num, test_label, args.task_num,
args.n_way, args.k_spt, args.k_qry)
accs = model_meta_trained.forward(x_spt, y_spt, x_qry,
y_qry)
meta_test_acc.append(accs)
if args.dataset == 'citeseer':
with open('citeseer.txt', 'a') as f:
f.write(
'Cross Validation:{}, Step: {}, Meta-Test_Accuracy: {}'
.format(
i + 1, j,
np.array(meta_test_acc).mean(axis=0).astype(
np.float16)))
f.write('\n')
elif args.dataset == 'cora':
with open('cora.txt', 'a') as f:
f.write(
'Cross Validation:{}, Step: {}, Meta-Test_Accuracy: {}'
.format(
i + 1, j,
np.array(meta_test_acc).mean(axis=0).astype(
np.float16)))
f.write('\n')
action='store_true',
default=False,
help='GCN* model.')
parser.add_argument('--test',
action='store_true',
default=False,
help='evaluation on test set.')
args = parser.parse_args()
print(args)
support00 = np.load('supports/' + args.data + '_support00.npy')
support01 = np.load('supports/' + args.data + '_support01.npy')
support10 = np.load('supports/' + args.data + '_support10.npy')
support11 = np.load('supports/' + args.data + '_support11.npy')
adj, features, labels, idx_train, idx_val, idx_test = load_citation(args.data)
cudaid = "cuda:" + str(args.dev)
device = torch.device(cudaid)
features = features.to(device)
adj = adj.to(device)
support0 = torch.sparse_coo_tensor(support00, support01,
(adj.shape[0], adj.shape[0]))
support1 = torch.sparse_coo_tensor(support10, support11,
(adj.shape[0], adj.shape[0]))
support0 = support0.to(device).to(torch.float32)
support1 = support1.to(device).to_dense().to(torch.float32)
def build_and_train(hype_space):
modelname = 'nof'
modeltype = {
normalization_choices = [
'',
'AugNormAdj',
'LeftNorm',
'InvLap',
'CombLap',
'SymNormAdj',
'SymNormLap'
]
args = get_feat_args()
adj, features, labels, idx_train,\
idx_val, idx_test = load_citation(args.dataset,
normalization=args.normalization,
cuda=False)
model = get_model(model_opt=args.model,
nfeat=features.size(1),
nclass=labels.max().item()+1,
nhid=args.hidden,
dropout=args.dropout,
cuda=False)
# TODO: Calculate time here
features = features.numpy()
transformer = fetch_transformation(args.preprocess)
forward, invert, evals = transformer(adj.to_dense())
from models import get_model
from utils import sgc_precompute, load_citation, set_seed
from args import get_citation_args
import torch
from hyperopt import fmin, tpe, hp, STATUS_OK, Trials
# Arguments
args = get_citation_args()
# setting random seeds
set_seed(args.seed, args.cuda)
# Hyperparameter optimization
space = {'weight_decay' : hp.loguniform('weight_decay', log(1e-10), log(1e-4))}
adj, adj_dist, features, labels, idx_train, idx_val, idx_test = load_citation(args.dataset, args.normalization, args.cuda, gamma=args.gamma,degree=args.degree, L=args.L, K=args.K)
if args.model != "GCN":
features, precompute_time = sgc_precompute(features, adj, adj_dist, args.degree, args.concat, args.L, args.K, idx_train, idx_val, idx_test)
def sgc_objective(space):
if args.K:
model = get_model(args.model, features[0][0].size(1), labels.max().item()+1, args.hidden, args.decay, args.L, args.K, args.dropout, args.cuda)
else:
model = get_model(args.model, features.size(1), labels.max().item()+1, args.hidden, args.decay, args.L, args.K, args.dropout, args.cuda)
if args.model != 'GCN':
if args.K:
model, acc_val, _, _ = train_regression(model, features[0], labels[idx_train], features[1], labels[idx_val], features[2], labels[idx_test], idx_test, adj,
args.epochs, space['weight_decay'], args.lr, args.dropout)
else:
model, acc_val, _, _ = train_regression(model, features[idx_train], labels[idx_train], features[idx_val], labels[idx_val], features[idx_test], labels[idx_test], idx_test, adj,
args.epochs, space['weight_decay'], args.lr, args.dropout)
else:
# Arguments
args = get_citation_args()
if args.tuned:
if args.model == "SGC":
with open("{}-tuning/{}.txt".format(args.model, args.dataset),
'rb') as f:
args.weight_decay = pkl.load(f)['weight_decay']
print("using tuned weight decay: {}".format(args.weight_decay))
else:
raise NotImplemented
# setting random seeds
set_seed(args.seed, args.cuda)
adj, train_adj, val_adj, features, labels, idx_train, idx_val, idx_test = load_citation(
args.dataset, args.normalization, args.cuda, args.load_bigger_train)
model = get_model(args.model, features.size(1),
labels.max().item() + 1, args.hidden, args.dropout,
args.cuda)
if args.model == "SGC":
features, precompute_time = sgc_precompute(features, adj, args.degree)
print("{:.4f}s".format(precompute_time))
def train_regression(model,
train_features,
train_labels,
val_features,
val_labels,
