# 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)