def __init__(self, model: Module, optimizer: Optimizer, criterion, mem_size: int = 200, train_mb_size: int = 1, train_epochs: int = 1, eval_mb_size: int = None, device=None, plugins: Optional[List[StrategyPlugin]] = None, evaluator: EvaluationPlugin = default_logger): """ Experience replay strategy. See ReplayPlugin for more details. This strategy does not use task identities. :param model: The model. :param optimizer: The optimizer to use. :param criterion: The loss criterion to use. :param mem_size: replay buffer size. :param train_mb_size: The train minibatch size. Defaults to 1. :param train_epochs: The number of training epochs. Defaults to 1. :param eval_mb_size: The eval minibatch size. Defaults to 1. :param device: The device to use. Defaults to None (cpu). :param plugins: Plugins to be added. Defaults to None. :param evaluator: (optional) instance of EvaluationPlugin for logging and metric computations. """ rp = ReplayPlugin(mem_size) if plugins is None: plugins = [rp] else: plugins.append(rp) super().__init__( model, optimizer, criterion, train_mb_size=train_mb_size, train_epochs=train_epochs, eval_mb_size=eval_mb_size, device=device, plugins=plugins, evaluator=evaluator)
def assert_balancing(self, policy): benchmark = get_fast_benchmark(use_task_labels=True) replay = ReplayPlugin(mem_size=100, storage_policy=policy) model = SimpleMLP(num_classes=benchmark.n_classes) # CREATE THE STRATEGY INSTANCE (NAIVE) cl_strategy = Naive( model, SGD(model.parameters(), lr=0.001), CrossEntropyLoss(), train_mb_size=100, train_epochs=0, eval_mb_size=100, plugins=[replay], evaluator=None, ) for exp in benchmark.train_stream: cl_strategy.train(exp) ext_mem = policy.buffer_groups ext_mem_data = policy.buffer_datasets print(list(ext_mem.keys()), [len(el) for el in ext_mem_data]) # buffer size should equal self.mem_size if data is large enough len_tot = sum([len(el) for el in ext_mem_data]) assert len_tot == policy.max_size
def get_method_plugins(args: Namespace): if args.method_name == "naive": return [] elif args.method_name == "replay_avalanche": return [ReplayPlugin()] elif args.method_name == "replay": memory = CILMemory(args.memory_size) return [CILMemoryPlugin(memory, HerdingMemoryStrategy()), CILReplayPlugin(memory)] elif args.method_name == "hybrid1": memory = CILMemory(args.memory_size) return [CILMemoryPlugin(memory, HerdingMemoryStrategy()), CILReplayPlugin(memory), LwFMCPlugin()] elif args.method_name == "iCaRL": return make_icarl_plugins(args.memory_size) elif args.method_name == "tricicl-P-ND": return make_tricicl_post_training_plugins(args.memory_size, distillation=False) elif args.method_name == "tricicl-P-D": return make_tricicl_post_training_plugins(args.memory_size, distillation=True) elif args.method_name == "tricicl-B-D": return make_tricicl_pre_training_plugins(args.memory_size, pre_distillation=True) elif args.method_name == "tricicl-A-D": return make_tricicl_alternate_training_plugins(args.memory_size, distillation=True) elif args.method_name == "tricicl-P-D-NME": return make_tricicl_post_training_plugins(args.memory_size, distillation=True, nme=True) elif args.method_name == "tricicl-B-D-NME": return make_tricicl_pre_training_plugins(args.memory_size, pre_distillation=True, nme=True) elif args.method_name == "tricicl-A-D-NME": return make_tricicl_alternate_training_plugins(args.memory_size, distillation=True, nme=True) # elif args.method_name == "tricicl": # return make_tricicl_during_training_plugin(args.memory_size, use_replay=True, nme=True, distillation=False) raise ValueError(f"Method {args.method_name} not supported")
def _test_replay_balanced_memory(self, storage_policy, mem_size): benchmark = get_fast_benchmark(use_task_labels=True) model = SimpleMLP(input_size=6, hidden_size=10) replayPlugin = ReplayPlugin( mem_size=mem_size, storage_policy=storage_policy ) cl_strategy = Naive( model, SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001), CrossEntropyLoss(), train_mb_size=32, train_epochs=1, eval_mb_size=100, plugins=[replayPlugin], ) n_seen_data = 0 for step in benchmark.train_stream: n_seen_data += len(step.dataset) mem_fill = min(mem_size, n_seen_data) cl_strategy.train(step) lengths = [] for d in replayPlugin.storage_policy.buffer_datasets: lengths.append(len(d)) self.assertEqual(sum(lengths), mem_fill) # Always fully filled
def test_replay_balanced_memory(self): scenario = self.create_scenario(task_labels=True) mem_size = 25 model = SimpleMLP(input_size=6, hidden_size=10) replayPlugin = ReplayPlugin(mem_size=mem_size) cl_strategy = Naive(model, SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001), CrossEntropyLoss(), train_mb_size=32, train_epochs=1, eval_mb_size=100, plugins=[replayPlugin]) for step in scenario.train_stream: curr_mem_size = min(mem_size, len(step.dataset)) cl_strategy.train(step) ext_mem = replayPlugin.ext_mem lengths = [] for task_id in ext_mem.keys(): lengths.append(len(ext_mem[task_id])) self.assertEqual(sum(lengths), curr_mem_size) difference = max(lengths) - min(lengths) self.assertLessEqual(difference, 1)
def main(args): # --- CONFIG device = torch.device(f"cuda:{args.cuda}" if torch.cuda.is_available() and args.cuda >= 0 else "cpu") n_batches = 5 # --------- # --- TRANSFORMATIONS train_transform = transforms.Compose([ RandomCrop(28, padding=4), ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) test_transform = transforms.Compose([ ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # --------- # --- SCENARIO CREATION mnist_train = MNIST('./data/mnist', train=True, download=True, transform=train_transform) mnist_test = MNIST('./data/mnist', train=False, download=True, transform=test_transform) scenario = nc_scenario( mnist_train, mnist_test, n_batches, task_labels=False, seed=1234) # --------- # MODEL CREATION model = SimpleMLP(num_classes=scenario.n_classes) # 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), ExperienceForgetting(), loggers=[interactive_logger]) # CREATE THE STRATEGY INSTANCE (NAIVE) cl_strategy = Naive(model, torch.optim.Adam(model.parameters(), lr=0.001), CrossEntropyLoss(), train_mb_size=100, train_epochs=4, eval_mb_size=100, device=device, plugins=[ReplayPlugin(mem_size=10000)], evaluator=eval_plugin ) # TRAINING LOOP print('Starting experiment...') results = [] for experience in scenario.train_stream: print("Start of experience ", experience.current_experience) cl_strategy.train(experience) print('Training completed') print('Computing accuracy on the whole test set') results.append(cl_strategy.eval(scenario.test_stream))
def main(args): # Model getter: specify dataset and depth of the network. model = pytorchcv_wrapper.resnet('cifar10', depth=20, pretrained=False) # Or get a more specific model. E.g. wide resnet, with depth 40 and growth # factor 8 for Cifar 10. # model = pytorchcv_wrapper.get_model("wrn40_8_cifar10", pretrained=False) # --- CONFIG device = torch.device(f"cuda:{args.cuda}" if torch.cuda.is_available() and args.cuda >= 0 else "cpu") device = "cpu" # --- TRANSFORMATIONS transform = transforms.Compose([ ToTensor(), transforms.Normalize((0.491, 0.482, 0.446), (0.247, 0.243, 0.261)) ]) # --- SCENARIO CREATION cifar_train = CIFAR10(root=expanduser("~") + "/.avalanche/data/cifar10/", train=True, download=True, transform=transform) cifar_test = CIFAR10(root=expanduser("~") + "/.avalanche/data/cifar10/", train=False, download=True, transform=transform) scenario = nc_benchmark( cifar_train, cifar_test, 5, task_labels=False, seed=1234, fixed_class_order=[i for i in range(10)]) # 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 THE STRATEGY INSTANCE (Naive, with Replay) cl_strategy = Naive(model, torch.optim.SGD(model.parameters(), lr=0.01), CrossEntropyLoss(), train_mb_size=100, train_epochs=1, eval_mb_size=100, device=device, plugins=[ReplayPlugin(mem_size=1000)], evaluator=eval_plugin ) # TRAINING LOOP print('Starting experiment...') results = [] for experience in scenario.train_stream: print("Start of experience ", experience.current_experience) cl_strategy.train(experience) print('Training completed') print('Computing accuracy on the whole test set') results.append(cl_strategy.eval(scenario.test_stream))
def test_dataload_batch_balancing(self): scenario = get_fast_scenario() model = SimpleMLP(input_size=6, hidden_size=10) batch_size = 32 replayPlugin = ReplayPlugin(mem_size=20) cl_strategy = Naive(model, SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001), CrossEntropyLoss(), train_mb_size=batch_size, train_epochs=1, eval_mb_size=100, plugins=[replayPlugin]) for step in scenario.train_stream: adapted_dataset = step.dataset dataloader = MultiTaskJoinedBatchDataLoader( adapted_dataset, AvalancheConcatDataset(replayPlugin.ext_mem.values()), oversample_small_tasks=True, num_workers=0, batch_size=batch_size, shuffle=True) for mini_batch in dataloader: lengths = [] for task_id in mini_batch.keys(): lengths.append(len(mini_batch[task_id][1])) if sum(lengths) == batch_size: difference = max(lengths) - min(lengths) self.assertLessEqual(difference, 1) self.assertLessEqual(sum(lengths), batch_size) cl_strategy.train(step)
def main(args): # --- CONFIG device = torch.device(f"cuda:{args.cuda}" if torch.cuda.is_available() and args.cuda >= 0 else "cpu") # --------- # --- TRANSFORMATIONS train_transform = transforms.Compose([ RandomCrop(28, padding=4), ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) test_transform = transforms.Compose([ ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # --------- # --- SCENARIO CREATION mnist_train = MNIST(root=expanduser("~") + "/.avalanche/data/mnist/", train=True, download=True, transform=train_transform) mnist_test = MNIST(root=expanduser("~") + "/.avalanche/data/mnist/", train=False, download=True, transform=test_transform) scenario = nc_scenario( mnist_train, mnist_test, 5, task_labels=False, seed=1234) # --------- # MODEL CREATION model = SimpleMLP(num_classes=scenario.n_classes) eval_plugin = EvaluationPlugin( accuracy_metrics(epoch=True, experience=True, stream=True), loss_metrics(epoch=True, experience=True, stream=True), # save image should be False to appropriately view # results in Interactive Logger. # a tensor will be printed StreamConfusionMatrix(save_image=False, normalize='all'), loggers=InteractiveLogger() ) # CREATE THE STRATEGY INSTANCE (NAIVE) cl_strategy = Naive( model, SGD(model.parameters(), lr=0.001, momentum=0.9), CrossEntropyLoss(), train_mb_size=100, train_epochs=4, eval_mb_size=100, device=device, evaluator=eval_plugin, plugins=[ReplayPlugin(5000)]) # TRAINING LOOP print('Starting experiment...') results = [] for experience in scenario.train_stream: print("Start of experience: ", experience.current_experience) print("Current Classes: ", experience.classes_in_this_experience) cl_strategy.train(experience) print('Training completed') print('Computing accuracy on the whole test set') results.append(cl_strategy.eval(scenario.test_stream))
def __init__( self, model: Module, optimizer: Optimizer, criterion, mem_size: int = 200, train_mb_size: int = 1, train_epochs: int = 1, eval_mb_size: int = None, device=None, plugins: Optional[List[SupervisedPlugin]] = None, evaluator: EvaluationPlugin = default_evaluator, eval_every=-1, **base_kwargs ): """Init. :param model: The model. :param optimizer: The optimizer to use. :param criterion: The loss criterion to use. :param mem_size: replay buffer size. :param train_mb_size: The train minibatch size. Defaults to 1. :param train_epochs: The number of training epochs. Defaults to 1. :param eval_mb_size: The eval minibatch size. Defaults to 1. :param device: The device to use. Defaults to None (cpu). :param plugins: Plugins to be added. Defaults to None. :param evaluator: (optional) instance of EvaluationPlugin for logging and metric computations. :param eval_every: the frequency of the calls to `eval` inside the training loop. -1 disables the evaluation. 0 means `eval` is called only at the end of the learning experience. Values >0 mean that `eval` is called every `eval_every` epochs and at the end of the learning experience. :param **base_kwargs: any additional :class:`~avalanche.training.BaseTemplate` constructor arguments. """ rp = ReplayPlugin(mem_size) if plugins is None: plugins = [rp] else: plugins.append(rp) super().__init__( model, optimizer, criterion, train_mb_size=train_mb_size, train_epochs=train_epochs, eval_mb_size=eval_mb_size, device=device, plugins=plugins, evaluator=evaluator, eval_every=eval_every, **base_kwargs )
def test_warning_slda_lwf(self): model, _, criterion, my_nc_benchmark = self.init_sit() with self.assertWarns(Warning) as cm: StreamingLDA( model, criterion, input_size=10, output_layer_name="features", num_classes=10, plugins=[LwFPlugin(), ReplayPlugin()], )
def test_warning_slda_lwf(self): model, _, criterion, my_nc_benchmark = self.init_sit() with self.assertLogs('avalanche.training.strategies', "WARNING") as cm: StreamingLDA(model, criterion, input_size=10, output_layer_name='features', num_classes=10, plugins=[LwFPlugin(), ReplayPlugin()]) self.assertEqual(1, len(cm.output)) self.assertIn( "LwFPlugin seems to use the callback before_backward" " which is disabled by StreamingLDA", cm.output[0] )
def __init__(self, model: Module, optimizer: Optimizer, criterion, mem_size: int = 200, train_mb_size: int = 1, train_epochs: int = 1, eval_mb_size: int = None, device=None, plugins: Optional[List[StrategyPlugin]] = None, evaluator: EvaluationPlugin = default_logger, eval_every=-1): """ Experience replay strategy. See ReplayPlugin for more details. This strategy does not use task identities. :param model: The model. :param optimizer: The optimizer to use. :param criterion: The loss criterion to use. :param mem_size: replay buffer size. :param train_mb_size: The train minibatch size. Defaults to 1. :param train_epochs: The number of training epochs. Defaults to 1. :param eval_mb_size: The eval minibatch size. Defaults to 1. :param device: The device to use. Defaults to None (cpu). :param plugins: Plugins to be added. Defaults to None. :param evaluator: (optional) instance of EvaluationPlugin for logging and metric computations. :param eval_every: the frequency of the calls to `eval` inside the training loop. if -1: no evaluation during training. if 0: calls `eval` after the final epoch of each training experience. if >0: calls `eval` every `eval_every` epochs and at the end of all the epochs for a single experience. """ rp = ReplayPlugin(mem_size) if plugins is None: plugins = [rp] else: plugins.append(rp) super().__init__(model, optimizer, criterion, train_mb_size=train_mb_size, train_epochs=train_epochs, eval_mb_size=eval_mb_size, device=device, plugins=plugins, evaluator=evaluator, eval_every=eval_every)
def test_dataload_reinit(self): scenario = get_fast_scenario() model = SimpleMLP(input_size=6, hidden_size=10) replayPlugin = ReplayPlugin(mem_size=5) cl_strategy = Naive( model, SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001), CrossEntropyLoss(), train_mb_size=16, train_epochs=1, eval_mb_size=16, plugins=[replayPlugin] ) for step in scenario.train_stream[:2]: cl_strategy.train(step)
def main(cuda: int): # --- CONFIG device = torch.device( f"cuda:{cuda}" if torch.cuda.is_available() else "cpu" ) # --- SCENARIO CREATION scenario = SplitCIFAR10(n_experiences=2, seed=42) # --------- # MODEL CREATION model = SimpleMLP(num_classes=scenario.n_classes, input_size=196608 // 64) # choose some metrics and evaluation method eval_plugin = EvaluationPlugin( accuracy_metrics(stream=True, experience=True), images_samples_metrics( on_train=True, on_eval=True, n_cols=10, n_rows=10, ), labels_repartition_metrics( # image_creator=repartition_bar_chart_image_creator, on_train=True, on_eval=True, ), loggers=[ TensorboardLogger(f"tb_data/{datetime.now()}"), InteractiveLogger(), ], ) # CREATE THE STRATEGY INSTANCE (NAIVE) cl_strategy = Naive( model, Adam(model.parameters()), train_mb_size=128, train_epochs=1, eval_mb_size=128, device=device, plugins=[ReplayPlugin(mem_size=1_000)], evaluator=eval_plugin, ) # TRAINING LOOP for i, experience in enumerate(scenario.train_stream, 1): cl_strategy.train(experience) cl_strategy.eval(scenario.test_stream[:i])
def test_dataload_batch_balancing(self): benchmark = get_fast_benchmark() batch_size = 32 replayPlugin = ReplayPlugin(mem_size=20) model = SimpleMLP(input_size=6, hidden_size=10) cl_strategy = Naive( model, SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001), CrossEntropyLoss(), train_mb_size=batch_size, train_epochs=1, eval_mb_size=100, plugins=[replayPlugin], ) for step in benchmark.train_stream: adapted_dataset = step.dataset if len(replayPlugin.storage_policy.buffer) > 0: dataloader = ReplayDataLoader( adapted_dataset, replayPlugin.storage_policy.buffer, oversample_small_tasks=True, num_workers=0, batch_size=batch_size, shuffle=True, ) else: dataloader = TaskBalancedDataLoader(adapted_dataset) for mini_batch in dataloader: mb_task_labels = mini_batch[-1] lengths = [] for task_id in adapted_dataset.task_set: len_task = (mb_task_labels == task_id).sum() lengths.append(len_task) if sum(lengths) == batch_size: difference = max(lengths) - min(lengths) self.assertLessEqual(difference, 1) self.assertLessEqual(sum(lengths), batch_size) cl_strategy.train(step)
def _test_replay_balanced_memory(self, storage_policy, mem_size): scenario = self.create_scenario(task_labels=True) model = SimpleMLP(input_size=6, hidden_size=10) replayPlugin = ReplayPlugin(mem_size=mem_size, storage_policy=storage_policy) cl_strategy = Naive( model, SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001), CrossEntropyLoss(), train_mb_size=32, train_epochs=1, eval_mb_size=100, plugins=[replayPlugin] ) n_seen_data = 0 for step in scenario.train_stream: n_seen_data += len(step.dataset) mem_fill = min(mem_size, n_seen_data) cl_strategy.train(step) ext_mem = replayPlugin.ext_mem lengths = [] for task_id in ext_mem.keys(): lengths.append(len(ext_mem[task_id])) self.assertEqual(sum(lengths), mem_fill) # Always fully filled
def main(args): # --- CONFIG device = torch.device( f"cuda:{args.cuda}" if torch.cuda.is_available() and args.cuda >= 0 else "cpu" ) # --- SCENARIO CREATION scenario = SplitCIFAR100(n_experiences=20, return_task_id=True) config = {"scenario": "SplitCIFAR100"} # MODEL CREATION model = MTSimpleCNN() # choose some metrics and evaluation method loggers = [InteractiveLogger()] if args.wandb_project != "": wandb_logger = WandBLogger( project_name=args.wandb_project, run_name="LaMAML_" + config["scenario"], config=config, ) loggers.append(wandb_logger) 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=loggers, ) # LAMAML STRATEGY rs_buffer = ReservoirSamplingBuffer(max_size=200) replay_plugin = ReplayPlugin( mem_size=200, batch_size=10, batch_size_mem=10, task_balanced_dataloader=False, storage_policy=rs_buffer, ) cl_strategy = LaMAML( model, torch.optim.SGD(model.parameters(), lr=0.1), CrossEntropyLoss(), n_inner_updates=5, second_order=True, grad_clip_norm=1.0, learn_lr=True, lr_alpha=0.25, sync_update=False, train_mb_size=10, train_epochs=10, eval_mb_size=100, device=device, plugins=[replay_plugin], evaluator=eval_plugin, ) # TRAINING LOOP print("Starting experiment...") results = [] for experience in scenario.train_stream: print("Start of experience ", experience.current_experience) cl_strategy.train(experience) print("Training completed") print("Computing accuracy on the whole test set") results.append(cl_strategy.eval(scenario.test_stream)) if args.wandb_project != "": wandb.finish()