# create datasets
trainset = torchvision.datasets.CIFAR10(root='./data',
train=True,
download=True,
transform=transform_train,
target_transform=target_transform)
trainset_wo_aug = torchvision.datasets.CIFAR10(
root='./data',
train=True,
download=False,
transform=transform_test,
target_transform=target_transform)
bc = bilevel_coreset.BilevelCoreset(loss_fn,
loss_fn,
max_inner_it=7500,
max_conj_grad_it=100)
model = models.LogisticRegression(nystrom_features_dim, num_classes)
# choose base inds
based_inds = np.random.choice(len(trainset.targets),
base_inds_size,
replace=False)
inds = bc.build_with_nystrom_proxy(
trainset,
trainset_wo_aug,
based_inds,
coreset_size,
kernel_fn_ntk,
loader_creator_fn,
def continual_learning(args):
nr_epochs = args.nr_epochs
beta = args.beta
dataset = args.dataset
device = args.device
method = args.method
samples_per_task = args.samples_per_task
buffer_size = args.buffer_size
num_workers = args.num_workers
pin_memory = device == 'cuda'
if dataset == 'permmnist':
generator = datagen.PermutedMnistGenerator(samples_per_task)
elif dataset == 'splitmnist':
generator = datagen.SplitMnistGenerator(samples_per_task)
tasks = []
train_loaders = []
test_loaders = []
for i in range(generator.max_iter):
X_train, y_train, X_test, y_test = generator.next_task()
tasks.append((X_train, y_train, X_test, y_test))
train_data = datagen.NumpyDataset(X_train, y_train)
train_loaders.append(
DataLoader(train_data,
batch_size=args.batch_size,
shuffle=True,
num_workers=num_workers,
pin_memory=pin_memory))
test_data = datagen.NumpyDataset(X_test, y_test)
test_loaders.append(
DataLoader(test_data,
batch_size=args.batch_size,
num_workers=num_workers,
pin_memory=pin_memory))
nr_classes = 10
inner_reg = 1e-3
if dataset == 'permmnist':
model = models.FNNet(28 * 28, 100, nr_classes).to(device)
else:
model = models.ConvNet(nr_classes).to(device)
training_op = training.Training(model, device, nr_epochs, beta=beta)
kernel_fn = get_kernel_fn(dataset)
bc = bilevel_coreset.BilevelCoreset(outer_loss_fn=loss_utils.cross_entropy,
inner_loss_fn=loss_utils.cross_entropy,
out_dim=10,
max_outer_it=1,
max_inner_it=200,
logging_period=1000)
rs = np.random.RandomState(args.seed)
for i in range(generator.max_iter):
training_op.train(train_loaders[i])
size_per_task = buffer_size // (i + 1)
for j in range(i):
(X, y), w = training_op.buffer[j]
X, y = X[:size_per_task], y[:size_per_task]
training_op.buffer[j] = ((X, y), np.ones(len(y)))
X, y, _, _ = tasks[i]
if method == 'coreset':
chosen_inds, _, = bc.build_with_representer_proxy_batch(
X,
y,
size_per_task,
kernel_fn,
cache_kernel=True,
start_size=1,
inner_reg=inner_reg)
else:
summarizer = summary.Summarizer.factory(method, rs)
chosen_inds = summarizer.build_summary(X,
y,
size_per_task,
method=method,
model=model,
device=device)
X, y = X[chosen_inds], y[chosen_inds]
assert (X.shape[0] == size_per_task)
training_op.buffer.append(((X, y), np.ones(len(y))))
result = []
for k in range(generator.max_iter):
result.append(training_op.test(test_loaders[k]))
filename = '{}_{}_{}_{}_{}.txt'.format(dataset, method, buffer_size, beta,
seed)
if not os.path.exists('cl_results'):
os.makedirs('cl_results')
with open('cl_results/' + filename, 'w') as outfile:
json.dump({
'test_acc': np.mean(result),
'acc_per_task': result
}, outfile)
torch.manual_seed(seed)
random.seed(seed)
X, y = get_data()
lim = 10000
rs = np.random.RandomState(seed)
if method == 'uniform':
summarizer = summary.UniformSummarizer(rs)
inds = summarizer.build_summary(X, y, coreset_size)
weights = np.ones(coreset_size)
elif method == 'coreset':
kernel_fn = lambda x, y: ntk_generator.generate_cnn_ntk(
x.reshape(-1, 28, 28, 1), y.reshape(-1, 28, 28, 1))
bc = bilevel_coreset.BilevelCoreset(
outer_loss_fn=loss_utils.cross_entropy,
inner_loss_fn=loss_utils.cross_entropy,
out_dim=10,
max_outer_it=10,
outer_lr=0.05,
max_inner_it=200,
logging_period=1000)
inds, weights = bc.build_with_representer_proxy_batch(
X[:lim],
y[:lim],
coreset_size,
kernel_fn,
cache_kernel=True,
start_size=10,
inner_reg=1e-7)
train_loader, test_loader = get_mnist_loaders(inds)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
model = models.ConvNet(10).to(device)
def cl_streaming(args):
seed = args.seed
nr_epochs = args.nr_epochs
beta = args.beta
device = args.device
method = args.method
buffer_size = args.buffer_size
stream_batch_size = args.stream_batch_size
dataset = args.dataset
if dataset == 'stream_imbalanced_splitcifar':
nr_slots = 1
else:
nr_slots = 10
generator = SplitCifar(imbalanced=dataset == 'stream_imbalanced_splitcifar')
train_loaders = []
test_loaders = []
train_inds_list = []
for i in range(generator.max_iter):
train_inds, test_inds = generator.next_task()
train_inds_list.append(train_inds)
train_loaders.append(get_custom_loader(generator.train_dataset, train_inds))
test_loaders.append(get_custom_loader(generator.test_dataset, test_inds))
model = models.ResNet18().to(device)
training_op = Training(model, device, nr_epochs, beta=beta)
kernel_fn = get_kernel_fn()
bc = bilevel_coreset.BilevelCoreset(outer_loss_fn=loss_utils.cross_entropy,
inner_loss_fn=loss_utils.cross_entropy, out_dim=10, max_outer_it=1,
candidate_batch_size=600, max_inner_it=300, logging_period=1000)
def coreset_builder_fn(X, y, m, data_weights):
return bc.build_with_representer_proxy_batch(X, y, m, kernel_fn, data_weights=data_weights,
cache_kernel=True, start_size=1, inner_reg=inner_reg)
inner_reg = 1e-3
if dataset == 'stream_imbalanced_splitcifar':
if method == 'reservoir':
training_op = reservoir_buffer(generator, stream_batch_size, buffer_size, training_op)
elif method == 'cbrs':
training_op = cbrs(generator, stream_batch_size, buffer_size, training_op)
elif method == 'coreset':
training_op = streaming_coreset(generator, stream_batch_size, buffer_size, training_op, coreset_builder_fn,
nr_slots)
else:
raise ValueError("Invalid dataset - method combination")
else:
if method not in cl_methods:
raise ValueError("Invalid dataset - method combination")
training_op = train_with_buffer(generator, buffer_size, training_op, train_loaders, train_inds_list, model,
method, device,
coreset_builder_fn)
result = get_test_accuracy(generator, test_loaders, training_op)
filename = '{}_{}_{}_{}_{}.txt'.format(dataset, method, buffer_size, beta, seed)
results_path = 'cl_results'
if dataset == 'stream_imbalanced_splitcifar':
results_path = 'streaming_results'
if not os.path.exists(results_path):
os.makedirs(results_path)
with open(os.path.join(results_path, filename), 'w') as outfile:
json.dump({'test_acc': np.mean(result), 'acc_per_task': result}, outfile)
def streaming(args):
nr_epochs = args.nr_epochs
beta = args.beta
dataset = args.dataset
device = args.device
method = args.method
samples_per_task = args.samples_per_task
buffer_size = args.buffer_size
stream_batch_size = args.stream_batch_size
nr_slots = args.nr_slots
batch_size = args.batch_size
num_workers = args.num_workers
pin_memory = device == 'cuda'
inner_reg = 1e-3
if dataset == 'permmnist':
generator = datagen.PermutedMnistGenerator(samples_per_task)
elif dataset == 'splitmnist':
generator = datagen.SplitMnistGenerator(samples_per_task)
elif dataset == 'splitmnistimbalanced':
inner_reg = 1e-4
generator = datagen.SplitMnistImbalancedGenerator()
tasks = []
train_loaders = []
test_loaders = []
for i in range(generator.max_iter):
X_train, y_train, X_test, y_test = generator.next_task()
tasks.append((X_train, y_train, X_test, y_test))
train_data = datagen.NumpyDataset(X_train, y_train)
train_loaders.append(
DataLoader(train_data,
batch_size=args.batch_size,
shuffle=True,
num_workers=num_workers,
pin_memory=pin_memory))
test_data = datagen.NumpyDataset(X_test, y_test)
test_loaders.append(
DataLoader(test_data,
batch_size=args.batch_size,
shuffle=True,
num_workers=num_workers,
pin_memory=pin_memory))
nr_classes = 10
if dataset == 'permmnist':
model = models.FNNet(28 * 28, 100, nr_classes).to(device)
else:
model = models.ConvNet(nr_classes).to(device)
training_op = training.Training(model, device, nr_epochs, beta=beta)
kernel_fn = get_kernel_fn(dataset)
bc = bilevel_coreset.BilevelCoreset(outer_loss_fn=loss_utils.cross_entropy,
inner_loss_fn=loss_utils.cross_entropy,
out_dim=10,
max_outer_it=1,
max_inner_it=200,
logging_period=1000)
def coreset_builder_fn(X, y, m, data_weights):
return bc.build_with_representer_proxy_batch(X,
y,
m,
kernel_fn,
data_weights=data_weights,
cache_kernel=True,
start_size=1,
inner_reg=inner_reg)
data_loader_fn = lambda data: DataLoader(data,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers,
pin_memory=pin_memory)
if method == 'reservoir':
training_op = reservoir_buffer(generator, stream_batch_size,
buffer_size, training_op,
data_loader_fn)
elif method == 'cbrs':
training_op = cbrs(generator, stream_batch_size, buffer_size,
training_op, data_loader_fn)
elif method == 'coreset':
training_op = streaming_coreset(generator, stream_batch_size,
buffer_size, training_op,
coreset_builder_fn, data_loader_fn,
nr_slots)
result = get_test_accuracy(generator, test_loaders, training_op)
filename = '{}_{}_{}_{}_{}.txt'.format(dataset, method, buffer_size, beta,
seed)
if not os.path.exists('streaming_results'):
os.makedirs('streaming_results')
with open('streaming_results/' + filename, 'w') as outfile:
json.dump({
'test_acc': np.mean(result),
'acc_per_task': result
}, outfile)