def main(args):
model = SimpleMLP(hidden_size=args.hs)
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr)
criterion = torch.nn.CrossEntropyLoss()
# check if selected GPU is available or use CPU
assert args.cuda == -1 or args.cuda >= 0, "cuda must be -1 or >= 0."
device = torch.device(
f"cuda:{args.cuda}"
if torch.cuda.is_available() and args.cuda >= 0
else "cpu"
)
print(f"Using device: {device}")
# create Permuted MNIST scenario
scenario = PermutedMNIST(n_experiences=4)
interactive_logger = InteractiveLogger()
eval_plugin = EvaluationPlugin(
accuracy_metrics(
minibatch=True, epoch=True, experience=True, stream=True
),
loss_metrics(minibatch=True, epoch=True, experience=True, stream=True),
forgetting_metrics(experience=True),
loggers=[interactive_logger],
)
# create strategy
assert (
len(args.lambda_e) == 1 or len(args.lambda_e) == 5
), "Lambda_e must be a non-empty list."
lambda_e = args.lambda_e[0] if len(args.lambda_e) == 1 else args.lambda_e
strategy = LFL(
model,
optimizer,
criterion,
lambda_e=lambda_e,
train_epochs=args.epochs,
device=device,
train_mb_size=args.minibatch_size,
evaluator=eval_plugin,
)
# train on the selected scenario with the chosen strategy
print("Starting experiment...")
results = []
for train_batch_info in scenario.train_stream:
print(
"Start training on experience ", train_batch_info.current_experience
)
strategy.train(train_batch_info, num_workers=0)
print(
"End training on experience ", train_batch_info.current_experience
)
print("Computing accuracy on the test set")
results.append(strategy.eval(scenario.test_stream[:]))
def test_PermutedMNIST_scenario_download_once(self):
global MNIST_DOWNLOADS
MNIST_DOWNLOADS = 0
scenario = PermutedMNIST(3)
self.assertEqual(3, len(scenario.train_stream))
self.assertEqual(3, len(scenario.test_stream))
self.assertEqual(1, MNIST_DOWNLOADS)
def test_PermutedMNIST_benchmark_download_once(self):
global MNIST_DOWNLOADS
MNIST_DOWNLOADS = 0
benchmark = PermutedMNIST(3)
self.assertEqual(3, len(benchmark.train_stream))
self.assertEqual(3, len(benchmark.test_stream))
self.assertEqual(1, MNIST_DOWNLOADS)
def main(args):
model = SimpleMLP(hidden_size=args.hs)
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr)
criterion = torch.nn.CrossEntropyLoss()
# check if selected GPU is available or use CPU
assert args.cuda == -1 or args.cuda >= 0, "cuda must be -1 or >= 0."
device = torch.device(f"cuda:{args.cuda}" if torch.cuda.is_available()
and args.cuda >= 0 else "cpu")
print(f'Using device: {device}')
# create scenario
if args.scenario == 'pmnist':
scenario = PermutedMNIST(n_experiences=args.permutations)
elif args.scenario == 'smnist':
scenario = SplitMNIST(n_experiences=5, return_task_id=False)
else:
raise ValueError("Wrong scenario name. Allowed pmnist, smnist.")
# choose some metrics and evaluation method
interactive_logger = InteractiveLogger()
text_logger = TextLogger(open('log.txt', 'a'))
eval_plugin = EvaluationPlugin(accuracy_metrics(minibatch=True,
epoch=True,
experience=True,
stream=True),
loss_metrics(minibatch=True,
epoch=True,
experience=True,
stream=True),
ExperienceForgetting(),
loggers=[interactive_logger])
# create strategy
strategy = EWC(model,
optimizer,
criterion,
args.ewc_lambda,
args.ewc_mode,
decay_factor=args.decay_factor,
train_epochs=args.epochs,
device=device,
train_mb_size=args.minibatch_size,
evaluator=eval_plugin)
# train on the selected scenario with the chosen strategy
print('Starting experiment...')
results = []
for experience in scenario.train_stream:
print("Start training on experience ", experience.current_experience)
strategy.train(experience)
print("End training on experience", experience.current_experience)
print('Computing accuracy on the test set')
results.append(strategy.eval(scenario.test_stream[:]))
def test_PermutedMNIST_scenario(self):
scenario = PermutedMNIST(3)
self.assertEqual(3, len(scenario.train_stream))
self.assertEqual(3, len(scenario.test_stream))
for task_info in scenario.train_stream:
self.assertIsInstance(task_info, Experience)
self.assertEqual(60000, len(task_info.dataset))
for task_info in scenario.test_stream:
self.assertIsInstance(task_info, Experience)
self.assertEqual(10000, len(task_info.dataset))
def test_PermutedMNIST_benchmark(self):
benchmark = PermutedMNIST(3)
self.assertEqual(3, len(benchmark.train_stream))
self.assertEqual(3, len(benchmark.test_stream))
for experience in benchmark.train_stream:
self.assertIsInstance(experience, Experience)
self.assertEqual(60000, len(experience.dataset))
load_experience_train_eval(experience)
for experience in benchmark.test_stream:
self.assertIsInstance(experience, Experience)
self.assertEqual(10000, len(experience.dataset))
load_experience_train_eval(experience)
def test_PermutedMNIST_scenario(self):
scenario = PermutedMNIST(3)
self.assertEqual(3, len(scenario.train_stream))
self.assertEqual(3, len(scenario.test_stream))
for experience in scenario.train_stream:
self.assertIsInstance(experience, Experience)
self.assertEqual(60000, len(experience.dataset))
load_experience_train_eval(experience)
for experience in scenario.test_stream:
self.assertIsInstance(experience, Experience)
self.assertEqual(10000, len(experience.dataset))
load_experience_train_eval(experience)
def main(args):
model = SimpleMLP(hidden_size=args.hs)
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr)
criterion = torch.nn.CrossEntropyLoss()
# check if selected GPU is available or use CPU
assert args.cuda == -1 or args.cuda >= 0, "cuda must be -1 or >= 0."
device = torch.device(f"cuda:{args.cuda}" if torch.cuda.is_available()
and args.cuda >= 0 else "cpu")
print(f"Using device: {device}")
# create scenario
if args.scenario == "pmnist":
scenario = PermutedMNIST(n_experiences=args.permutations)
elif args.scenario == "smnist":
mnist_train = MNIST(
root=expanduser("~") + "/.avalanche/data/mnist/",
train=True,
download=True,
transform=ToTensor(),
)
mnist_test = MNIST(
root=expanduser("~") + "/.avalanche/data/mnist/",
train=False,
download=True,
transform=ToTensor(),
)
scenario = nc_benchmark(mnist_train,
mnist_test,
5,
task_labels=False,
seed=1234)
else:
raise ValueError("Wrong scenario name. Allowed pmnist, smnist.")
# choose some metrics and evaluation method
interactive_logger = InteractiveLogger()
tensorboard_logger = TensorboardLogger()
eval_plugin = EvaluationPlugin(
accuracy_metrics(minibatch=True,
epoch=True,
experience=True,
stream=True),
loss_metrics(minibatch=True, epoch=True, experience=True, stream=True),
forgetting_metrics(experience=True, stream=True),
bwt_metrics(experience=True, stream=True),
loggers=[interactive_logger, tensorboard_logger],
)
# create strategy
strategy = EWC(
model,
optimizer,
criterion,
args.ewc_lambda,
args.ewc_mode,
decay_factor=args.decay_factor,
train_epochs=args.epochs,
device=device,
train_mb_size=args.minibatch_size,
evaluator=eval_plugin,
)
# train on the selected scenario with the chosen strategy
print("Starting experiment...")
results = []
for experience in scenario.train_stream:
print("Start training on experience ", experience.current_experience)
strategy.train(experience)
print("End training on experience", experience.current_experience)
print("Computing accuracy on the test set")
results.append(strategy.eval(scenario.test_stream[:]))
def main(args):
model = SimpleMLP(hidden_size=args.hs)
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr)
criterion = torch.nn.CrossEntropyLoss()
# check if selected GPU is available or use CPU
assert args.cuda == -1 or args.cuda >= 0, "cuda must be -1 or >= 0."
device = torch.device(f"cuda:{args.cuda}" if torch.cuda.is_available()
and args.cuda >= 0 else "cpu")
print(f"Using device: {device}")
# create scenario
if args.scenario == "pmnist":
scenario = PermutedMNIST(n_experiences=args.permutations)
elif args.scenario == "smnist":
scenario = SplitMNIST(n_experiences=5, return_task_id=False)
else:
raise ValueError("Wrong scenario name. Allowed pmnist, smnist.")
# choose some metrics and evaluation method
interactive_logger = InteractiveLogger()
eval_plugin = EvaluationPlugin(
accuracy_metrics(minibatch=True,
epoch=True,
experience=True,
stream=True),
loss_metrics(minibatch=True, epoch=True, experience=True, stream=True),
forgetting_metrics(experience=True),
loggers=[interactive_logger],
)
# create strategy
if args.strategy == "gem":
strategy = GEM(
model,
optimizer,
criterion,
args.patterns_per_exp,
args.memory_strength,
train_epochs=args.epochs,
device=device,
train_mb_size=10,
evaluator=eval_plugin,
)
elif args.strategy == "agem":
strategy = AGEM(
model,
optimizer,
criterion,
args.patterns_per_exp,
args.sample_size,
train_epochs=args.epochs,
device=device,
train_mb_size=10,
evaluator=eval_plugin,
)
else:
raise ValueError("Wrong strategy name. Allowed gem, agem.")
# train on the selected scenario with the chosen strategy
print("Starting experiment...")
results = []
for experience in scenario.train_stream:
print("Start training on experience ", experience.current_experience)
strategy.train(experience)
print("End training on experience ", experience.current_experience)
print("Computing accuracy on the test set")
results.append(strategy.eval(scenario.test_stream[:]))
