def before_training_exp(self,
strategy,
num_workers=0,
shuffle=True,
**kwargs):
"""
Dataloader to build batches containing examples from both memories and
the training dataset
"""
if self.ext_mem_list_current_index == 0:
return
temp_x_tensors = []
for elem in self.ext_mem_list_x:
temp_x_tensors.append(torch.FloatTensor(elem))
memory = list(zip(temp_x_tensors, self.ext_mem_list_y))
memory = AvalancheDataset(memory, targets=self.ext_mem_list_y)
strategy.dataloader = ReplayDataLoader(
strategy.adapted_dataset,
memory,
oversample_small_tasks=True,
num_workers=num_workers,
batch_size=strategy.train_mb_size,
shuffle=shuffle)
def before_training_exp(self,
strategy: "SupervisedTemplate",
num_workers: int = 0,
shuffle: bool = True,
**kwargs):
"""
Dataloader to build batches containing examples from both memories and
the training dataset
"""
if len(self.storage_policy.buffer) == 0:
# first experience. We don't use the buffer, no need to change
# the dataloader.
return
batch_size = self.batch_size
if batch_size is None:
batch_size = strategy.train_mb_size
batch_size_mem = self.batch_size_mem
if batch_size_mem is None:
batch_size_mem = strategy.train_mb_size
strategy.dataloader = ReplayDataLoader(
strategy.adapted_dataset,
self.storage_policy.buffer,
oversample_small_tasks=True,
batch_size=batch_size,
batch_size_mem=batch_size_mem,
task_balanced_dataloader=self.task_balanced_dataloader,
num_workers=num_workers,
shuffle=shuffle)
def test_basic(self):
benchmark = get_fast_benchmark()
ds = [el.dataset for el in benchmark.train_stream]
data = AvalancheConcatDataset(ds)
dl = TaskBalancedDataLoader(data)
for el in dl:
pass
dl = GroupBalancedDataLoader(ds)
for el in dl:
pass
dl = ReplayDataLoader(data, data)
for el in dl:
pass
def before_training_exp(self, strategy, num_workers=0, shuffle=True,
**kwargs):
"""
Dataloader to build batches containing examples from both memories and
the training dataset
"""
if len(self.ext_mem) == 0:
return
strategy.dataloader = ReplayDataLoader(
strategy.adapted_dataset,
AvalancheConcatDataset(self.ext_mem.values()),
oversample_small_tasks=True,
num_workers=num_workers,
batch_size=strategy.train_mb_size,
shuffle=shuffle)
def test_basic(self):
scenario = get_fast_scenario()
ds = [el.dataset for el in scenario.train_stream]
data = AvalancheConcatDataset(ds)
dl = TaskBalancedDataLoader(data)
for el in dl:
pass
dl = GroupBalancedDataLoader(ds)
for el in dl:
pass
dl = ReplayDataLoader(data, data)
for el in dl:
pass
def before_training_exp(self,
strategy,
num_workers=0,
shuffle=True,
**kwargs):
"""
Random retrieval from a class-balanced memory.
Dataloader builds batches containing examples from both memories and
the training dataset.
"""
if len(self.replay_mem) == 0:
return
strategy.dataloader = ReplayDataLoader(
strategy.adapted_dataset,
AvalancheConcatDataset(self.replay_mem.values()),
oversample_small_tasks=True,
num_workers=num_workers,
batch_size=strategy.train_mb_size * 2,
shuffle=shuffle)
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 before_training_exp(self,
strategy: "BaseStrategy",
num_workers: int = 0,
shuffle: bool = True,
**kwargs):
"""
Dataloader to build batches containing examples from both memories and
the training dataset
"""
if len(self.storage_policy.buffer) == 0:
# first experience. We don't use the buffer, no need to change
# the dataloader.
return
strategy.dataloader = ReplayDataLoader(
strategy.adapted_dataset,
self.storage_policy.buffer,
oversample_small_tasks=True,
num_workers=num_workers,
batch_size=strategy.train_mb_size,
force_data_batch_size=self.force_data_batch_size,
shuffle=shuffle,
)
def before_training_exp(self,
strategy,
num_workers=0,
shuffle=True,
**kwargs):
"""
Random retrieval from a class-balanced memory.
Dataloader builds batches containing examples from both memories and
the training dataset.
This implementation requires the use of early stopping, otherwise the
entire memory will be iterated.
"""
if len(self.replay_mem) == 0:
return
self.it_cnt = 0
strategy.dataloader = ReplayDataLoader(
strategy.adapted_dataset,
AvalancheConcatDataset(self.replay_mem.values()),
oversample_small_tasks=False,
num_workers=num_workers,
batch_size=strategy.train_mb_size * 2,
force_data_batch_size=strategy.train_mb_size,
shuffle=shuffle)
