def test_full_run_from_yaml(self):
filename = self._test_file('basic_classifier.yaml')
model = BasicClassifier.new_from_yaml_filename(filename)
training_feed = SingleClassImageFeed.from_torchvision()
validation_feed = SingleClassImageFeed.from_torchvision(train=False)
if torch.cuda.is_available():
model.cuda()
training_feed.cuda()
validation_feed.cuda()
model.set_optimizer(optim.SGD,
lr=1e-4,
momentum=0.9,
weight_decay=1e-4)
trainer = SingleClassImageClassifierTrainer(
model=model,
training_feed=training_feed,
validation_feed=validation_feed)
self.assertLess(trainer.get_classification_accuracy(), 0.2)
model.set_schedule('learning_rate',
Cosine(initial_value=1e-1, final_value=3e-2))
trainer.train(num_epochs=3)
trainer.monitor.dataframe_monitor.plot(skip_first=30, smooth_window=5)
self.assertGreater(trainer.get_classification_accuracy(), 0.95)
def test_full_run(self):
model = WideResnetImageClassifier(image_channels=1,
depth=10, widening_factor=1)
training_feed = SingleClassImageFeed.from_torchvision()
validation_feed = SingleClassImageFeed.from_torchvision(train=False)
if torch.cuda.is_available():
model.cuda()
training_feed.cuda()
validation_feed.cuda()
model.set_optimizer(optim.SGD, lr=1e-4, momentum=0.9, weight_decay=1e-4)
trainer = SingleClassImageClassifierTrainer(model=model,
training_feed=training_feed,
validation_feed=validation_feed)
self.assertLess(trainer.get_classification_accuracy(), 0.2)
num_steps = trainer.get_num_steps(num_epochs=2)
model.set_schedule('learning_rate', Triangle(initial_value=5e-3, peak_value=5e-2))
trainer.train(num_epochs=2)
acc = trainer.get_classification_accuracy()
print(f"Accuracy: {acc}")
self.assertGreater(acc, 0.90)
def test_properties(self):
dg = SingleClassImageFeed.from_torchvision(
batch_size=3,
fraction=15 / 10_000,
train=False)
self.assertEqual(len(dg), 5)
self.assertEqual(dg.num_samples, 15)
def test_full_run(self):
model = BasicAutoencoder(image_height=28,
image_width=28,
hidden_size=200,
latent_size=100)
training_feed = SingleClassImageFeed.from_torchvision(fraction=1 / 6)
validation_feed = SingleClassImageFeed.from_torchvision(train=False,
fraction=0.1)
if torch.cuda.is_available():
model.cuda()
training_feed.cuda()
validation_feed.cuda()
model.set_optimizer(optim.SGD,
lr=1e-4,
momentum=0.9,
weight_decay=1e-6)
trainer = AutoencoderTrainer(model=model,
training_feed=training_feed,
validation_feed=validation_feed)
survey_monitor = trainer.survey_learning_rate(num_epochs=0.1,
min_learning_rate=1e-1,
max_learning_rate=1e3)
survey_monitor.dataframe_monitor.plot_learning_rate_survey()
trainer.plot_input_output_pairs()
trainer.plot_latent_space()
model.set_schedule('learning_rate',
Cosine(initial_value=2, final_value=2 / 50))
trainer.train(num_epochs=1)
trainer.multi_train(num_cycles=4)
trainer.monitor.dataframe_monitor.plot()
val_monitor = trainer.validate()
val_loss = val_monitor.dataframe_monitor.df['validation_loss'].mean()
self.assertLess(val_loss, 0.21)
def test_iterates_forever(self):
dg = SingleClassImageFeed.from_torchvision(
batch_size=1,
fraction=5 / 10_000,
train=False)
count = 0
for batch in dg:
count += 1
if count >= 5 * 2.2:
break
self.assertTrue(True, "Can iterate forever")
def test_from_folder(self):
feed = SingleClassImageFeed.from_image_folder(
root=os.path.join(THIS_DIR, 'data', 'image_folder'))
df = feed.get_class_df()
expected_df = pd.DataFrame([
dict(cats=True, dogs=False, toys=False),
dict(cats=False, dogs=True, toys=False),
dict(cats=False, dogs=False, toys=True),
dict(cats=False, dogs=False, toys=True),
])
self.assertTrue(df.equals(expected_df))
def test_run_with_batch_multiplier(self):
filename = self._test_file('multilayer_perceptron.yaml')
model = MultilayerPerceptron.new_from_yaml_filename(filename)
training_feed = SingleClassImageFeed.from_torchvision(batch_size=100)
validation_feed = SingleClassImageFeed.from_torchvision(batch_size=100,
train=False)
if torch.cuda.is_available():
model.cuda()
training_feed.cuda()
validation_feed.cuda()
model.set_optimizer(optim.SGD,
lr=1e-4,
momentum=0.90,
weight_decay=1e-4)
trainer = SingleClassImageClassifierTrainer(
model=model,
training_feed=training_feed,
validation_feed=validation_feed)
survey_monitor = trainer.survey_learning_rate(min_learning_rate=1e-4,
max_learning_rate=100)
max_lr = survey_monitor.dataframe_monitor.df[('__default__',
'learning_rate')].max()
print(f"Max learning rate tried: {max_lr}")
self.assertLess(max_lr, 50)
self.assertLess(trainer.get_classification_accuracy(), 0.2)
model.set_schedule('learning_rate',
Triangle(initial_value=5e-2, peak_value=5e-1))
trainer.train(num_epochs=3, batch_multiplier=5)
acc = trainer.get_classification_accuracy()
print(f"Accuracy: {acc}")
self.assertGreater(acc, 0.80)
def test_cuda(self):
dg = SingleClassImageFeed.from_torchvision(
batch_size=1,
fraction=5 / 10_000,
train=False)
inputs, targets = dg.next()
self.assertFalse(inputs.is_cuda)
self.assertFalse(targets.is_cuda)
dg.cuda()
inputs, targets = dg.next()
self.assertTrue(inputs.is_cuda)
self.assertTrue(targets.is_cuda)
dg.cuda(False)
inputs, targets = dg.next()
self.assertFalse(inputs.is_cuda)
self.assertFalse(targets.is_cuda)
dg.cuda({'targets': None})
inputs, targets = dg.next()
self.assertFalse(inputs.is_cuda)
self.assertTrue(targets.is_cuda)
dg.cuda(False)
inputs, targets = dg.next()
self.assertFalse(inputs.is_cuda)
self.assertFalse(targets.is_cuda)
dg.cuda({'targets': 0})
inputs, targets = dg.next()
self.assertFalse(inputs.is_cuda)
self.assertTrue(targets.is_cuda)
dg.cuda(False)
inputs, targets = dg.next()
self.assertFalse(inputs.is_cuda)
self.assertFalse(targets.is_cuda)
dg.cuda({'targets': False, 'inputs': 0})
inputs, targets = dg.next()
self.assertTrue(inputs.is_cuda)
self.assertFalse(targets.is_cuda)
with self.assertRaises(RuntimeError):
dg.cuda({'foo': None})