classification_criterion.cuda()
gen_model = autoencoder_MNIST_512_features(32)
gen_dict = torch.load('./pretrained_models/AE_5_classes_32_code_size.pth')
gen_model.load_state_dict(gen_dict)
gen_model.cuda()
generative_optimizer = torch.optim.Adam(gen_model.parameters(), lr=opts['learning_rate'], betas=(0.9, 0.999), weight_decay=1e-5)
generative_criterion_cl = nn.MSELoss()
generative_criterion_cl.cuda()
generative_criterion_rec = nn.MSELoss()
generative_criterion_rec.cuda()
# ---------------------------------- FILLING THE BUFFERS WITH THE HISTORICAL DATA ----------------------------------------------
prev_classes = [0, 1, 2, 3, 4]
historical_buffer = Data_Buffer(60, 100)
real_buffer = Data_Buffer(1, 100)
for idx_class in prev_classes:
indices_prev = get_indices_for_classes(trainset, [idx_class])
prev_loader = DataLoader(trainset, batch_size=opts['batch_size'], sampler = SubsetRandomSampler(indices_prev), drop_last=True)
for batch, label in prev_loader:
historical_buffer.add_batch(gen_model.encoder(batch.cuda()).data, idx_class)
real_buffer.add_batch(batch.cuda(), idx_class)
max_accuracy = 0
fake_batches = 10
real_batches = 1
known_classes = [int(a) for a in historical_buffer.dbuffer.keys()]
indices_test = get_indices_for_classes(testset, known_classes)
test_loader = DataLoader(testset, batch_size=1000, sampler = SubsetRandomSampler(indices_test))
acc_real = test_classifier(classifier, test_loader)
'./pretrained_models/AE_5_classes_32_code_size_MNIST.pth')
gen_model.load_state_dict(gen_dict)
gen_model.cuda()
generative_optimizer = torch.optim.Adam(gen_model.parameters(),
lr=opts['learning_rate'],
betas=(0.9, 0.999),
weight_decay=1e-5)
generative_criterion_cl = nn.MSELoss()
generative_criterion_cl.cuda()
generative_criterion_rec = nn.MSELoss()
generative_criterion_rec.cuda()
# ---------------------------------- FILLING THE BUFFERS WITH THE HISTORICAL DATA ----------------------------------------------
codes_storage = Data_Buffer(codes_storage_size, opts['batch_size'])
codes_storage.cuda_device = cuda_device
real_buffer = Data_Buffer(real_buffer_size, opts['batch_size'])
real_buffer.cuda_device = cuda_device
"""
Filling in historical buffers
"""
pretrained_on_classes = list(range(5))
real_buffer.load_from_tensor_dataset(full_original_trainset,
pretrained_on_classes)
codes_storage.load_from_tensor_dataset(full_original_trainset,
pretrained_on_classes,
gen_model.encoder)
print('Historical data successfully loaded from the datasets')
Classifier = models.Classifier_LSUN
test_classifier = sup_functions.test_classifier
test_classifier_on_generator = sup_functions.test_classifier_on_generator
get_indices_for_classes = sup_functions.get_indices_for_classes
trainset = torch.load('../datasets/LSUN/trainset.pth')
testset = torch.load('../datasets/LSUN/testset.pth')
original_trainset = TensorDataset(trainset[0], trainset[1], torch.zeros(trainset[1].shape))
trainset = TensorDataset(trainset[0], trainset[1], torch.zeros(trainset[1].shape))
testset = TensorDataset(testset[0], testset[1])
# Loading the datasets
print('Reshaping data into readable format')
hist_buffer = Data_Buffer(real_batches_to_add or 1, opts['batch_size'])
hist_buffer.load_from_tensor_dataset(trainset, list(range(30)))
hist_buffer.make_tensor_dataset()
hist_data = hist_buffer.tensor_dataset
data_buffer = Data_Buffer(batches_per_class, opts['batch_size'])
data_buffer.load_from_tensor_dataset(trainset, list(range(30)))
data_buffer.cuda_device = cuda_device
print('Ended reshaping')
# Initializing data loaders for first 5 classes
#train_loader = DataLoader(original_trainset, batch_size=opts['batch_size'], shuffle=True)
test_loader = DataLoader(testset, batch_size=opts['batch_size'], shuffle=False)
# Initializing classification model
indices = torch.FloatTensor(
list((data.tensors[1].long() == class_).tolist()
for class_ in data_classes)).sum(0).nonzero().long().squeeze()
return indices
trainset = torch.load('../datasets/LSUN/testset.pth')
testset = torch.load('../datasets/LSUN/testset.pth')
original_trainset = TensorDataset(trainset[0], trainset[1],
torch.zeros(trainset[1].shape))
testset = TensorDataset(testset[0], testset[1])
# Loading the datasets
print('Reshaping data into readable format')
data_buffer = Data_Buffer(batches_per_class, opts['batch_size'])
data_buffer.add_batches_from_dataset(original_trainset, list(range(30)),
batches_per_class)
data_buffer.cuda_device = cuda_device
orig_buffer = Data_Buffer(real_batches_to_add, opts['batch_size'])
orig_buffer.add_batches_from_dataset(original_trainset, list(range(30)),
real_batches_to_add)
orig_buffer.cuda_device = cuda_device
original_trainset = orig_buffer.make_tensor_dataset()
print('Ended reshaping')
# Initializing data loaders for first 5 classes
#train_loader = DataLoader(original_trainset, batch_size=opts['batch_size'], shuffle=True)
test_loader = DataLoader(testset, batch_size=opts['batch_size'], shuffle=False)
# ----------------------------------------- LOADING PRETRAINED MODELS ----------------------------------------------------------
# Initializing classification model
classifier = models.Classifier_MNIST(nb_of_classes)
class_dict = torch.load('./pretrained_models/classifier_5_MNIST.pth')
classifier.load_state_dict(class_dict)
classification_optimizer = optim.Adam(classifier.parameters(),
lr=opts['learning_rate'],
betas=(0.9, 0.999),
weight_decay=1e-5)
classification_criterion = nn.CrossEntropyLoss()
classifier.cuda()
classification_criterion.cuda()
# ---------------------------------- FILLING THE BUFFERS WITH THE HISTORICAL DATA ----------------------------------------------
real_buffer = Data_Buffer(real_buffer_size, opts['batch_size'])
real_buffer.cuda_device = cuda_device
"""
Filling in historical buffers
"""
pretrained_on_classes = list(range(5))
real_buffer.load_from_tensor_dataset(full_original_trainset,
pretrained_on_classes)
print('Historical data successfully loaded from the datasets')
max_accuracy = 0
print('Testing already acquired knowledge prior to stream training')
known_classes = pretrained_on_classes
indices_test = sup_functions.get_indices_for_classes(full_original_testset,
indices = torch.FloatTensor(
list((data.tensors[1].long() == class_).tolist()
for class_ in data_classes)).sum(0).nonzero().long().squeeze()
return indices[torch.randperm(len(indices))]
# Loading the datasets
full_data = torch.load(
'./data/Synthetic/data_train_test_500_classes_128_features_2000_samples.pth'
)
trainset = TensorDataset(full_data['data_train'], full_data['labels_train'])
testset = TensorDataset(full_data['data_test'], full_data['labels_test'])
print('Reshaping data into readable format')
prev_classes = list(range(500))
data_buffer = Data_Buffer(4, opts['batch_size'])
for idx_class in prev_classes:
indices_prev = get_indices_for_classes(trainset, [idx_class])
prev_loader = DataLoader(trainset,
batch_size=opts['batch_size'],
sampler=SubsetRandomSampler(indices_prev),
drop_last=True)
for batch, label in prev_loader:
data_buffer.add_batch(batch.cuda(), idx_class)
print('Ended reshaping')
# Initializing data loaders for first 5 classes
train_loader = DataLoader(trainset,
batch_size=opts['batch_size'],
shuffle=True)