def test_each_model(name):
_, _, adj_test, _, _, features_test, _, _, labels_test, _, _ = load_data(
n_conf=args.n_conf, name_list=[name])
n_test = len(adj_test)
prob_list = np.zeros((n_test, n_class))
if args.model == 'SVM':
x, y = prepare_svm_data(features_test, labels_test)
#clf = SVC(gamma='auto', verbose=False)
#clf.fit(x, y)
pred = clf.predict(x)
prob_list = np.zeros(n_class)
for p in pred:
prob_list[p] += 1
prob_list /= len(pred)
print(prob_list)
return 0
for i in range(n_test):
model.eval()
output_test = model(features_test[i], adj_test[i])
preds_test = output_to_label(output_test)
for p in preds_test:
prob_list[i, p] += 1
prob_list[i] /= len(preds_test)
print(np.mean(prob_list, axis=0))
def test():
if args.model == 'SVM':
x, y = prepare_svm_data(features_test, labels_test)
clf.fit(x, y)
pred = clf.predict(x)
print(accuracy_score(pred, y))
return 0
running_loss_test = 0
running_tot_acc_test = 0
for i in range(n_test):
model.eval()
output_test = model(features_test[i], adj_test[i])
loss_test = F.nll_loss(output_test, labels_test[i])
tot_acc_test = accuracy(output_test, labels_test[i])
running_loss_test += loss_test
running_tot_acc_test += tot_acc_test
idx = labels_test[i].detach().numpy()[0]
print("Test set results:",
"loss= {:.4f}".format(running_loss_test / n_test),
"Total accuracy={:.4f}".format(running_tot_acc_test / n_test))
def train(epoch):
if args.model == 'SVM':
x, y = prepare_svm_data(features_test, labels_test)
clf.fit(x, y)
pred = clf.predict(x)
print(accuracy_score(pred, y))
exit(1)
t = time.time()
running_loss_train = 0
running_acc_train = 0
for i in range(n_train):
model.train()
optimizer.zero_grad()
output_train = model(features_train[i], adj_train[i])
loss_train = F.nll_loss(output_train, labels_train[i])
acc_train = accuracy(output_train, labels_train[i])
loss_train.backward()
optimizer.step()
running_loss_train += loss_train.data
running_acc_train += acc_train
running_loss_val = 0
running_acc_val = 0
for i in range(n_val):
model.eval()
output_val = model(features_val[i], adj_val[i])
loss_val = F.nll_loss(output_val, labels_val[i])
acc_val = accuracy(output_val, labels_val[i])
running_loss_val += loss_val.data
running_acc_val += acc_val
print('Epoch: {:04d}'.format(epoch + 1),
'loss_train: {:.4f}'.format(running_loss_train / n_train),
'acc_train: {:.4f}'.format(running_acc_train / n_train),
'loss_val: {:.4f}'.format(running_loss_val / n_val),
'acc_val: {:.4f}'.format(running_acc_val / n_val),
'time: {:.4f}s'.format(time.time() - t))
return [
epoch + 1, running_loss_train / n_train, running_acc_train / n_train,
running_loss_val / n_val, running_acc_val / n_val
]
def test():
if args.model == 'PCA':
pca = PCA(n_components=10)
x, y = prepare_svm_data(features, labels)
x_pca = pca.fit_transform(x)
return x_pca, y
encoded_list = []
decoded_list = []
label_list = []
running_loss = 0
for i in range(n):
model.eval()
encoded, decoded = model(features[i], adj[i], inv_adj[i])
loss = criterion(decoded, features[i])
running_loss += loss
encoded = encoded.detach().numpy()
decoded = decoded.detach().numpy()
label = labels[i].detach().numpy()
feature = features[i].detach().numpy()
for j in range(len(encoded)):
encoded_list.append(encoded[j])
label_list.append(label[j])
if i == 0:
decoded_list.append(decoded[0])
decoded_list.append(feature[0])
decoded_list = np.transpose(decoded_list)
print("Test set results:",
"loss= {:.4f}".format(running_loss/n))
return encoded_list, label_list