def main():
print(args)
device = torch.device('cuda')
maml = Meta(args).to(device)
tmp = filter(lambda x: x.requires_grad, maml.parameters())
num = sum(map(lambda x: np.prod(x.shape), tmp))
print(maml)
print('Total trainable tensors:', num)
trainset = Gen(args.task_num, args.k_spt, args.k_qry)
testset = Gen(args.task_num, args.k_spt, args.k_qry * 10)
for epoch in range(args.epoch):
ind = [i for i in range(trainset.xs.shape[0])]
np.random.shuffle(ind)
xs, ys = torch.Tensor(trainset.xs[ind]).to(device), torch.Tensor(
trainset.ys[ind]).to(device)
xq, yq = torch.Tensor(trainset.xq[ind]).to(device), torch.Tensor(
trainset.yq[ind]).to(device)
maml.train()
loss = maml(xs, ys, xq, yq, epoch)
print('Epoch: {} Initial loss: {} Train loss: {}'.format(
epoch, loss[0] / args.task_num, loss[-1] / args.task_num))
if (epoch + 1) % 50 == 0:
print("Evaling the model...")
torch.save(maml.state_dict(), 'save.pt')
# del(maml)
# maml = Meta(args).to(device)
# maml.load_state_dict(torch.load('save.pt'))
maml.eval()
i = random.randint(0, testset.xs.shape[0] - 1)
xs, ys = torch.Tensor(testset.xs[i]).to(device), torch.Tensor(
testset.ys[i]).to(device)
xq, yq = torch.Tensor(testset.xq[i]).to(device), torch.Tensor(
testset.yq[i]).to(device)
losses, losses_q, logits_q, _ = maml.finetunning(xs, ys, xq, yq)
print('Epoch: {} Initial loss: {} Test loss: {}'.format(
epoch, losses_q[0], losses_q[-1]))
def main():
torch.manual_seed(222)
torch.cuda.manual_seed_all(222)
np.random.seed(222)
## Task Learner Setup
task_config = [('conv2d', [32, 3, 3, 3, 1, 0]), ('relu', [True]),
('bn', [32]), ('max_pool2d', [2, 2, 0]),
('conv2d', [32, 32, 3, 3, 1, 0]), ('relu', [True]),
('bn', [32]), ('max_pool2d', [2, 2, 0]),
('conv2d', [32, 32, 3, 3, 1, 0]), ('relu', [True]),
('bn', [32]), ('max_pool2d', [2, 2, 0]),
('conv2d', [32, 32, 3, 3, 1, 0]), ('relu', [True]),
('bn', [32]), ('max_pool2d', [2, 1, 0]), ('flatten', []),
('linear', [args.n_way, 32 * 5 * 5])]
last_epoch = 0
suffix = "_v0"
save_path = os.getcwd() + '/data/model_batchsz' + str(
args.k_model) + '_stepsz' + str(
args.update_lr) + '_epoch' + str(last_epoch) + suffix + '.pt'
while os.path.isfile(save_path):
valid_epoch = last_epoch
last_epoch += 500
save_path = os.getcwd() + '/data/model_batchsz' + str(
args.k_model) + '_stepsz' + str(
args.update_lr) + '_epoch' + str(last_epoch) + suffix + '.pt'
save_path = os.getcwd() + '/data/model_batchsz' + str(
args.k_model) + '_stepsz' + str(
args.update_lr) + '_epoch' + str(valid_epoch) + suffix + '.pt'
device = torch.device('cuda')
task_mod = Meta(args, task_config).to(device)
task_mod.load_state_dict(torch.load(save_path))
task_mod.eval()
## AL Learner Setup
print(args)
al_config = [('linear', [1, 32 * 5 * 5])]
device = torch.device('cuda')
maml = AL_Learner(args, al_config, task_mod).to(device)
tmp = filter(lambda x: x.requires_grad, maml.parameters())
num = sum(map(lambda x: np.prod(x.shape), tmp))
print(maml)
print('Total trainable tensors:', num)
# batchsz here means total episode number
mini = MiniImagenet('/home/tesca/data/miniimagenet/',
mode='train',
n_way=args.n_way,
k_shot=1,
k_query=args.k_qry,
batchsz=10000,
resize=args.imgsz)
mini_test = MiniImagenet('/home/tesca/data/miniimagenet/',
mode='test',
n_way=args.n_way,
k_shot=1,
k_query=args.k_qry,
batchsz=100,
resize=args.imgsz)
save_path = os.getcwd() + '/data/model_batchsz' + str(
args.k_model) + '_stepsz' + str(args.update_lr) + '_epoch'
for epoch in range(args.epoch // 10000):
# fetch meta_batchsz num of episode each time
db = DataLoader(mini,
args.task_num,
shuffle=True,
num_workers=1,
pin_memory=True)
for step, (x_spt, y_spt, x_qry, y_qry) in enumerate(db):
x_spt, y_spt, x_qry, y_qry = x_spt.to(device), y_spt.to(
device), x_qry.to(device), y_qry.to(device)
al_accs = maml(x_spt, y_spt, x_qry, y_qry)
if step % 30 == 0:
print('step:', step, '\tAL acc:', al_accs)
if step % 500 == 0: # evaluation
torch.save(maml.state_dict(),
save_path + str(step) + "_al_net.pt")
'''db_test = DataLoader(mini_test, 1, shuffle=True, num_workers=1, pin_memory=True)
def main():
torch.manual_seed(666)
torch.cuda.manual_seed_all(666)
np.random.seed(666)
# data_name = 'BlogCatalog'
print(args)
nb_epochs = 50
nb_runs = 16
nb_try = 16
nb_batch_maml = 10
nb_batch = 32
lr_1 = 0.03
lr_s = lr_1 * args.task_num
tr = 0.6
# features, labels, idx_train, y_train, idx_val, y_val, idx_labeled, train_unlabeled = SGC_process(data_name, degree=2, l_ratio=0.08, tr_ratio=0.8)
# print(args.task_num)
aucfile = 'results/auc_' + datetime.now().strftime("%m_%d_%H_%M") + '_yelp.txt'
with open(aucfile, 'a') as f:
f.write("settings: {labeled ratio: %f, training ratio: %f, epochs: %d, update_step: %d}\n" % (lr_1, tr, nb_epochs, args.update_step))
for t in range(nb_try):
taskData = task(nb_task=args.task_num, degree=2, l_ratio=lr_1, t_ratio=tr, name='yelp')
taskData.loadNProcess()
f.write("target data name:" + taskData.f_name[-1] + "\n")
f.write("%d-th try: \n" % t)
for i in range(nb_runs):
# training maml
print("maml training...")
print("In %d-th run..." % (i + 1))
f.write("%d-th run\n" % i)
feature_list, label, l_list, ul_list, idx_test = taskData.sampleAnomaly()
config = modelArch(feature_list[0].shape[1], args.n_way)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
maml = Meta(args, config).to(device)
# stats of parameters to be updated
tmp = filter(lambda x: x.requires_grad, maml.parameters())
num = sum(map(lambda x: np.prod(x.shape), tmp))
# print(maml)
print("Total #trainable tensors: ", num)
batch_gen = DataLoaderN(feature_list, l_list, ul_list, b_size=8, b_size_qry=6, nb_task=args.task_num, device=device)
maml.train()
for e in range(1, nb_epochs + 1):
print("Running %d-th epoch" % e)
epoch_loss = 0
epoch_acc = 0
for b in range(nb_batch_maml):
x_train, y_train, x_qry, y_qry = batch_gen.getBatch(qry=False)
y_pred, loss = maml(x_train, y_train, x_qry, y_qry)
epoch_loss += loss
print("Epoch loss: %f" % epoch_loss)
print("End of training.")
# testing
print("Evaluating the maml model")
maml.eval()
x_test, y_test = feature_list[args.task_num-1][idx_test].to(device), label[idx_test].to(device)
auc_roc, auc_pr, ap = maml.evaluating(x_test, y_test)
print("End of evaluating.")
f.write("MAML auc_roc: %.5f, auc_pr: %.5f, ap: %.5f\n" % (auc_roc, auc_pr, ap))
# g-dev training
print('G-dev training...')
features, labels, idx_labeled, idx_unlabeled, idx_test = SGC_process(taskData.target, degree=2, l_ratio=lr_s, tr_ratio=tr)
# print("finish loading data...")
attr_dim = features.shape[1]
# print("%d-th run:" % i)
# model = FCNet(attr_dim, 1).to(device)
# model = SGC_original(attr_dim, 1).to(device)
model = SGC(attr_dim, 1).to(device)
# print(model)
optim = torch.optim.Adam(model.parameters(), lr=0.002, weight_decay=0)
# loss = deviation_loss()
data_sampler = DataLoader(features, idx_labeled, idx_unlabeled, b_size=8)
model.float()
model.train()
for e in range(1, nb_epochs + 1):
# print('Epoch: %d' % e)
epoch_loss = 0
epoch_acc = 0
for b in range(nb_batch):
x_b, y_b = data_sampler.getBatch()
x_b, y_b = x_b.to(device), y_b.to(device)
y_pred = model(x_b)
loss = deviation_loss(y_b, y_pred)
optim.zero_grad()
loss.backward()
optim.step()
epoch_loss += loss.item()
print("epoch loss %f" % epoch_loss)
# validation
model.eval()
# print(idx_val.shape)
x_val = features[idx_test].to(device)
# print(x_val.shape)
y_pred = model(x_val).detach().cpu().numpy()
y_val = labels[idx_test].detach().cpu().numpy()
# fpr, tpr, roc_auc = dict(), dict(), dict()
# for i in range(2):
# fpr[i], tpr[i], _ = roc_curve(y_val, y_pred, pos_label=1)
# roc_auc[i] = auc(fpr[i], tpr[i])
auc_roc, _, auc_pr = aucPerformance(y_val, y_pred)
print("G-dev auc_roc: %.5f, auc_pr: %.5f" % (auc_roc, auc_pr))
f.write("G-Dev auc_roc: %.5f, auc_pr: %.5f\n" % (auc_roc, auc_pr))
f.close()
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')
