def test__init__custom_loss_function_type(self):
classifier = gem.Classifier(
model,
train_dataset.classes('BodyPartExamined'),
loss_function=gem.nn.MultiLabelMarginLoss())
self.assertIsInstance(classifier.loss_function,
gem.nn.MultiLabelMarginLoss)
def test__init__custom_layer_config_type(self):
classifier = gem.Classifier(
model,
train_dataset.classes('BodyPartExamined'),
layer_config=gem.functr.DefaultLastLayerConfig())
self.assertIsInstance(classifier.layer_config,
gem.functr.DefaultLastLayerConfig)
def test_train_correct_usage(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
classifier.train(train_dataset,
epochs=1,
pin_memory=True,
test_dataset=eval_dataset)
def _train(model, field_list, value_list, file):
net = gem.Classifier(model, train_set_classes, enable_cuda=True)
# set correct net params
value_types = []
if len(field_list):
for index, field in enumerate(field_list):
# check if the field exists if not just throw and terminate, a small anti oopsie feature
getattr(net, field)
setattr(net, field, value_list[index])
value_types += [str(value_list[index])]
# log train parameters to an excel file
if len(value_types):
log_train_options(value_types, file)
else:
log_train_options(["default"], file)
# train and log the results
net.train(train_set,
epochs=80,
test_dataset=eval_set,
verbosity=2,
num_workers=4,
batch_size=4,
output_policy=gem.ToConsoleAndExcelFile(file))
def demo_initialize_classifier():
# Use resnet 18 as the base model for our new classifier
resnet18 = models.resnet18(pretrained=True)
dataset = gem.DicomoDataset.get_dicomo_dataset(train_dataset, labels=['BodyPartExamined'])
dataset.summarize('BodyPartExamined')
net = gem.Classifier(resnet18, dataset.classes('BodyPartExamined'), enable_cuda=True)
net.save(classifier_path)
def test__init__custom_optimizer_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'),
optimizer=gem.torch.optim.SGD(
model.parameters(),
lr=0.001,
momentum=0.9))
self.assertIsInstance(classifier.optimizer, gem.torch.optim.SGD)
def test__init__wrong_enable_cuda_type(self):
try:
with self.assertRaises(TypeError):
gem.Classifier(model,
train_dataset.classes('BodyPartExamined'),
enable_cuda=list())
except RuntimeError:
None
def test_train_negative_num_workers(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.train(train_dataset,
epochs=1,
pin_memory=True,
num_workers=-1)
def test_train_wrong_batch_size_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.train(train_dataset,
batch_size="z",
epochs=1,
pin_memory=True)
def test_train_wrong_output_policy_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.train(train_dataset,
epochs=1,
pin_memory=True,
output_policy=[])
def test__init__correct_device_type(self):
try:
classifier = gem.Classifier(
model,
train_dataset.classes('BodyPartExamined'),
enable_cuda=True)
self.assertEqual(str(classifier.device), "cuda")
except RuntimeError:
None
def test_init_correct_usage(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
self.assertIsInstance(classifier, gem.Classifier)
self.assertIsInstance(classifier.module, gem.nn.Module)
self.assertIsInstance(classifier.classes, list)
self.assertIsInstance(classifier.layer_config,
gem.functr.GEMICAIABCFunctor)
self.assertIsInstance(classifier.loss_function, gem.nn.Module)
self.assertIsInstance(classifier.optimizer, gem.torch.optim.Optimizer)
def bench_initialize_tree():
# Select the fields the tree should sequencially. The first item in the list will what the root of the tree
# classifies. Initializing the Tree takes quite long, as it has to calculate the classes for every node.
relevant_labels = ['BodyPartExamined', 'StudyDescription']
resnet18 = models.resnet18(pretrained=True)
ds = gem.DicomoDataset.get_dicomo_dataset('/mnt/SharedStor/dataset/DX', labels=relevant_labels)
net = gem.Classifier(resnet18, [], enable_cuda=True)
start = datetime.now()
tree = gem.ClassifierTree(default_classifier=net, labels=relevant_labels, base_dataset=ds, path=tree_path)
print('Initializing tree took : {}'.format(gem.utils.strfdelta(datetime.now() - start, '%H:%M:%S')))
print(tree)
def test_set_trainable_layers_correct_usage(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
def test_mode(classifier, layer_mode):
classifier.set_trainable_layers([("fc", layer_mode)])
for name, param in classifier.module.named_parameters():
name = '.'.join(name.split('.')[:-1])
if name == "fc":
self.assertEqual(param.requires_grad, layer_mode)
test_mode(classifier, True)
test_mode(classifier, False)
def test_save_correct_path(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
os.mkdir(test_classifier_dir)
try:
classifier_path = os.path.join(test_classifier_dir, "1.gemclas")
classifier.save(classifier_path)
self.assertEqual(os.path.isfile(classifier_path), True)
finally:
try:
os.remove(classifier_path)
except FileNotFoundError:
None
os.rmdir(test_classifier_dir)
def test_from_file_correct_usage(self):
os.mkdir(test_classifier_dir)
try:
self.maxDiff = None
test_file_path = os.path.join(test_classifier_dir, "1.gemclas")
classifier = gem.Classifier(
model, train_dataset.classes('BodyPartExamined'))
classifier.save(test_file_path)
classifier = gem.Classifier.from_file(test_file_path)
self.assertIsInstance(classifier, gem.Classifier)
finally:
try:
os.remove(test_file_path)
except FileNotFoundError:
None
os.rmdir(test_classifier_dir)
def bench_classify():
relevant_labels = [
'Modality', 'BodyPartExamined', 'StudyDescription', 'SeriesDescription'
]
resnet18 = models.resnet18(pretrained=True)
ds = gem.DicomoDataset.get_dicomo_dataset('examples',
labels=relevant_labels)
net = gem.Classifier(resnet18,
ds.classes('BodyPartExamined'),
enable_cuda=False)
ds_iter = iter(ds)
tensors = torch.cat(
(torch.unsqueeze(next(ds_iter)[0],
0), torch.unsqueeze(next(ds_iter)[0], 0)))
cls = net.classify(tensors)
def test_train_negative_verbosity_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.train(train_dataset, epochs=1, verbosity=-1)
def test_evaluate_correct_usage(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
classifier.evaluate(eval_dataset)
def test_evaluate_wrong_output_policy_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.evaluate(train_dataset, output_policy=[])
def test__init__wrong_optimizer_type(self):
with self.assertRaises(TypeError):
gem.Classifier(model,
train_dataset.classes('BodyPartExamined'),
optimizer=[])
def test_evaluate_wrong_num_workers_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.evaluate(eval_dataset, num_workers="z")
def test__init__wrong_loss_function_type(self):
with self.assertRaises(TypeError):
gem.Classifier(model,
train_dataset.classes('BodyPartExamined'),
loss_function=[])
def test_evaluate_pin_memory_wrong_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.evaluate(eval_dataset, pin_memory="z")
def test_evaluate_def_negative_num_workers(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.evaluate(eval_dataset, num_workers=-10)
def test__init__wrong_layer_config_type(self):
with self.assertRaises(TypeError):
gem.Classifier(model,
train_dataset.classes('BodyPartExamined'),
layer_config=[])
def test_set_trainable_layers_layers_wrong_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.set_trainable_layers({})
def test_save_wrong_path_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
classifier_path = 1
with self.assertRaises(TypeError):
classifier.save(classifier_path)
def test_save_invalid_path(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
classifier_path = os.path.join(test_classifier_dir, "1.gemclas")
with self.assertRaises(FileNotFoundError):
classifier.save(classifier_path)
def test_evaluate_negative_verbosity_type(self):
classifier = gem.Classifier(model,
train_dataset.classes('BodyPartExamined'))
with self.assertRaises(TypeError):
classifier.evaluate(eval_dataset, verbosity=-1)
