def task(self,
trainable_config: dict,
metric: str,
trainable_class: Union[str, tune.Trainable] = DicommlTrainable,
mode: str = 'min',
scheduler_class: Union[str, None] = None,
scheduler_config: Union[dict, None] = None,
scheduler: Union[tune.schedulers.trial_scheduler.TrialScheduler,
None] = None,
**kwargs):
if isinstance(trainable_class, str):
Trainable = dicomml_resolve(trainable_class)
else:
Trainable = trainable_class
if isinstance(scheduler_class, str):
scheduler = dicomml_resolve(scheduler_class)(**scheduler_config)
analysis = tune.run(run_or_experiment=Trainable,
config=trainable_config,
scheduler=scheduler,
checkpoint_at_end=True,
**kwargs)
best_trial = analysis.get_best_trial(metric=metric, mode=mode)
checkpoint = analysis.get_best_checkpoint(trial=best_trial, mode=mode)
self.logger.info('Best trial is checkpointed at {checkpoint} \
and has config {config}'.format(checkpoint=checkpoint,
config=str(best_trial.config)))
return dict(best_checkpoint=checkpoint)
def run_task(name: Union[str, None] = None,
task_class: Union[str, DicommlTask] = DicommlTask,
config: Union[dict, None] = None,
parallel_configs: Union[List[dict], None] = None) -> dict:
if isinstance(task_class, str):
Task = dicomml_resolve(task_class)
else:
Task = task_class
if parallel_configs is not None:
parallel_configs = {
'{name}-{i}'.format(name=name, i=i): {
**config,
**cfg
}
for i, cfg in enumerate(parallel_configs)
}
tasks = [
ray.remote(Task).options(name=name).remote(name=name, config=cfg)
for name, cfg in parallel_configs.items()
]
results = ray.get([task.run.remote() for task in tasks])
else:
results = [Task(config=config).run()]
# combine results
return {key: val for res in results for key, val in res.items()}
def __init__(self,
path: str = '.',
transformations: dict = dict(),
**kwargs):
import glob
self.files = [
_f for _f in glob.glob(path, recursive=True)
if os.path.isfile(_f)]
self.transformations = [
dicomml_resolve(kind)(**cfg)
for kind, cfg in transformations.items()]
self.export_kwargs = kwargs
def setup_training(self,
loss_function: Tuple[str, dict],
eval_metrics: Dict[str, dict],
model_class: str,
optimizer_class: str,
model_config: dict = dict(),
prediction_target: str = 'class',
treshold_value: float = 0.5,
**kwargs):
# setup metrics
_class, _config = loss_function
if 'weight' in _config.keys():
_config['weight'] = torch.Tensor(_config['weight']).to(self.device)
self.loss = dicomml_resolve(_class, prefix='torch')(**_config)
self.eval_metrics = {
key: partial(dicomml_resolve(key, prefix='sklearn.metrics'), **cfg)
for key, cfg in eval_metrics.items()}
# setup model
self.model = dicomml_resolve(model_class)(**{
**model_config,
**{k[6:]: v for k, v in kwargs.items() if 'model_' in k}})
self.model.to(self.device)
# setup optimizer
self.optimizer = dicomml_resolve(optimizer_class, prefix='torch')(
self.model.parameters(),
**{key[10:]: val for key, val in kwargs.items()
if 'optimizer_' in key})
# setup logits transformation layer
if prediction_target == 'class':
self.logits_layer = torch.nn.Softmax(dim=1)
self.predict = lambda prob: np.argmax(prob, axis=1)
elif prediction_target == 'labels':
self.logits_layer = torch.nn.Sigmoid()
self.predict = lambda prob: np.where(prob > treshold_value, 0, 1)
if prediction_target == 'class_probabilities':
self.logits_layer = torch.nn.Softmax(dim=1)
self.predict = lambda prob: prob
elif prediction_target == 'label_probabilities':
self.logits_layer = torch.nn.Sigmoid()
self.predict = lambda prob: prob
def __init__(self,
base_transform: Union[Type[ArrayTransform], str],
base_config: dict = dict(),
value_ranges: Dict[str, tuple] = dict(),
n_applications: int = 1,
**kwargs):
if isinstance(base_transform, str):
Transform = dicomml_resolve(base_transform)
else:
Transform = base_transform
transform_configs = []
for _ in range(n_applications):
random_config = {
key: np.random.uniform(low=val[0], high=val[1])
for key, val in value_ranges.items()}
transform_configs.append({
**base_config,
**random_config})
self.random_instances = [
Transform(**cfg) for cfg in transform_configs]
def task(self,
filenames: Union[List[str], None] = None,
num_concurrent_files: Union[int, None] = None,
folder_in: Union[str, None] = None,
filename_pattern: str = '*.zip',
load_config: dict = dict(),
steps: Dict[str, dict] = dict(),
folder_out: str = './out',
save_config: dict = dict()):
from dicomml.transforms.io import Save, Load
# construct transforms
transforms = []
for kind, config in steps.items():
if isinstance(kind, str):
Task = dicomml_resolve(kind)
else:
Task = kind
transforms.append(Task(**config))
# load
if filenames is None:
filenames = glob.glob(os.path.join(folder_in, filename_pattern))
if num_concurrent_files is None:
num_concurrent_files = len(filenames)
def shards():
for i in range(0, len(filenames), num_concurrent_files):
yield filenames[i:i + num_concurrent_files]
results = {}
for files in shards():
cases = Load(**load_config)(files=files)
# transform
for transform in transforms:
cases = transform(cases)
# save
files = Save(**save_config)(cases=cases, folder=folder_out)
results.update(files)
return results