def main(cfg):
# ===== 0.random seed and set logger ===== #
logger = cfg._get_test_logger()
logger.write('# === MAIN TEST === #')
torch.manual_seed(cfg.random_seed)
torch.cuda.manual_seed(cfg.random_seed)
# ===== 1.load test data ===== #
logger.write('==> Test Data loading...')
test_dataset = cfg.dataset('test', cfg.data_param, cfg.transform_param,
logger)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=10,
shuffle=False,
num_workers=cfg.training_setting_param.num_workers,
pin_memory=False,
drop_last=True)
logger.write('==> Test Data loaded Successfully!')
# ===== 2.load the network ===== #
logger.write('==> Model loading...')
net = get_model(cfg.model_param).to(cfg.device)
assert osp.exists(cfg.test_setting_param.model_path)
logger.write("==> loading pretrained model '{}'".format(
cfg.test_setting_param.model_path))
net = load_pretrained_model(net, cfg.test_setting_param.model_path)
logger.write('==> Model loaded Successfully!')
# ===== 4.main test process ===== #
cfg.test(cfg, net, test_loader, logger)
def main(cfg):
# ===== 0.random seed and set logger ===== #
logger = cfg._get_train_logger()
logger.write('# ===== MAIN TRAINING ===== #')
torch.manual_seed(cfg.random_seed)
torch.cuda.manual_seed(cfg.random_seed)
# ===== 1.load train and val dataset ===== #
logger.write('==> Data loading...')
train_dataset = cfg.dataset('train', cfg.data_param, cfg.transform_param,
logger)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=cfg.training_setting_param.batch_size_per_gpu *
cfg.devices_num,
shuffle=True,
num_workers=cfg.training_setting_param.num_workers,
pin_memory=True,
drop_last=True)
val_dataset = cfg.dataset('val', cfg.data_param, cfg.transform_param,
logger)
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=cfg.training_setting_param.batch_size_per_gpu *
cfg.devices_num,
shuffle=False,
num_workers=cfg.training_setting_param.num_workers,
pin_memory=False,
drop_last=True)
logger.write('==> Data loaded Successfully!')
# ===== 2.load the network ===== #
logger.write('==> Model loading...')
time.sleep(2)
net = get_model(cfg.model_param).to(cfg.device)
input = torch.rand(cfg.transform_param.input_size)
params = count_param(net)
logger.write('%s totoal parameters: %.2fM (%d)' %
(cfg.model_param.model_name, params / 1e6, params))
# ===== 3.define loss and optimizer ===== #
#cfg.criterion = get_criterion(cfg.loss_param, cfg.task_name)
cfg.optimizer = get_optim(net, cfg.training_setting_param)
# ===== 4.optionally load a pretrained model or resume from one specific epoch ===== #
if cfg.pretrained_model_path is not None:
logger.write("==> loading pretrained model '{}'".format(
cfg.pretrained_model_path))
net = load_pretrained_model(net, cfg.pretrained_model_path)
if cfg.resume_ckpt_path is not None:
if os.path.isfile(cfg.resume_ckpt_path):
logger.write("==> loading checkpoint '{}'".format(
cfg.resume_ckpt_path))
net, cfg.resume_epoch, resume_metric_best = resume(
net, cfg.resume_ckpt_path)
logger.write("==> loaded checkpoint '{}' (epoch {})".format(
cfg.resume_ckpt_path, cfg.resume_epoch))
else:
logger.write("==> no checkpoint found at '{}'".format(
cfg.resume_ckpt_path))
os._exit(0)
# ===== 5.main training process ===== #
cudnn.benchmark = True
metric_best = resume_metric_best if cfg.resume_ckpt_path is not None else -1000
start_epoch = cfg.resume_epoch if cfg.resume_ckpt_path is not None else 0
logger.set_names([
'Epoch', 'Loss', 'Metric_Train', 'Metric_Val', 'Is_Best', 'Epoch_Time',
'End_Time'
])
for epoch in range(start_epoch, cfg.training_setting_param.epochs):
epoch_start_time = time.time()
print('==> Epoch: [{0}] Prepare Training... '.format(epoch))
torch.cuda.empty_cache()
# train for one epoch
loss_train, metric_train = cfg.train(cfg, net, train_loader, epoch)
# evaluate on validation set
metric_val = cfg.val(cfg, net, val_loader)
# save best checkpoints
is_best = metric_val > metric_best
metric_best = max(metric_val, metric_best)
save_ckpt(cfg, epoch, net, metric_val, metric_best, is_best)
# log epoch time and estimate the final end
epoch_time = (time.time() - epoch_start_time) / 60
final_end_time = estimate_final_end_time(
cfg.training_setting_param.epochs, epoch, epoch_time)
logger.append([
epoch, loss_train, metric_train, metric_val,
str(int(is_best)), epoch_time, final_end_time
])
def _train(args):
_set_seed(args["seed"])
factory.set_device(args)
inc_dataset = factory.get_data(args)
args["classes_order"] = inc_dataset.class_order
print(inc_dataset.class_order)
model = factory.get_model(args)
results = results_utils.get_template_results(args)
memory = None
for _ in range(inc_dataset.n_tasks):
task_info, train_loader, val_loader, test_loader = inc_dataset.new_task(
memory)
if task_info["task"] == args["max_task"]:
break
model.set_task_info(task=task_info["task"],
total_n_classes=task_info["max_class"],
increment=task_info["increment"],
n_train_data=task_info["n_train_data"],
n_test_data=task_info["n_test_data"],
n_tasks=task_info["max_task"])
model.eval()
model.before_task(train_loader, val_loader)
print("Train on {}->{}.".format(task_info["min_class"],
task_info["max_class"]))
model.train()
model.train_task(train_loader, val_loader)
model.eval()
model.after_task(inc_dataset)
#model._save_model("../model_weight/cifar_(2000)_ours_005009dissEweightDist_v2_withoutbias_order{}_task{}.pkl".format(args["order"], task_info["task"]))
print("Eval on {}->{}.".format(0, task_info["max_class"]))
#ypred, ytrue = model.eval_task(test_loader)
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(
test_loader)
acc_stats = utils.compute_accuracy(ynpred,
yntrue,
task_size=args["increment"])
print(acc_stats)
results["results"].append(acc_stats)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred,
ytrue,
task_size=args["increment"])
print('classifier: ', acc_stats)
with open(
'../results/results_txt/cifar_(1000)_learn50_ours_without_Norm_classifier.txt',
"a") as accuracy:
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
"""
#top5
acc_stats = utils.compute_accuracy(y_top5, ytrue, task_size=args["increment"])
print('classifier top5:',acc_stats)
with open('../results/results_txt/cifar_(2000)_ours_04dissEweightDist_nobias_classifier_top5.txt', "a") as accuracy:
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
"""
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred,
yntrue,
task_size=args["increment"])
print('nearest: ', acc_stats)
with open(
'../results/results_txt/cifar_(1000)_learn50_ours_without_Norm_nearest.txt',
"a") as accuracy:
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
"""
#top5
acc_stats = utils.compute_accuracy(yn_top5, yntrue, task_size=args["increment"])
print('nearest top5: ',acc_stats)
with open('../results/results_txt/cifar_(2000)_ours_04dissEweightDist_nobias_nearest_top5.txt', "a") as accuracy:
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
"""
"""
###############################Confusion matrix######################################
if _ == (inc_dataset.n_tasks-1) :
confusion = confusion_matrix(ytrue, ypred)
confusion_plot = sn.heatmap(confusion, annot=False, cbar=False,
xticklabels =10,yticklabels =10, square = True)
fig = confusion_plot.get_figure()
fig.savefig("../confusion_matrix/shuffle/cifar_(2000)_ours_04dissEweightDist_nobias/classifier"+str(args["order"])+".png")
confusion = confusion_matrix(yntrue, ynpred)
confusion_plot = sn.heatmap(confusion, annot=False, cbar=False,
xticklabels =10,yticklabels =10, square = True)
fig = confusion_plot.get_figure()
fig.savefig("../confusion_matrix/shuffle/cifar_(2000)_ours_04dissEweightDist_nobias/nearest"+str(args["order"])+".png")
#####################################################################################
"""
memory = model.get_memory()
print("Average Incremental Accuracy: {}.".format(
results_utils.compute_avg_inc_acc(results["results"])))
if args["name"]:
results_utils.save_results(results, args["name"])
del model
del inc_dataset
torch.cuda.empty_cache()
def _train(args):
_set_seed(args["seed"])
factory.set_device(args)
inc_dataset = factory.get_data(args)
args["classes_order"] = inc_dataset.class_order
model = factory.get_model(args)
results = results_utils.get_template_results(args)
memory = None
for _ in range(inc_dataset.n_tasks):
task_info, train_loader, val_loader, test_loader = inc_dataset.new_task(
memory)
if task_info["task"] == args["max_task"]:
break
model.set_task_info(task=task_info["task"],
total_n_classes=task_info["max_class"],
increment=task_info["increment"],
n_train_data=task_info["n_train_data"],
n_test_data=task_info["n_test_data"],
n_tasks=task_info["max_task"])
model.eval()
model.before_task(train_loader, val_loader)
print("Train on {}->{}.".format(task_info["min_class"],
task_info["max_class"]))
model.train()
model.train_task(train_loader, val_loader)
model.eval()
model.after_task(inc_dataset)
print("Eval on {}->{}.".format(0, task_info["max_class"]))
ypred, ytrue = model.eval_task(test_loader)
acc_stats = utils.compute_accuracy(ypred,
ytrue,
task_size=args["increment"])
print(acc_stats)
results["results"].append(acc_stats)
memory = model.get_memory()
print("Average Incremental Accuracy: {}.".format(
results_utils.compute_avg_inc_acc(results["results"])))
if args["name"]:
results_utils.save_results(results, args["name"])
######################
#with open('closs_L-_all_200.txt', 'w', newline='') as f:
# mywrite = csv.writer(f)
# mywrite.writerow(model._classification_loss)
#with open('gloss_L-_all_200.txt', 'w', newline='') as f:
# mywrite = csv.writer(f)
# mywrite.writerow(model._graph_loss)
del model
del inc_dataset
torch.cuda.empty_cache()
def _train(args):
_set_seed(args["seed"])
factory.set_device(args)
inc_dataset = factory.get_data(args)
# build ltl data loader (train:val = 0.5:0.5)
ltl_inc_dataset = factory.get_ltl_data(args)
# build ss data loader (batch size=1)
ss_inc_dataset = factory.get_ss_data(args)
gb_inc_dataset = factory.get_gb_data(args)
args["classes_order"] = inc_dataset.class_order
print(inc_dataset.class_order)
model = factory.get_model(args)
results = results_utils.get_template_results(args)
memory = None
###load pretrain model (metric)######################
#model._network.load_state_dict(torch.load('./net.weight'))
model._metric_network.load_state_dict(torch.load('../../iCaRL_new/model_weight/cifar_pretrain_metric_withNorm_nearest.pkl'))
#freeze
for param in model._metric_network.parameters():
param.requires_grad = False
model._metric_network.eval()
######################################
for _ in range(inc_dataset.n_tasks):
# the data loader is for pretraining model
task_info, train_loader, val_loader, test_loader = inc_dataset.new_task(memory)
# the data loader is for ss generator(nt yet implement)
task_info, ss_train_loader, ss_val_loader, ss_test_loader = ss_inc_dataset.new_task(memory)
if task_info["task"] == args["max_task"]:
break
# prepare to learn to learn (1st pretrain, 2nd ltl)
print("#################"+str(task_info["task"])+"#####################################")
if task_info["task"] == 0:
# the data loader is for training the gamma and beta (in cross domain method)
ltl_task_info, ltl_train_loader, ltl_val_loader, ltl_test_loader = ltl_inc_dataset.new_task(memory)
# get the data loader for train 100 classes
# the data loader is for training 100 classes together (to see the scaling and shifting can work or not)
gb_task_info, gb_train_loader, gb_val_loader, gb_test_loader = gb_inc_dataset.new_task(None)
# 1st pretrain
model.set_task_info(
task=task_info["task"],
total_n_classes=task_info["max_class"],
increment=task_info["increment"],
n_train_data=task_info["n_train_data"],
n_test_data=task_info["n_test_data"],
n_tasks=task_info["max_task"]
)
# adjust the controller of mtl weight, feature wise layer and need_grad
#change_ft(model, ft=False)
#change_mtl(model, mtl=False)
#change_ss_flag(model, flag=False)
#change_weight_requires_grad(model, normal_grad_need=True, mtl_grad_need=False)
#change_fw_requires_grad(model, fw_need=False)
model.eval()
model.before_task(train_loader, val_loader)
print("Train on {}->{}.".format(task_info["min_class"], task_info["max_class"]))
"""
model.train()
model.train_task(train_loader, val_loader)
"""
model._network.load_state_dict(torch.load('./pre_net.weight'))
model.eval()
# torch.save(model._network.state_dict(), './pre_net.weight')
model.after_task(inc_dataset)
print("Eval on {}->{}.".format(0, task_info["max_class"]))
# classify 100 class
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(train_loader)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('train classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('train nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
####################################################################################
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(test_loader)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
####################################################################################
# 2nd ltl
model.set_task_info(
task=ltl_task_info["task"],
total_n_classes=ltl_task_info["max_class"],
increment=ltl_task_info["increment"],
n_train_data=ltl_task_info["n_train_data"],
n_test_data=ltl_task_info["n_test_data"],
n_tasks=ltl_task_info["max_task"]
)
# use feature wise during training
#change_ft(model, ft=True)
model.eval()
model.before_task_to_2nd_ltl(ltl_train_loader, ltl_val_loader)
print("Train on {}->{}.".format(task_info["min_class"], task_info["max_class"]))
# model.train()
# model.ltl_train_task(ltl_train_loader, ltl_val_loader)
model._network.load_state_dict(torch.load('./ss_net.weight'))
model.eval()
# torch.save(model._network.state_dict(), './ss_net.weight')
model.after_task(inc_dataset)
print("Eval on {}->{}.".format(0, task_info["max_class"]))
# classify 100 class
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(train_loader)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('train classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('train nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
####################################################################################
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(test_loader)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
####################################################################################
# train the ss generator
# close the ft and open the mtl to train the scaling and shifting
#change_ft(model, ft=False)
#change_mtl(model, mtl=True)
#change_ss_flag(model, flag=True)
# fixed the normal weight
#chage_extractor_requires_grad(model, ex_need_1=False, ex_need_2=False, ex_need_3=False, ex_need=False)
# for the scaling and shifting (gamma beta)
#chage_extractor_requires_grad_mtl(model, ex_need_1=False, ex_need_2=False, ex_need_3=False, ex_need_1_bn_fw=False, ex_need_2_bn_fw=False, ex_need_3_bn_fw=False, ex_need=False) # <- not need now
#chage_extractor_requires_grad_gb(model, ex_need_1_bn_fw=True, ex_need_2_bn_fw=True, ex_need_3_bn_fw=True, ex_need=True)
# train the scaling and shifting
# gb_train_loader: 100 classes
model.before_ss(train_loader, val_loader, ss=True)
model.train()
model.train_ss(train_loader, val_loader)
model.eval()
# use inc_dataset to store the exemplars
# model.after_task(inc_dataset)
# model.after_task(ss_inc_dataset)
# model.after_task(inc_dataset)
# model.ss_after_task(ss_inc_dataset)
print('finish!!!!!!!!')
# gb_after_task: dosen't store the exemplars
model.gb_after_task(inc_dataset)
print("Eval on {}->{}.".format(0, task_info["max_class"]))
# classify 100 class
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(train_loader, ss=1)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('train classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('train nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
####################################################################################
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(test_loader, ss=1)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
memory = model.get_memory()
####################################################################################
#elif task_info["task"] == 1:
# break
else: # below not yet modified, need to modify when use ss generator
#change_ft(model, ft=False)
#change_mtl(model, mtl=True)
#change_ss_flag(model, flag=True)
# close the updates
#chage_extractor_requires_grad(model, ex_need_1=False, ex_need_2=False, ex_need_3=False, ex_need=False)
# for meta-transfer learning
#chage_extractor_requires_grad_mtl(model, ex_need_1=True, ex_need_2=True, ex_need_3=True, ex_need_1_bn_fw=True, ex_need_2_bn_fw=True, ex_need_3_bn_fw=True, ex_need=True)
# only open the mtl_weight of the stage_1, stage_2 and stage_3
# chage_extractor_requires_grad_mtl(model, ex_need_1=True, ex_need_2=True, ex_need_3=True, ex_need_1_bn_fw=False, ex_need_2_bn_fw=False, ex_need_3_bn_fw=False)
# only open the mtl_weight of the stage_3
# chage_extractor_requires_grad_mtl(model, ex_need_1=False, ex_need_2=False, ex_need_3=True, ex_need_1_bn_fw=False, ex_need_2_bn_fw=False, ex_need_3_bn_fw=False)
model.set_task_info(
task=task_info["task"],
total_n_classes=task_info["max_class"],
increment=task_info["increment"],
n_train_data=task_info["n_train_data"],
n_test_data=task_info["n_test_data"],
n_tasks=task_info["max_task"]
)
model.eval()
model.before_task(train_loader, val_loader) #extend classifier
#model.before_mtl(ss_train_loader, ss_val_loader)
model.before_ss(train_loader, val_loader, ss=True, cls_layer=True)
print("Train on {}->{}.".format(task_info["min_class"], task_info["max_class"]))
model.train()
#model.train_gb(train_loader, val_loader)
model.train_ss(train_loader, val_loader)
#################### train ssg after classifier #######################################
# model.before_ss(train_loader, val_loader, ss=True)
# print("Train on {}->{}.".format(task_info["min_class"], task_info["max_class"]))
# model.train()
# model.train_gb(train_loader, val_loader)
# model.train_ss(train_loader, val_loader)
#######################################################################################
model.eval()
model.gb_after_task(inc_dataset)
print("Eval on {}->{}.".format(0, task_info["max_class"]))
#ypred, ytrue = model.eval_task(test_loader)
# batch size = 1
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(train_loader, ss=1)
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('train classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('train nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("train\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
####################################################################################
ypred, ytrue, ynpred, yntrue, y_top5, yn_top5 = model.eval_task(test_loader, ss=1)
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print(acc_stats)
results["results"].append(acc_stats)
memory = model.get_memory()
####################################################################################
#classifier 100 classes
acc_stats = utils.compute_accuracy(ypred, ytrue, task_size=args["increment"])
print('classifier: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_classifier.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
#nearest 100 classes
acc_stats = utils.compute_accuracy(ynpred, yntrue, task_size=args["increment"])
print('nearest: ',acc_stats)
with open('./results/results_txt/'+args["name"]+'_nearest.txt', "a") as accuracy:
accuracy.write("test\n")
for i in acc_stats.values():
accuracy.write(str(i) + " ")
accuracy.write("\n")
memory = model.get_memory()
####################################################################################
"""
print(
"Average Incremental Accuracy: {}.".format(
results_utils.compute_avg_inc_acc(results["results"])
)
)
"""
#if args["name"]:
# results_utils.save_results(results, args["name"])
del model
del inc_dataset
del ss_inc_dataset
del ltl_inc_dataset
torch.cuda.empty_cache()