SYMBOL INDEX (1049 symbols across 110 files)

FILE: delira/_backends.py
  function _determine_backends (line 17) | def _determine_backends():
  function get_backends (line 75) | def get_backends():
  function seed_all (line 91) | def seed_all(seed):

FILE: delira/_debug_mode.py
  function get_current_debug_mode (line 13) | def get_current_debug_mode():
  function switch_debug_mode (line 24) | def switch_debug_mode():
  function set_debug_mode (line 31) | def set_debug_mode(mode: bool):

FILE: delira/_version.py
  function get_keywords (line 19) | def get_keywords():
  class VersioneerConfig (line 32) | class VersioneerConfig:
  function get_config (line 36) | def get_config():
  class NotThisMethod (line 50) | class NotThisMethod(Exception):
  function register_vcs_handler (line 58) | def register_vcs_handler(vcs, method):  # decorator
  function run_command (line 69) | def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
  function versions_from_parentdir (line 106) | def versions_from_parentdir(parentdir_prefix, root, verbose):
  function git_get_keywords (line 132) | def git_get_keywords(versionfile_abs):
  function git_versions_from_keywords (line 161) | def git_versions_from_keywords(keywords, tag_prefix, verbose):
  function git_pieces_from_vcs (line 216) | def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_comma...
  function plus_or_dot (line 307) | def plus_or_dot(pieces):
  function render_pep440 (line 314) | def render_pep440(pieces):
  function render_pep440_pre (line 339) | def render_pep440_pre(pieces):
  function render_pep440_post (line 355) | def render_pep440_post(pieces):
  function render_pep440_old (line 382) | def render_pep440_old(pieces):
  function render_git_describe (line 404) | def render_git_describe(pieces):
  function render_git_describe_long (line 424) | def render_git_describe_long(pieces):
  function render (line 444) | def render(pieces, style):
  function get_versions (line 476) | def get_versions():

FILE: delira/data_loading/augmenter.py
  class AbstractAugmenter (line 15) | class AbstractAugmenter(object):
    method __init__ (line 20) | def __init__(
    method __iter__ (line 69) | def __iter__(self):
  class _ParallelAugmenter (line 73) | class _ParallelAugmenter(AbstractAugmenter):
    method __init__ (line 78) | def __init__(self, data_loader, batchsize, sampler, num_processes=None,
    method abort_event (line 123) | def abort_event(self):
    method abort_event (line 135) | def abort_event(self, new_event):
    method _start_processes (line 147) | def _start_processes(self):
    method _shutdown_processes (line 182) | def _shutdown_processes(self):
    method _next_index_pipe (line 215) | def _next_index_pipe(self):
    method _next_data_pipe (line 226) | def _next_data_pipe(self):
    method _enqueue_indices (line 236) | def _enqueue_indices(self, sample_idxs):
    method _receive_data (line 255) | def _receive_data(self):
    method __iter__ (line 269) | def __iter__(self):
  class _WorkerProcess (line 320) | class _WorkerProcess(multiprocessing.Process):
    method __init__ (line 325) | def __init__(self, dataloader: DataLoader,
    method run (line 358) | def run(self) -> None:
  class _SequentialAugmenter (line 391) | class _SequentialAugmenter(AbstractAugmenter):
    method __init__ (line 397) | def __init__(
    method __iter__ (line 425) | def __iter__(self):
  class Augmenter (line 442) | class Augmenter(object):
    method __init__ (line 449) | def __init__(self, data_loader, batchsize, sampler, num_processes=None,
    method _resolve_augmenter_cls (line 481) | def _resolve_augmenter_cls(num_processes, **kwargs):
    method __iter__ (line 503) | def __iter__(self):

FILE: delira/data_loading/data_loader.py
  class DataLoader (line 7) | class DataLoader:
    method __init__ (line 13) | def __init__(self, data):
    method __call__ (line 38) | def __call__(self, indices):
    method process_id (line 68) | def process_id(self):
    method process_id (line 81) | def process_id(self, new_id):

FILE: delira/data_loading/data_manager.py
  class DataManager (line 17) | class DataManager(object):
    method __init__ (line 24) | def __init__(self, data, batch_size, n_process_augmentation,
    method get_batchgen (line 103) | def get_batchgen(self, seed=1):
    method get_subset (line 141) | def get_subset(self, indices):
    method update_state_from_dict (line 171) | def update_state_from_dict(self, new_state: dict):
    method batch_size (line 219) | def batch_size(self):
    method batch_size (line 232) | def batch_size(self, new_batch_size):
    method n_process_augmentation (line 247) | def n_process_augmentation(self):
    method n_process_augmentation (line 262) | def n_process_augmentation(self, new_process_number):
    method transforms (line 279) | def transforms(self):
    method transforms (line 293) | def transforms(self, new_transforms):
    method data_loader_cls (line 312) | def data_loader_cls(self):
    method data_loader_cls (line 325) | def data_loader_cls(self, new_loader_cls):
    method n_samples (line 345) | def n_samples(self):
    method n_batches (line 358) | def n_batches(self):
    method dataset (line 384) | def dataset(self):
    method dataset (line 388) | def dataset(self, new_dset):
    method __iter__ (line 394) | def __iter__(self):

FILE: delira/data_loading/dataset.py
  class AbstractDataset (line 14) | class AbstractDataset:
    method __init__ (line 20) | def __init__(self, data_path: str, load_fn: typing.Callable):
    method _make_dataset (line 35) | def _make_dataset(self, path: str):
    method __getitem__ (line 53) | def __getitem__(self, index):
    method __len__ (line 70) | def __len__(self):
    method __iter__ (line 81) | def __iter__(self):
    method get_sample_from_index (line 92) | def get_sample_from_index(self, index):
    method get_subset (line 120) | def get_subset(self, indices):
  class _DatasetIter (line 152) | class _DatasetIter(object):
    method __init__ (line 157) | def __init__(self, dset):
    method __iter__ (line 168) | def __iter__(self):
    method __next__ (line 171) | def __next__(self):
  class DictDataset (line 180) | class DictDataset(AbstractDataset):
    method __init__ (line 185) | def __init__(self, data: dict):
    method __getitem__ (line 197) | def __getitem__(self, index: int):
    method get_sample_from_index (line 215) | def get_sample_from_index(self, index):
    method _make_dataset (line 232) | def _make_dataset(self, path: str):
    method __len__ (line 245) | def __len__(self):
  class IterableDataset (line 257) | class IterableDataset(AbstractDataset):
    method __init__ (line 262) | def __init__(self, data: Iterable):
    method __getitem__ (line 273) | def __getitem__(self, index):
    method get_sample_from_index (line 291) | def get_sample_from_index(self, index):
    method _make_dataset (line 308) | def _make_dataset(self, path: str):
    method __len__ (line 321) | def __len__(self):
  class BlankDataset (line 333) | class BlankDataset(AbstractDataset):
    method __init__ (line 340) | def __init__(self, data, old_getitem, **kwargs):
    method __getitem__ (line 361) | def __getitem__(self, index):
    method __len__ (line 378) | def __len__(self):
  class BaseCacheDataset (line 391) | class BaseCacheDataset(AbstractDataset):
    method __init__ (line 401) | def __init__(self, data_path: typing.Union[str, list],
    method _make_dataset (line 423) | def _make_dataset(self, path: typing.Union[str, list]):
    method __getitem__ (line 461) | def __getitem__(self, index):
  class BaseLazyDataset (line 480) | class BaseLazyDataset(AbstractDataset):
    method __init__ (line 486) | def __init__(self, data_path: typing.Union[str, list],
    method _make_dataset (line 508) | def _make_dataset(self, path: typing.Union[str, list]):
    method __getitem__ (line 538) | def __getitem__(self, index):
  class BaseExtendCacheDataset (line 557) | class BaseExtendCacheDataset(BaseCacheDataset):
    method __init__ (line 568) | def __init__(self, data_path: typing.Union[str, list],
    method _make_dataset (line 593) | def _make_dataset(self, path: typing.Union[str, list]):
  class ConcatDataset (line 632) | class ConcatDataset(AbstractDataset):
    method __init__ (line 633) | def __init__(self, *datasets):
    method get_sample_from_index (line 652) | def get_sample_from_index(self, index):
    method __getitem__ (line 692) | def __getitem__(self, index):
    method __len__ (line 695) | def __len__(self):

FILE: delira/data_loading/load_utils.py
  function norm_range (line 9) | def norm_range(mode):
  function norm_zero_mean_unit_std (line 47) | def norm_zero_mean_unit_std(data):
  class LoadSample (line 61) | class LoadSample:
    method __init__ (line 66) | def __init__(self,
    method __call__ (line 113) | def __call__(self, path) -> dict:
  class LoadSampleLabel (line 148) | class LoadSampleLabel(LoadSample):
    method __init__ (line 149) | def __init__(self,
    method __call__ (line 199) | def __call__(self, path) -> dict:

FILE: delira/data_loading/numba_transform.py
  class NumbaTransformWrapper (line 10) | class NumbaTransformWrapper(AbstractTransform):
    method __init__ (line 11) | def __init__(self, transform: AbstractTransform, nopython=True,
    method __call__ (line 26) | def __call__(self, **kwargs):
  class NumbaTransform (line 30) | class NumbaTransform(NumbaTransformWrapper):
    method __init__ (line 31) | def __init__(self, transform_cls, nopython=True, target="cpu",
  class NumbaCompose (line 39) | class NumbaCompose(Compose):
    method __init__ (line 40) | def __init__(self, transforms):

FILE: delira/data_loading/sampler/abstract.py
  class AbstractSampler (line 4) | class AbstractSampler(object):
    method __init__ (line 9) | def __init__(self, indices):
    method __iter__ (line 19) | def __iter__(self):
    method __len__ (line 31) | def __len__(self):
    method from_dataset (line 44) | def from_dataset(cls, dset: AbstractDataset, **kwargs):

FILE: delira/data_loading/sampler/batch.py
  class BatchSampler (line 4) | class BatchSampler(object):
    method __init__ (line 10) | def __init__(self, sampler: AbstractSampler, batch_size, drop_last=Fal...
    method __iter__ (line 26) | def __iter__(self):
    method __len__ (line 50) | def __len__(self):

FILE: delira/data_loading/sampler/random.py
  class RandomSampler (line 5) | class RandomSampler(AbstractSampler):
    method __init__ (line 10) | def __init__(self, indices, replacement=False, num_samples=None):
    method __iter__ (line 32) | def __iter__(self):
    method __len__ (line 52) | def __len__(self):
  class RandomSamplerNoReplacement (line 67) | class RandomSamplerNoReplacement(RandomSampler):
    method __init__ (line 72) | def __init__(self, indices):
  class RandomSamplerWithReplacement (line 84) | class RandomSamplerWithReplacement(RandomSampler):
    method __init__ (line 89) | def __init__(self, indices, num_samples=None):

FILE: delira/data_loading/sampler/sequential.py
  class SequentialSampler (line 4) | class SequentialSampler(AbstractSampler):
    method __iter__ (line 9) | def __iter__(self):

FILE: delira/data_loading/sampler/weighted.py
  class WeightedRandomSampler (line 6) | class WeightedRandomSampler(AbstractSampler):
    method __init__ (line 11) | def __init__(self, weights, num_samples=None):
    method __iter__ (line 29) | def __iter__(self):
    method __len__ (line 41) | def __len__(self):
  class PrevalenceRandomSampler (line 53) | class PrevalenceRandomSampler(WeightedRandomSampler):
    method __init__ (line 58) | def __init__(self, indices):
    method from_dataset (line 80) | def from_dataset(cls, dset: AbstractDataset, key="label", **kwargs):

FILE: delira/io/chainer.py
  function save_checkpoint (line 7) | def save_checkpoint(file, model=None, optimizers=None, epoch=None):
  function _deserialize_and_load (line 74) | def _deserialize_and_load(archive: zipfile.ZipFile, file: str, obj,
  function load_checkpoint (line 108) | def load_checkpoint(file, old_state: dict = None,

FILE: delira/io/sklearn.py
  function save_checkpoint (line 6) | def save_checkpoint(file: str, model=None, epoch=None, **kwargs):
  function load_checkpoint (line 26) | def load_checkpoint(file, **kwargs):

FILE: delira/io/tf.py
  function save_checkpoint (line 10) | def save_checkpoint(file: str, model=None):
  function load_checkpoint (line 24) | def load_checkpoint(file: str, model=None):
  function _create_varlist (line 42) | def _create_varlist(model: AbstractTfEagerNetwork = None,
  function save_checkpoint_eager (line 56) | def save_checkpoint_eager(file,
  function load_checkpoint_eager (line 74) | def load_checkpoint_eager(file,

FILE: delira/io/torch.py
  function save_checkpoint_torch (line 11) | def save_checkpoint_torch(file: str, model=None, optimizers=None,
  function load_checkpoint_torch (line 61) | def load_checkpoint_torch(file, **kwargs):
  function save_checkpoint_torchscript (line 88) | def save_checkpoint_torchscript(file: str, model=None, optimizers=None,
  function load_checkpoint_torchscript (line 132) | def load_checkpoint_torchscript(file: str, **kwargs):

FILE: delira/logging/base_backend.py
  class BaseBackend (line 20) | class BaseBackend(object, metaclass=ABCMeta):
    class FigureManager (line 26) | class FigureManager:
      method __init__ (line 32) | def __init__(self, push_fn, figure_kwargs: dict, push_kwargs: dict):
      method __enter__ (line 52) | def __enter__(self):
      method __exit__ (line 61) | def __exit__(self, *args):
    method __init__ (line 80) | def __init__(self, abort_event: Event = None, queue: Queue = None):
    method _log_item (line 143) | def _log_item(self):
    method _resolve_global_step (line 181) | def _resolve_global_step(self, key, **val):
    method run (line 236) | def run(self):
    method set_queue (line 252) | def set_queue(self, queue: Queue):
    method set_event (line 264) | def set_event(self, event: Event):
    method _call_exec_fn (line 276) | def _call_exec_fn(self, exec_fn, args):
    method _image (line 312) | def _image(self, *args, **kwargs):
    method _images (line 332) | def _images(self, *args, **kwargs):
    method _image_with_boxes (line 350) | def _image_with_boxes(self, *args, **kwargs):
    method _scalar (line 370) | def _scalar(self, *args, **kwargs):
    method _scalars (line 390) | def _scalars(self, *args, **kwargs):
    method _histogram (line 410) | def _histogram(self, *args, **kwargs):
    method _figure (line 431) | def _figure(self, *args, **kwargs):
    method _audio (line 451) | def _audio(self, *args, **kwargs):
    method _video (line 471) | def _video(self, *args, **kwargs):
    method _text (line 491) | def _text(self, *args, **kwargs):
    method _graph_pytorch (line 511) | def _graph_pytorch(self, *args, **kwargs):
    method _graph_tf (line 532) | def _graph_tf(self, *args, **kwargs):
    method _graph_onnx (line 552) | def _graph_onnx(self, *args, **kwargs):
    method _embedding (line 572) | def _embedding(self, *args, **kwargs):
    method _pr_curve (line 592) | def _pr_curve(self, *args, **kwargs):
    method _scatter (line 612) | def _scatter(self, plot_kwargs: dict, figure_kwargs: dict = None,
    method _line (line 636) | def _line(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method _stem (line 660) | def _stem(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method _heatmap (line 683) | def _heatmap(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method _bar (line 706) | def _bar(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method _boxplot (line 729) | def _boxplot(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method _surface (line 752) | def _surface(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method _contour (line 776) | def _contour(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method _quiver (line 800) | def _quiver(self, plot_kwargs=None, figure_kwargs=None, **kwargs):
    method name (line 824) | def name(self):

FILE: delira/logging/base_logger.py
  class Logger (line 11) | class Logger(object):
    method __init__ (line 17) | def __init__(self, backend: BaseBackend, max_queue_size: int = None,
    method log (line 135) | def log(self, log_message: dict):
    method __call__ (line 209) | def __call__(self, log_message: dict):
    method close (line 228) | def close(self):
    method __del__ (line 242) | def __del__(self):
  class SingleThreadedLogger (line 252) | class SingleThreadedLogger(Logger):
    method log (line 258) | def log(self, log_message: dict):
  function make_logger (line 275) | def make_logger(backend: BaseBackend, max_queue_size: int = None,

FILE: delira/logging/logging_context.py
  class LoggingContext (line 8) | class LoggingContext(object):
    method __init__ (line 13) | def __init__(
    method __enter__ (line 59) | def __enter__(self):
    method __exit__ (line 73) | def __exit__(self, *args):
    method log (line 94) | def log(self, msg: dict):
    method __call__ (line 109) | def __call__(self, log_message: dict):

FILE: delira/logging/registry.py
  function log (line 9) | def log(msg: dict, name=None):
  function logger_exists (line 49) | def logger_exists(name: str):
  function register_logger (line 67) | def register_logger(logger: Logger, name: str, overwrite=False):
  function unregister_logger (line 93) | def unregister_logger(name: str):
  function get_logger (line 110) | def get_logger(name):
  function get_available_loggers (line 128) | def get_available_loggers():

FILE: delira/logging/tensorboard_backend.py
  class TensorboardBackend (line 16) | class TensorboardBackend(WriterLoggingBackend):
    method __init__ (line 21) | def __init__(self, writer_kwargs=None,
    method _call_exec_fn (line 46) | def _call_exec_fn(self, exec_fn, args):
    method __del__ (line 70) | def __del__(self):
    method _graph_pytorch (line 78) | def _graph_pytorch(self, model, input_to_model=None, verbose=False,
    method _graph_tf (line 101) | def _graph_tf(self, graph, run_metadata=None):
    method _graph_onnx (line 140) | def _graph_onnx(self, prototxt):
    method _embedding (line 154) | def _embedding(self, mat, metadata=None, label_img=None, global_step=N...
    method _scalars (line 183) | def _scalars(self, main_tag: str, tag_scalar_dict: dict, global_step=N...
    method name (line 214) | def name(self):

FILE: delira/logging/visdom_backend.py
  class VisdomBackend (line 8) | class VisdomBackend(WriterLoggingBackend):
    method __init__ (line 13) | def __init__(self, writer_kwargs: dict = None,
    method name (line 37) | def name(self):

FILE: delira/logging/writer_backend.py
  class WriterLoggingBackend (line 7) | class WriterLoggingBackend(BaseBackend):
    method __init__ (line 12) | def __init__(self, writer_cls, writer_kwargs: dict,
    method convert_to_npy (line 19) | def convert_to_npy(*args, **kwargs):
    method _image (line 40) | def _image(self, tag, img_tensor, global_step=None, walltime=None,
    method _images (line 66) | def _images(self, tag, img_tensor, global_step=None, walltime=None,
    method _image_with_boxes (line 92) | def _image_with_boxes(self, tag, img_tensor, box_tensor, global_step=N...
    method _scalar (line 124) | def _scalar(self, tag, scalar_value, global_step=None, walltime=None):
    method _scalars (line 145) | def _scalars(self, main_tag, tag_scalar_dict, global_step=None,
    method _histogram (line 169) | def _histogram(self, tag, values, global_step=None, bins='tensorflow',
    method _figure (line 194) | def _figure(self, tag, figure, global_step=None, close=True,
    method _audio (line 218) | def _audio(self, tag, snd_tensor, global_step=None, sample_rate=44100,
    method _text (line 243) | def _text(self, tag, text_string, global_step=None, walltime=None):
    method _pr_curve (line 264) | def _pr_curve(self, tag, labels, predictions, global_step=None,
    method _video (line 297) | def _video(self, tag, vid_tensor, global_step=None, fps=4, walltime=No...
    method name (line 322) | def name(self):

FILE: delira/models/abstract_network.py
  class AbstractNetwork (line 7) | class AbstractNetwork(object):
    method __init__ (line 16) | def __init__(self, **kwargs):
    method __call__ (line 32) | def __call__(self, *args, **kwargs):
    method closure (line 54) | def closure(model, data_dict: dict, optimizers: dict, losses: dict,
    method prepare_batch (line 94) | def prepare_batch(batch: dict, input_device, output_device):
    method init_kwargs (line 124) | def init_kwargs(self):

FILE: delira/models/backends/chainer/abstract_network.py
  class ChainerMixin (line 12) | class ChainerMixin(AbstractNetwork):
  class AbstractChainerNetwork (line 16) | class AbstractChainerNetwork(chainer.Chain, ChainerMixin):
    method __init__ (line 21) | def __init__(self, **kwargs):
    method forward (line 35) | def forward(self, *args, **kwargs) -> dict:
    method __call__ (line 54) | def __call__(self, *args, **kwargs) -> dict:
    method prepare_batch (line 76) | def prepare_batch(batch: dict, input_device, output_device):
    method closure (line 112) | def closure(model, data_dict: dict, optimizers: dict, losses: dict,

FILE: delira/models/backends/chainer/data_parallel.py
  function _apply_scatter (line 6) | def _apply_scatter(inputs: chainer.Variable, target_devices: list,
  function _apply_gather (line 91) | def _apply_gather(target_device, dim, *outputs):
  function _scatter (line 98) | def _scatter(inputs, target_devices: list, dim):
  function _gather (line 170) | def _gather(outputs, target_device, dim=0):
  class DataParallelChainerNetwork (line 199) | class DataParallelChainerNetwork(AbstractChainerNetwork):
    method __init__ (line 205) | def __init__(self, module: AbstractChainerNetwork, devices: list,
    method forward (line 248) | def forward(self, *args, **kwargs):
    method params (line 283) | def params(self, include_uninit=True):
    method _scatter (line 300) | def _scatter(inputs, kwargs, target_devices: list, dim=0):
    method _gather (line 342) | def _gather(predictions, dim, target_device):
    method cleargrads (line 363) | def cleargrads(self):
    method zerograds (line 367) | def zerograds(self):
    method closure (line 372) | def closure(self):
    method prepare_batch (line 376) | def prepare_batch(self):
  class ParallelOptimizerCumulateGradientsHook (line 380) | class ParallelOptimizerCumulateGradientsHook(object):
    method __call__ (line 390) | def __call__(self, optimizer: chainer.Optimizer):
  class ParallelOptimizerUpdateModelParameters (line 407) | class ParallelOptimizerUpdateModelParameters(object):
    method __call__ (line 417) | def __call__(self, optimizer: chainer.Optimizer):
  class DataParallelChainerOptimizer (line 423) | class DataParallelChainerOptimizer(chainer.Optimizer):
    method __init__ (line 433) | def __init__(self, optimizer):
    method from_optimizer_class (line 451) | def from_optimizer_class(cls, optim_cls, *args, **kwargs):
    method setup (line 475) | def setup(self, link):
    method target (line 492) | def target(self):
    method epoch (line 496) | def epoch(self):
    method _pre_update_hooks (line 500) | def _pre_update_hooks(self):
    method _loss_scale (line 504) | def _loss_scale(self):
    method _loss_scale_max (line 508) | def _loss_scale_max(self):
    method _loss_scaling_is_dynamic (line 512) | def _loss_scaling_is_dynamic(self):
    method use_auto_new_epoch (line 516) | def use_auto_new_epoch(self):
    method update (line 520) | def update(self):
    method new_epoch (line 524) | def new_epoch(self):
    method add_hook (line 528) | def add_hook(self):
    method remove_hook (line 532) | def remove_hook(self):
    method call_hooks (line 536) | def call_hooks(self):
    method serialize (line 540) | def serialize(self):
    method loss_scaling (line 544) | def loss_scaling(self):
    method set_loss_scale (line 548) | def set_loss_scale(self):
    method check_nan_in_grads (line 552) | def check_nan_in_grads(self):
    method is_safe_to_update (line 556) | def is_safe_to_update(self):
    method update_loss_scale (line 560) | def update_loss_scale(self):

FILE: delira/models/backends/sklearn/abstract_network.py
  class SklearnEstimator (line 7) | class SklearnEstimator(AbstractNetwork):
    method __init__ (line 13) | def __init__(self, module: BaseEstimator):
    method __call__ (line 40) | def __call__(self, *args, **kwargs):
    method iterative_training (line 60) | def iterative_training(self):
    method prepare_batch (line 75) | def prepare_batch(batch: dict, input_device, output_device):
    method closure (line 106) | def closure(model, data_dict: dict, optimizers: dict, losses: dict,

FILE: delira/models/backends/tf_eager/abstract_network.py
  class AbstractTfEagerNetwork (line 8) | class AbstractTfEagerNetwork(AbstractNetwork, tf.keras.layers.Layer):
    method __init__ (line 15) | def __init__(self, data_format="channels_first", trainable=True,
    method call (line 42) | def call(self, *args, **kwargs):
    method __call__ (line 61) | def __call__(self, *args, **kwargs):
    method prepare_batch (line 77) | def prepare_batch(batch: dict, input_device, output_device):
    method closure (line 112) | def closure(model, data_dict: dict,

FILE: delira/models/backends/tf_eager/data_parallel.py
  class DataParallelTfEagerNetwork (line 6) | class DataParallelTfEagerNetwork(AbstractTfEagerNetwork):
    method __init__ (line 15) | def __init__(self, module, devices):
    method call (line 32) | def call(self, *args, **kwargs):
    method closure (line 47) | def closure(self):
    method prepare_batch (line 51) | def prepare_batch(self):

FILE: delira/models/backends/tf_graph/abstract_network.py
  class AbstractTfGraphNetwork (line 9) | class AbstractTfGraphNetwork(AbstractNetwork, metaclass=abc.ABCMeta):
    method __init__ (line 20) | def __init__(self, sess=tf.Session, **kwargs):
    method __call__ (line 39) | def __call__(self, *args, **kwargs):
    method run (line 59) | def run(self, *args, **kwargs):
    method _add_losses (line 91) | def _add_losses(self, losses: dict):
    method _add_optims (line 121) | def _add_optims(self, optims: dict):
    method prepare_batch (line 144) | def prepare_batch(batch: dict, input_device, output_device):
    method closure (line 170) | def closure(model, data_dict: dict, optimizers: dict, losses: dict,

FILE: delira/models/backends/torch/abstract_network.py
  class AbstractPyTorchNetwork (line 8) | class AbstractPyTorchNetwork(AbstractNetwork, torch.nn.Module):
    method __init__ (line 19) | def __init__(self, **kwargs):
    method forward (line 33) | def forward(self, *inputs):
    method __call__ (line 49) | def __call__(self, *args, **kwargs):
    method prepare_batch (line 69) | def prepare_batch(batch: dict, input_device, output_device):
    method closure (line 102) | def closure(model, data_dict: dict, optimizers: dict, losses: dict,

FILE: delira/models/backends/torch/data_parallel.py
  class DataParallelPyTorchNetwork (line 7) | class DataParallelPyTorchNetwork(AbstractPyTorchNetwork,
    method __init__ (line 14) | def __init__(self, module: AbstractPyTorchNetwork,
    method forward (line 41) | def forward(self, *args, **kwargs):
    method closure (line 63) | def closure(self):
    method prepare_batch (line 67) | def prepare_batch(self):

FILE: delira/models/backends/torch/utils.py
  function scale_loss (line 13) | def scale_loss(loss,

FILE: delira/models/backends/torchscript/abstract_network.py
  class AbstractTorchScriptNetwork (line 6) | class AbstractTorchScriptNetwork(AbstractNetwork, torch.jit.ScriptModule):
    method __init__ (line 19) | def __init__(self, optimize=True, **kwargs):
    method __call__ (line 33) | def __call__(self, *args, **kwargs):
    method prepare_batch (line 53) | def prepare_batch(batch: dict, input_device, output_device):
    method closure (line 86) | def closure(model, data_dict: dict, optimizers: dict, losses: dict,

FILE: delira/training/backends/chainer/experiment.py
  class ChainerExperiment (line 14) | class ChainerExperiment(BaseExperiment):
    method __init__ (line 15) | def __init__(self,
    method test (line 79) | def test(self, network: AbstractChainerNetwork,

FILE: delira/training/backends/chainer/trainer.py
  class ChainerNetworkTrainer (line 17) | class ChainerNetworkTrainer(BaseNetworkTrainer):
    method __init__ (line 27) | def __init__(self,
    method _setup (line 189) | def _setup(self, network, optim_fn, optimizer_cls, optimizer_params,
    method _at_training_begin (line 325) | def _at_training_begin(self, *args, **kwargs):
    method _at_training_end (line 344) | def _at_training_end(self, *args, **kwargs):
    method _at_epoch_end (line 364) | def _at_epoch_end(self, metrics_val, val_score_key, epoch, is_best,
    method _train_single_epoch (line 408) | def _train_single_epoch(self, batchgen: MultiThreadedAugmenter, epoch,
    method predict_data_mgr (line 427) | def predict_data_mgr(self, datamgr, batchsize=None, metrics={},
    method save_state (line 462) | def save_state(self, file_name, epoch, **kwargs):
    method load_state (line 485) | def load_state(file_name, **kwargs):
    method update_state (line 508) | def update_state(self, file_name, *args, **kwargs):
    method _update_state (line 533) | def _update_state(self, new_state):
    method _search_for_prev_state (line 561) | def _search_for_prev_state(path, extensions=None):

FILE: delira/training/backends/chainer/utils.py
  function _single_element_tensor_conversion (line 7) | def _single_element_tensor_conversion(element):
  function convert_to_numpy (line 12) | def convert_to_numpy(*args, **kwargs):
  function create_optims_default (line 39) | def create_optims_default(model, optim_cls, **optimizer_params):

FILE: delira/training/backends/sklearn/experiment.py
  class SklearnExperiment (line 15) | class SklearnExperiment(BaseExperiment):
    method __init__ (line 16) | def __init__(self,
    method _setup_training (line 80) | def _setup_training(self, config, **kwargs):
    method _setup_test (line 120) | def _setup_test(self, config, model, convert_batch_to_npy_fn,

FILE: delira/training/backends/sklearn/trainer.py
  class SklearnEstimatorTrainer (line 20) | class SklearnEstimatorTrainer(BaseNetworkTrainer):
    method __init__ (line 30) | def __init__(self,
    method _setup (line 157) | def _setup(self, estimator, key_mapping, convert_batch_to_npy_fn,
    method _at_training_begin (line 206) | def _at_training_begin(self, *args, **kwargs):
    method _at_training_end (line 225) | def _at_training_end(self, *args, **kwargs):
    method _at_epoch_end (line 245) | def _at_epoch_end(self, metrics_val, val_score_key, epoch, is_best,
    method _get_classes_if_necessary (line 285) | def _get_classes_if_necessary(self, dmgr: DataManager, verbose,
    method train (line 330) | def train(self, num_epochs, datamgr_train, datamgr_valid=None,
    method save_state (line 400) | def save_state(self, file_name, epoch, **kwargs):
    method load_state (line 422) | def load_state(file_name, *args, **kwargs):
    method _update_state (line 445) | def _update_state(self, new_state):
    method _search_for_prev_state (line 470) | def _search_for_prev_state(path, extensions=None):
    method calc_metrics (line 498) | def calc_metrics(batch, metrics: dict = None, metric_keys=None):

FILE: delira/training/backends/sklearn/utils.py
  function create_optims_default (line 1) | def create_optims_default(*args, **kwargs):

FILE: delira/training/backends/tf_eager/experiment.py
  class TfEagerExperiment (line 17) | class TfEagerExperiment(BaseExperiment):
    method __init__ (line 18) | def __init__(self,
    method kfold (line 83) | def kfold(self, data: DataManager, metrics: dict, num_epochs=None,
    method test (line 203) | def test(self, network, test_data: DataManager,
    method setup (line 264) | def setup(self, config, training=True, **kwargs):

FILE: delira/training/backends/tf_eager/trainer.py
  class TfEagerNetworkTrainer (line 18) | class TfEagerNetworkTrainer(BaseNetworkTrainer):
    method __init__ (line 19) | def __init__(self,
    method _setup (line 178) | def _setup(self, network, optim_fn, optimizer_cls, optimizer_params,
    method _at_training_end (line 254) | def _at_training_end(self, *args, **kwargs):
    method _train_single_epoch (line 274) | def _train_single_epoch(self, batchgen, epoch, verbose=False):
    method predict_data_mgr (line 290) | def predict_data_mgr(self, datamgr, batchsize=None, metrics=None,
    method save_state (line 320) | def save_state(self, file_name, *args, **kwargs):
    method load_state (line 332) | def load_state(self, file_name, *args, **kwargs):
    method _search_for_prev_state (line 349) | def _search_for_prev_state(path, extensions=None):

FILE: delira/training/backends/tf_eager/utils.py
  function _single_element_tensor_conversion (line 7) | def _single_element_tensor_conversion(element):
  function convert_to_numpy (line 11) | def convert_to_numpy(*args, **kwargs):
  function create_optims_default (line 38) | def create_optims_default(optim_cls, **optim_params):

FILE: delira/training/backends/tf_graph/experiment.py
  class TfGraphExperiment (line 17) | class TfGraphExperiment(TfEagerExperiment):
    method __init__ (line 18) | def __init__(self,
    method test (line 88) | def test(self, network, test_data: DataManager,

FILE: delira/training/backends/tf_graph/trainer.py
  class TfGraphNetworkTrainer (line 20) | class TfGraphNetworkTrainer(BaseNetworkTrainer):
    method __init__ (line 30) | def __init__(self,
    method _setup (line 187) | def _setup(self, network, optim_fn, optimizer_cls, optimizer_params,
    method _at_training_end (line 276) | def _at_training_end(self, *args, **kwargs):
    method _train_single_epoch (line 298) | def _train_single_epoch(self, dmgr_train: DataManager, epoch,
    method predict_data_mgr (line 315) | def predict_data_mgr(self, datamgr, batch_size=None, metrics=None,
    method save_state (line 346) | def save_state(self, file_name, *args, **kwargs):
    method load_state (line 357) | def load_state(self, file_name, *args, **kwargs):
    method _search_for_prev_state (line 372) | def _search_for_prev_state(path, extensions=None):

FILE: delira/training/backends/tf_graph/utils.py
  function initialize_uninitialized (line 4) | def initialize_uninitialized(sess):

FILE: delira/training/backends/torch/experiment.py
  class PyTorchExperiment (line 17) | class PyTorchExperiment(BaseExperiment):
    method __init__ (line 18) | def __init__(self,
    method kfold (line 82) | def kfold(self, data: DataManager, metrics: dict, num_epochs=None,
    method test (line 202) | def test(self, network, test_data: DataManager,

FILE: delira/training/backends/torch/trainer.py
  class PyTorchNetworkTrainer (line 23) | class PyTorchNetworkTrainer(BaseNetworkTrainer):
    method __init__ (line 33) | def __init__(self,
    method _setup (line 248) | def _setup(self, network, optim_fn, optimizer_cls, optimizer_params,
    method _at_training_begin (line 366) | def _at_training_begin(self, *args, **kwargs):
    method _at_training_end (line 382) | def _at_training_end(self, *args, **kwargs):
    method _at_epoch_end (line 402) | def _at_epoch_end(self, metrics_val, val_score_key, epoch, is_best,
    method _train_single_epoch (line 444) | def _train_single_epoch(self, batchgen: MultiThreadedAugmenter, epoch,
    method predict_data_mgr (line 463) | def predict_data_mgr(self, datamgr, batchsize=None, metrics=None,
    method save_state (line 501) | def save_state(self, file_name, epoch, **kwargs):
    method load_state (line 521) | def load_state(file_name, **kwargs):
    method _update_state (line 544) | def _update_state(self, new_state):
    method _search_for_prev_state (line 575) | def _search_for_prev_state(path, extensions=None):

FILE: delira/training/backends/torch/utils.py
  function create_optims_default (line 9) | def create_optims_default(model, optim_cls, **optim_params):
  function _single_element_tensor_conversion (line 31) | def _single_element_tensor_conversion(element):
  function convert_to_numpy (line 35) | def convert_to_numpy(*args, **kwargs):

FILE: delira/training/backends/torchscript/experiment.py
  class TorchScriptExperiment (line 13) | class TorchScriptExperiment(PyTorchExperiment):
    method __init__ (line 14) | def __init__(self,

FILE: delira/training/backends/torchscript/trainer.py
  class TorchScriptNetworkTrainer (line 19) | class TorchScriptNetworkTrainer(PyTorchNetworkTrainer):
    method __init__ (line 20) | def __init__(self,
    method save_state (line 190) | def save_state(self, file_name, epoch, **kwargs):
    method load_state (line 212) | def load_state(file_name, **kwargs):
    method _update_state (line 231) | def _update_state(self, new_state):
    method _search_for_prev_state (line 252) | def _search_for_prev_state(path, extensions=None):

FILE: delira/training/base_experiment.py
  class BaseExperiment (line 26) | class BaseExperiment(object):
    method __init__ (line 41) | def __init__(self,
    method setup (line 144) | def setup(self, config, training=True, **kwargs):
    method _setup_training (line 178) | def _setup_training(self, config, **kwargs):
    method _setup_test (line 245) | def _setup_test(self, config, model, convert_batch_to_npy_fn,
    method run (line 277) | def run(self, train_data: DataManager,
    method resume (line 326) | def resume(self, save_path: str, train_data: DataManager,
    method test (line 365) | def test(self, network, test_data: DataManager,
    method kfold (line 417) | def kfold(self, data: DataManager, metrics: dict, num_epochs=None,
    method __str__ (line 604) | def __str__(self):
    method __call__ (line 619) | def __call__(self, *args, **kwargs):
    method save (line 638) | def save(self):
    method load (line 650) | def load(file_name):
    method _resolve_params (line 663) | def _resolve_params(self, config: typing.Union[DeliraConfig, None]):
    method _resolve_kwargs (line 691) | def _resolve_kwargs(self, kwargs: typing.Union[dict, None]):
    method __getstate__ (line 719) | def __getstate__(self):
    method __setstate__ (line 722) | def __setstate__(self, state):

FILE: delira/training/base_trainer.py
  class BaseNetworkTrainer (line 21) | class BaseNetworkTrainer(Predictor):
    method __init__ (line 37) | def __init__(self,
    method _setup (line 188) | def _setup(self, network, lr_scheduler_cls, lr_scheduler_params, gpu_ids,
    method _at_training_begin (line 212) | def _at_training_begin(self, *args, **kwargs):
    method _at_training_end (line 230) | def _at_training_end(self, *args, **kwargs):
    method _at_epoch_begin (line 252) | def _at_epoch_begin(self, val_score_key, epoch, num_epochs,
    method _at_epoch_end (line 276) | def _at_epoch_end(self, metrics_val, val_score_key, epoch, is_best,
    method _at_iter_begin (line 310) | def _at_iter_begin(self, iter_num, epoch=0, **kwargs):
    method _at_iter_end (line 333) | def _at_iter_end(self, iter_num, data_dict, metrics, epoch=0, **kwargs):
    method _train_single_epoch (line 365) | def _train_single_epoch(self, dmgr_train: DataManager, epoch,
    method train (line 439) | def train(self, num_epochs, datamgr_train, datamgr_valid=None,
    method fold (line 566) | def fold(self):
    method fold (line 579) | def fold(self, fold):
    method register_callback (line 601) | def register_callback(self, callback: AbstractCallback):
    method save_state (line 630) | def save_state(self, file_name, *args, **kwargs):
    method load_state (line 648) | def load_state(file_name, *args, **kwargs):
    method _update_state (line 671) | def _update_state(self, new_state):
    method update_state (line 699) | def update_state(self, file_name, *args, **kwargs):
    method _is_better_val_scores (line 721) | def _is_better_val_scores(old_val_score, new_val_score,
    method name (line 751) | def name(self):
    method _reinitialize_logging (line 755) | def _reinitialize_logging(self, logging_type, logging_kwargs: dict,
    method _search_for_prev_state (line 854) | def _search_for_prev_state(path, extensions=None):
    method register_callback (line 910) | def register_callback(self, callback: AbstractCallback):

FILE: delira/training/callbacks/abstract_callback.py
  class AbstractCallback (line 1) | class AbstractCallback(object):
    method __init__ (line 12) | def __init__(self, *args, **kwargs):
    method at_epoch_begin (line 25) | def at_epoch_begin(self, trainer, *args, **kwargs):
    method at_epoch_end (line 48) | def at_epoch_end(self, trainer, *args, **kwargs):
    method at_training_begin (line 71) | def at_training_begin(self, trainer, *args, **kwargs):
    method at_training_end (line 89) | def at_training_end(self, trainer, *args, **kwargs):
    method at_iter_begin (line 108) | def at_iter_begin(self, trainer, *args, **kwargs):
    method at_iter_end (line 135) | def at_iter_end(self, trainer, *args, **kwargs):

FILE: delira/training/callbacks/early_stopping.py
  class EarlyStopping (line 4) | class EarlyStopping(AbstractCallback):
    method __init__ (line 14) | def __init__(self, monitor_key,
    method _is_better (line 51) | def _is_better(self, metric):
    method at_epoch_end (line 72) | def at_epoch_end(self, trainer, **kwargs):

FILE: delira/training/callbacks/logging_callback.py
  class DefaultLoggingCallback (line 6) | class DefaultLoggingCallback(AbstractCallback):
    method __init__ (line 12) | def __init__(self, backend: BaseBackend, max_queue_size: int = None,
    method at_iter_end (line 53) | def at_iter_end(self, trainer, iter_num=None, data_dict=None, train=Fa...
    method create_tag (line 87) | def create_tag(tag: str, train: bool):

FILE: delira/training/callbacks/pytorch_schedulers.py
  class DefaultPyTorchSchedulerCallback (line 9) | class DefaultPyTorchSchedulerCallback(AbstractCallback):
    method __init__ (line 16) | def __init__(self, *args, **kwargs):
    method at_epoch_end (line 31) | def at_epoch_end(self, trainer, **kwargs):
  class OneCycleLRCallback (line 51) | class OneCycleLRCallback(DefaultPyTorchSchedulerCallback):
    method __init__ (line 57) | def __init__(
    method at_iter_begin (line 144) | def at_iter_begin(self, trainer, train,
    method at_epoch_end (line 167) | def at_epoch_end(self, trainer, **kwargs):
  class ReduceLROnPlateauCallback (line 170) | class ReduceLROnPlateauCallback(DefaultPyTorchSchedulerCallback):
    method __init__ (line 176) | def __init__(self, optimizer, mode='min', factor=0.1, patience=10,
    method at_epoch_end (line 238) | def at_epoch_end(self, trainer,
  class CosineAnnealingLRCallback (line 266) | class CosineAnnealingLRCallback(DefaultPyTorchSchedulerCallback):
    method __init__ (line 272) | def __init__(self, optimizer, T_max, eta_min=0, last_epoch=-1):
  class ExponentialLRCallback (line 292) | class ExponentialLRCallback(DefaultPyTorchSchedulerCallback):
    method __init__ (line 298) | def __init__(self, optimizer, gamma, last_epoch=-1):
  class LambdaLRCallback (line 315) | class LambdaLRCallback(DefaultPyTorchSchedulerCallback):
    method __init__ (line 321) | def __init__(self, optimizer, lr_lambda, last_epoch=-1):
  class MultiStepLRCallback (line 340) | class MultiStepLRCallback(DefaultPyTorchSchedulerCallback):
    method __init__ (line 346) | def __init__(self, optimizer, milestones, gamma=0.1, last_epoch=-1):
  class StepLRCallback (line 367) | class StepLRCallback(DefaultPyTorchSchedulerCallback):
    method __init__ (line 373) | def __init__(self, optimizer, step_size, gamma=0.1, last_epoch=-1):

FILE: delira/training/losses.py
  class BCEFocalLossPyTorch (line 7) | class BCEFocalLossPyTorch(torch.nn.Module):
    method __init__ (line 13) | def __init__(self, alpha=None, gamma=2, reduction='elementwise_mean'):
    method forward (line 45) | def forward(self, p, t):
  class BCEFocalLossLogitPyTorch (line 73) | class BCEFocalLossLogitPyTorch(torch.nn.Module):
    method __init__ (line 79) | def __init__(self, alpha=None, gamma=2, reduction='elementwise_mean'):
    method forward (line 110) | def forward(self, p, t):

FILE: delira/training/metrics.py
  class SklearnClassificationMetric (line 11) | class SklearnClassificationMetric(object):
    method __init__ (line 12) | def __init__(self, score_fn, gt_logits=False, pred_logits=True, **kwar...
    method __call__ (line 32) | def __call__(self, y_true, y_pred, **kwargs):
  class SklearnAccuracyScore (line 62) | class SklearnAccuracyScore(SklearnClassificationMetric):
    method __init__ (line 67) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnBalancedAccuracyScore (line 71) | class SklearnBalancedAccuracyScore(SklearnClassificationMetric):
    method __init__ (line 76) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnF1Score (line 81) | class SklearnF1Score(SklearnClassificationMetric):
    method __init__ (line 86) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnFBetaScore (line 90) | class SklearnFBetaScore(SklearnClassificationMetric):
    method __init__ (line 95) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnHammingLoss (line 99) | class SklearnHammingLoss(SklearnClassificationMetric):
    method __init__ (line 104) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnJaccardSimilarityScore (line 108) | class SklearnJaccardSimilarityScore(SklearnClassificationMetric):
    method __init__ (line 113) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnLogLoss (line 118) | class SklearnLogLoss(SklearnClassificationMetric):
    method __init__ (line 123) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnMatthewsCorrCoeff (line 127) | class SklearnMatthewsCorrCoeff(SklearnClassificationMetric):
    method __init__ (line 132) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnPrecisionScore (line 136) | class SklearnPrecisionScore(SklearnClassificationMetric):
    method __init__ (line 141) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnRecallScore (line 145) | class SklearnRecallScore(SklearnClassificationMetric):
    method __init__ (line 150) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class SklearnZeroOneLoss (line 154) | class SklearnZeroOneLoss(SklearnClassificationMetric):
    method __init__ (line 159) | def __init__(self, gt_logits=False, pred_logits=True, **kwargs):
  class AurocMetric (line 163) | class AurocMetric(object):
    method __init__ (line 164) | def __init__(self, classes=(0, 1), **kwargs):
    method __call__ (line 187) | def __call__(self, y_true, y_pred, **kwargs):

FILE: delira/training/predictor.py
  class Predictor (line 16) | class Predictor(object):
    method __init__ (line 29) | def __init__(
    method _setup (line 67) | def _setup(self, network, key_mapping, convert_batch_args_kwargs_to_np...
    method __call__ (line 102) | def __call__(self, data: dict, **kwargs):
    method predict (line 120) | def predict(self, data: dict, already_prepared=False, **kwargs):
    method _at_iter_begin (line 159) | def _at_iter_begin(self, iter_num, **kwargs):
    method _at_iter_end (line 185) | def _at_iter_end(self, iter_num, data_dict, metrics, **kwargs):
    method predict_data_mgr (line 217) | def predict_data_mgr(
    method predict_data_mgr_cache_metrics_only (line 334) | def predict_data_mgr_cache_metrics_only(self, datamgr, batchsize=None,
    method predict_data_mgr_cache_all (line 385) | def predict_data_mgr_cache_all(self, datamgr, batchsize=None, metrics=...
    method predict_data_mgr_cache (line 434) | def predict_data_mgr_cache(self, datamgr, batchsize=None, metrics=None,
    method __convert_dict (line 521) | def __convert_dict(old_dict, new_dict):
    method __concatenate_dict_items (line 566) | def __concatenate_dict_items(dict_like: dict):
    method __setattr__ (line 589) | def __setattr__(self, key, value):
    method calc_metrics (line 616) | def calc_metrics(batch: LookupConfig, metrics=None, metric_keys=None):
    method register_callback (line 647) | def register_callback(self, callback: AbstractCallback):

FILE: delira/training/utils.py
  function recursively_convert_elements (line 5) | def recursively_convert_elements(element, check_type, conversion_fn):
  function _correct_zero_shape (line 58) | def _correct_zero_shape(arg):
  function convert_to_numpy_identity (line 80) | def convert_to_numpy_identity(*args, **kwargs):

FILE: delira/utils/codecs.py
  class Encoder (line 12) | class Encoder:
    method __call__ (line 18) | def __call__(self, obj) -> typing.Any:
    method encode (line 34) | def encode(self, obj) -> typing.Any:
    method _encode_list (line 79) | def _encode_list(self, obj) -> list:
    method _encode_dict (line 95) | def _encode_dict(self, obj) -> dict:
    method _encode_array (line 112) | def _encode_array(self, obj) -> dict:
    method _encode_mapping (line 132) | def _encode_mapping(self, obj) -> dict:
    method _encode_iterable (line 154) | def _encode_iterable(self, obj) -> dict:
    method _encode_module (line 176) | def _encode_module(self, obj) -> dict:
    method _encode_type (line 193) | def _encode_type(self, obj) -> dict:
    method _encode_function (line 213) | def _encode_function(self, obj) -> dict:
    method _encode_class (line 233) | def _encode_class(self, obj) -> dict:
  class Decoder (line 257) | class Decoder:
    method __init__ (line 262) | def __init__(self):
    method __call__ (line 275) | def __call__(self, obj) -> typing.Any:
    method decode (line 291) | def decode(self, obj) -> typing.Any:
    method _decode_dict (line 314) | def _decode_dict(self, obj) -> dict:
    method _decode_list (line 335) | def _decode_list(self, obj) -> list:
    method _decode_array (line 351) | def _decode_array(self, obj) -> np.ndarray:
    method _decode_convert (line 367) | def _decode_convert(self, obj: dict) -> typing.Union[
    method _decode_module (line 387) | def _decode_module(self, obj: dict) -> types.ModuleType:
    method _decode_type (line 403) | def _decode_type(self, obj) -> typing.Any:
    method _decode_function (line 422) | def _decode_function(self, obj: dict) -> typing.Union[
    method _decode_class (line 442) | def _decode_class(self, obj: dict) -> typing.Any:
    method _decode_classargs (line 477) | def _decode_classargs(self, obj: dict) -> typing.Any:
    method _decode_functionargs (line 508) | def _decode_functionargs(self, obj: dict) -> typing.Any:

FILE: delira/utils/config.py
  function non_string_warning (line 15) | def non_string_warning(func):
  class Config (line 42) | class Config(dict):
    method __init__ (line 47) | def __init__(self, dict_like=None, **kwargs):
    method __setattr__ (line 85) | def __setattr__(self, key, value):
    method __setitem__ (line 100) | def __setitem__(self, key, value):
    method _traverse_keys (line 121) | def _traverse_keys(self, keys, create=False):
    method _set_internal_item (line 150) | def _set_internal_item(self, key, item, deepcopy=False):
    method _to_config (line 170) | def _to_config(cls, item):
    method _create_internal_dict (line 193) | def _create_internal_dict(*args, **kwargs):
    method __getitem__ (line 206) | def __getitem__(self, key):
    method __contains__ (line 229) | def __contains__(self, key):
    method update (line 251) | def update(self, update_dict, deepcopy=False, overwrite=False):
    method _update (line 274) | def _update(self, key, item, deepcopy=False, overwrite=False):
    method _raise_overwrite (line 300) | def _raise_overwrite(self, key, overwrite):
    method dump (line 321) | def dump(self, path, formatter=yaml.dump, encoder_cls=Encoder, **kwargs):
    method dumps (line 342) | def dumps(self, formatter=yaml.dump, encoder_cls=Encoder, **kwargs):
    method load (line 361) | def load(self, path, formatter=yaml.load, decoder_cls=Decoder, **kwargs):
    method loads (line 382) | def loads(self, data, formatter=yaml.load, decoder_cls=Decoder, **kwar...
    method create_from_dict (line 403) | def create_from_dict(cls, value, deepcopy=False):
    method create_from_argparse (line 432) | def create_from_argparse(cls, value, deepcopy=False, **kwargs):
    method create_from_file (line 465) | def create_from_file(cls, path, formatter=yaml.load, decoder_cls=Decoder,
    method create_from_str (line 493) | def create_from_str(cls, data, formatter=yaml.load, decoder_cls=Decoder,
    method create_argparser (line 520) | def create_argparser(self):
    method _add_unknown_args (line 556) | def _add_unknown_args(unknown_args):
    method update_from_argparse (line 602) | def update_from_argparse(self, parser=None, add_unknown_items=False):
  class LookupConfig (line 645) | class LookupConfig(Config):
    method _create_internal_dict (line 651) | def _create_internal_dict(*args, **kwargs):
    method __contains__ (line 664) | def __contains__(self, key):
    method nested_get (line 686) | def nested_get(self, key, *args, allow_multiple=False, **kwargs):
  class DeliraConfig (line 735) | class DeliraConfig(LookupConfig):
    method __init__ (line 741) | def __init__(self, dict_like=None, fixed_model=None, fixed_training=None,
    method generate_dict (line 774) | def generate_dict(value):
    method params (line 794) | def params(self):
    method variable_params (line 809) | def variable_params(self):
    method variable_params (line 822) | def variable_params(self, new_params: dict):
    method fixed_params (line 847) | def fixed_params(self):
    method fixed_params (line 860) | def fixed_params(self, new_params: dict):
    method model_params (line 884) | def model_params(self):
    method model_params (line 897) | def model_params(self, new_params: dict):
    method training_params (line 921) | def training_params(self):
    method training_params (line 934) | def training_params(self, new_params: dict):
    method log_as_string (line 957) | def log_as_string(self, full_config=False, **kwargs):

FILE: delira/utils/context_managers.py
  class DebugMode (line 4) | class DebugMode(object):
    method __init__ (line 11) | def __init__(self, mode):
    method _switch_to_new_mode (line 21) | def _switch_to_new_mode(self):
    method __enter__ (line 31) | def __enter__(self):
    method __exit__ (line 37) | def __exit__(self, *args, **kwargs):
  class DebugEnabled (line 56) | class DebugEnabled(DebugMode):
    method __init__ (line 62) | def __init__(self):
  class DebugDisabled (line 66) | class DebugDisabled(DebugMode):
    method __init__ (line 71) | def __init__(self):

FILE: delira/utils/decorators.py
  function dtype_func (line 9) | def dtype_func(class_object):
  function classtype_func (line 42) | def classtype_func(class_object):
  function make_deprecated (line 74) | def make_deprecated(new_func):

FILE: delira/utils/dict_reductions.py
  function reduce_last (line 7) | def reduce_last(items: list) -> Union[float, int, np.ndarray]:
  function reduce_first (line 25) | def reduce_first(items: list) -> Union[float, int, np.ndarray]:
  function reduce_mean (line 43) | def reduce_mean(items: list) -> Union[float, int, np.ndarray]:
  function reduce_median (line 61) | def reduce_median(items: list) -> Union[float, int, np.ndarray]:
  function reduce_max (line 79) | def reduce_max(items: list) -> Union[float, int, np.ndarray]:
  function reduce_min (line 97) | def reduce_min(items: list) -> Union[float, int, np.ndarray]:
  function flatten_dict (line 115) | def flatten_dict(d: dict, parent_key: str = '', sep: str = '.') -> dict:
  function unflatten_dict (line 146) | def unflatten_dict(dictionary: dict, sep: str = ".") -> dict:
  function reduce_dict (line 174) | def reduce_dict(items: list, reduce_fn) -> dict:
  function possible_reductions (line 234) | def possible_reductions() -> tuple:
  function get_reduction (line 246) | def get_reduction(reduce_type: str) -> Callable:

FILE: delira/utils/messenger.py
  class BaseMessenger (line 9) | class BaseMessenger(ABC):
    method __init__ (line 15) | def __init__(self, experiment: BaseExperiment, notify_epochs: int = No...
    method emit_message (line 31) | def emit_message(self, msg: str) -> dict:
    method __getattr__ (line 49) | def __getattr__(self, attr):
    method run (line 70) | def run(self, *args, **kwargs):
    method resume (line 107) | def resume(self, *args, **kwargs):
    method test (line 143) | def test(self, *args, **kwargs):
    method kfold (line 173) | def kfold(self, *args, **kwargs):
  class MessengerEpochCallback (line 218) | class MessengerEpochCallback(AbstractCallback):
    method __init__ (line 227) | def __init__(self, n_epochs: int, messenger: BaseMessenger):
    method at_epoch_end (line 241) | def at_epoch_end(self, trainer, **kwargs) -> dict:
  class MessengerFoldCallback (line 265) | class MessengerFoldCallback(AbstractCallback):
    method __init__ (line 274) | def __init__(self, messenger: BaseMessenger):
    method at_training_begin (line 285) | def at_training_begin(self, trainer, **kwargs) -> dict:
    method at_training_end (line 305) | def at_training_end(self, trainer, **kwargs) -> dict:
  class SlackMessenger (line 326) | class SlackMessenger(BaseMessenger):
    method __init__ (line 341) | def __init__(self, experiment: BaseExperiment, token: str,
    method emit_message (line 401) | def emit_message(self, msg, **kwargs):
    method _emit_message_v1 (line 434) | def _emit_message_v1(self, msg, **kwargs) -> dict:
    method _emit_message_v2 (line 462) | def _emit_message_v2(self, msg, **kwargs):

FILE: delira/utils/path.py
  function subdirs (line 4) | def subdirs(d):

FILE: delira/utils/time.py
  function now (line 4) | def now():

FILE: docs/_api/_build/delira/logging/logging_context.py
  class LoggingContext (line 8) | class LoggingContext(object):
    method __init__ (line 13) | def __init__(
    method __enter__ (line 59) | def __enter__(self):
    method __exit__ (line 73) | def __exit__(self, *args):
    method log (line 94) | def log(self, msg: dict):
    method __call__ (line 109) | def __call__(self, log_message: dict):

FILE: docs/_api/_build/delira/logging/registry.py
  function log (line 9) | def log(msg: dict, name=None):
  function logger_exists (line 49) | def logger_exists(name: str):
  function register_logger (line 67) | def register_logger(logger: Logger, name: str, overwrite=False):
  function unregister_logger (line 93) | def unregister_logger(name: str):
  function get_logger (line 110) | def get_logger(name):
  function get_available_loggers (line 128) | def get_available_loggers():

FILE: docs/_api/_build/delira/logging/tensorboard_backend.py
  class TensorboardBackend (line 8) | class TensorboardBackend(WriterLoggingBackend):
    method __init__ (line 13) | def __init__(self, writer_kwargs=None,
    method _call_exec_fn (line 33) | def _call_exec_fn(self, exec_fn, args):
    method __del__ (line 57) | def __del__(self):
    method _graph_pytorch (line 65) | def _graph_pytorch(self, model, input_to_model=None, verbose=False,
    method _graph_tf (line 88) | def _graph_tf(self, graph, run_metadata=None):
    method _graph_onnx (line 127) | def _graph_onnx(self, prototxt):
    method _embedding (line 141) | def _embedding(self, mat, metadata=None, label_img=None, global_step=N...
    method _scalars (line 170) | def _scalars(self, main_tag: str, tag_scalar_dict: dict, global_step=N...
    method name (line 201) | def name(self):

FILE: docs/_api/_build/delira/logging/visdom_backend.py
  class VisdomBackend (line 8) | class VisdomBackend(WriterLoggingBackend):
    method __init__ (line 13) | def __init__(self, writer_kwargs: dict = None,
    method name (line 37) | def name(self):

FILE: docs/_api/_build/delira/logging/writer_backend.py
  class WriterLoggingBackend (line 7) | class WriterLoggingBackend(BaseBackend):
    method __init__ (line 12) | def __init__(self, writer_cls, writer_kwargs: dict,
    method convert_to_npy (line 19) | def convert_to_npy(*args, **kwargs):
    method _image (line 40) | def _image(self, tag, img_tensor, global_step=None, walltime=None,
    method _images (line 66) | def _images(self, tag, img_tensor, global_step=None, walltime=None,
    method _image_with_boxes (line 92) | def _image_with_boxes(self, tag, img_tensor, box_tensor, global_step=N...
    method _scalar (line 124) | def _scalar(self, tag, scalar_value, global_step=None, walltime=None):
    method _scalars (line 145) | def _scalars(self, main_tag, tag_scalar_dict, global_step=None,
    method _histogram (line 169) | def _histogram(self, tag, values, global_step=None, bins='tensorflow',
    method _figure (line 194) | def _figure(self, tag, figure, global_step=None, close=True,
    method _audio (line 218) | def _audio(self, tag, snd_tensor, global_step=None, sample_rate=44100,
    method _text (line 243) | def _text(self, tag, text_string, global_step=None, walltime=None):
    method _pr_curve (line 264) | def _pr_curve(self, tag, labels, predictions, global_step=None,
    method _video (line 297) | def _video(self, tag, vid_tensor, global_step=None, fps=4, walltime=No...
    method name (line 322) | def name(self):

FILE: docs/conf.py
  function read_file (line 31) | def read_file(file):

FILE: setup.py
  function resolve_requirements (line 6) | def resolve_requirements(file):
  function read_file (line 21) | def read_file(file):
  function unify_requirements (line 27) | def unify_requirements(base_requirements: list, *additional_requirement_...
  function parse_all_requirements (line 36) | def parse_all_requirements(backend_requirement_dict: dict):

FILE: tests/data_loading/test_augmenters.py
  class TestAugmenters (line 10) | class TestAugmenters(unittest.TestCase):
    method setUp (line 11) | def setUp(self) -> None:
    method _aug_test (line 31) | def _aug_test(self):
    method test_parallel (line 60) | def test_parallel(self):
    method test_parallel_drop_last (line 66) | def test_parallel_drop_last(self):
    method test_sequential (line 72) | def test_sequential(self):
    method test_sequential_drop_last (line 78) | def test_sequential_drop_last(self):
    method _test_sampler_indices (line 81) | def _test_sampler_indices(self, parallel: bool):
    method test_sampling_order_parallel (line 115) | def test_sampling_order_parallel(self):
    method test_sampling_order_sequential (line 121) | def test_sampling_order_sequential(self):

FILE: tests/data_loading/test_data_loader.py
  class DataLoaderTest (line 8) | class DataLoaderTest(unittest.TestCase):
    method _test_data_loader (line 10) | def _test_data_loader(self, data):
    method test_data_loader_dset (line 34) | def test_data_loader_dset(self):
    method test_data_loader_dict (line 41) | def test_data_loader_dict(self):
    method test_data_loader_iterable (line 49) | def test_data_loader_iterable(self):

FILE: tests/data_loading/test_data_manager.py
  class DataManagerTest (line 12) | class DataManagerTest(unittest.TestCase):
    method test_datamanager (line 17) | def test_datamanager(self):

FILE: tests/data_loading/test_dataset.py
  class DataSubsetConcatTest (line 12) | class DataSubsetConcatTest(unittest.TestCase):
    method load_dummy_sample (line 15) | def load_dummy_sample(path, label_load_fct):
    method test_data_subset_concat (line 34) | def test_data_subset_concat(self):
    method test_cache_dataset (line 89) | def test_cache_dataset(self):
    method test_lazy_dataset (line 149) | def test_lazy_dataset(self):
    method test_load_sample (line 175) | def test_load_sample(self):

FILE: tests/data_loading/test_numba_transforms.py
  class NumbaTest (line 13) | class NumbaTest(unittest.TestCase):
    method setUp (line 14) | def setUp(self) -> None:
    method compare_transform_outputs (line 30) | def compare_transform_outputs(self, transform, numba_transform):
    method test_zoom (line 42) | def test_zoom(self):
    method test_pad (line 50) | def test_pad(self):
    method test_compose (line 58) | def test_compose(self):

FILE: tests/data_loading/test_sampler.py
  class SamplerTest (line 11) | class SamplerTest(unittest.TestCase):
    method setUp (line 12) | def setUp(self) -> None:
    method test_batch_sampler (line 18) | def test_batch_sampler(self):
    method test_sequential (line 41) | def test_sequential(self):
    method test_random_replacement (line 54) | def test_random_replacement(self):
    method test_random_no_replacement (line 71) | def test_random_no_replacement(self):
    method test_prevalence_sampler (line 88) | def test_prevalence_sampler(self):
    method test_abstract_sampler_iter (line 107) | def test_abstract_sampler_iter(self):

FILE: tests/data_loading/utils.py
  class DummyDataset (line 7) | class DummyDataset(AbstractDataset):
    method __init__ (line 8) | def __init__(self, length=600, class_weights=[0.5, 0.3, 0.2]):
    method __getitem__ (line 20) | def __getitem__(self, index):
    method __len__ (line 23) | def __len__(self):

FILE: tests/io/test_chainer.py
  class Model (line 10) | class Model(AbstractChainerNetwork):
    method __init__ (line 11) | def __init__(self):
    method forward (line 17) | def forward(self, x):
  class IoChainerTest (line 25) | class IoChainerTest(unittest.TestCase):
    method test_load_save (line 30) | def test_load_save(self):

FILE: tests/io/test_sklearn.py
  class IoSklearnTest (line 6) | class IoSklearnTest(unittest.TestCase):
    method test_load_save (line 11) | def test_load_save(self):

FILE: tests/io/test_tf.py
  class IoTfTest (line 6) | class IoTfTest(unittest.TestCase):
    method setUp (line 8) | def setUp(self) -> None:
    method test_load_save (line 19) | def test_load_save(self):
    method test_load_save_eager (line 72) | def test_load_save_eager(self):
    method tearDown (line 114) | def tearDown(self) -> None:

FILE: tests/io/test_torch.py
  class IoTorchTest (line 6) | class IoTorchTest(unittest.TestCase):
    method test_load_save (line 11) | def test_load_save(self):
    method test_torchscript_save (line 41) | def test_torchscript_save(self):

FILE: tests/logging/test_logging_frequency.py
  class DummyBackend (line 6) | class DummyBackend(BaseBackend):
    method _text (line 7) | def _text(self, logging_no: int, tag: str, global_step=None):
    method _image (line 11) | def _image(self, *args, **kwargs):
    method _images (line 14) | def _images(self, *args, **kwargs):
    method _image_with_boxes (line 17) | def _image_with_boxes(self, *args, **kwargs):
    method _scalar (line 20) | def _scalar(self, *args, **kwargs):
    method _scalars (line 23) | def _scalars(self, *args, **kwargs):
    method _histogram (line 26) | def _histogram(self, *args, **kwargs):
    method _figure (line 29) | def _figure(self, *args, **kwargs):
    method _audio (line 32) | def _audio(self, *args, **kwargs):
    method _video (line 35) | def _video(self, *args, **kwargs):
    method _graph_pytorch (line 38) | def _graph_pytorch(self, *args, **kwargs):
    method _graph_tf (line 41) | def _graph_tf(self, *args, **kwargs):
    method _graph_onnx (line 44) | def _graph_onnx(self, *args, **kwargs):
    method _embedding (line 47) | def _embedding(self, *args, **kwargs):
    method _pr_curve (line 50) | def _pr_curve(self, *args, **kwargs):
  class LoggingFrequencyTestCase (line 54) | class LoggingFrequencyTestCase(unittest.TestCase):
    method _logging_freq_test (line 56) | def _logging_freq_test(self, frequencies, num_runs: int, check_freq=No...
    method test_logging_freq (line 77) | def test_logging_freq(self):

FILE: tests/logging/test_logging_outside_trainer.py
  class LoggingOutsideTrainerTestCase (line 14) | class LoggingOutsideTrainerTestCase(unittest.TestCase):
    method test_logging_freq (line 18) | def test_logging_freq(self):

FILE: tests/logging/test_single_threaded_logging.py
  class TestTensorboardLogging (line 27) | class TestTensorboardLogging(unittest.TestCase):
    method setUp (line 29) | def setUp(self) -> None:
    method _setup_logger (line 87) | def _setup_logger(self):
    method _check_for_tag (line 92) | def _check_for_tag(self, tag, logdir=None):
    method _destroy_logger (line 117) | def _destroy_logger(logger: Logger):
    method test_image_npy (line 122) | def test_image_npy(self):
    method test_image_torch (line 129) | def test_image_torch(self):
    method test_img_npy (line 135) | def test_img_npy(self):
    method test_img_torch (line 142) | def test_img_torch(self):
    method test_picture_npy (line 148) | def test_picture_npy(self):
    method test_picture_torch (line 155) | def test_picture_torch(self):
    method test_images_npy (line 162) | def test_images_npy(self):
    method test_images_torch (line 169) | def test_images_torch(self):
    method test_imgs_npy (line 175) | def test_imgs_npy(self):
    method test_imgs_torch (line 182) | def test_imgs_torch(self):
    method test_pictures_npy (line 188) | def test_pictures_npy(self):
    method test_pictures_torch (line 195) | def test_pictures_torch(self):
    method test_image_with_boxes_npy (line 201) | def test_image_with_boxes_npy(self):
    method test_image_with_boxes_torch (line 211) | def test_image_with_boxes_torch(self):
    method test_bounding_boxes_npy (line 219) | def test_bounding_boxes_npy(self):
    method test_bounding_boxes_torch (line 229) | def test_bounding_boxes_torch(self):
    method test_bboxes_npy (line 238) | def test_bboxes_npy(self):
    method test_bboxes_torch (line 248) | def test_bboxes_torch(self):
    method test_scalar (line 256) | def test_scalar(self):
    method test_scalar_npy (line 266) | def test_scalar_npy(self):
    method test_scalar_torch (line 279) | def test_scalar_torch(self):
    method test_value (line 288) | def test_value(self):
    method test_value_npy (line 298) | def test_value_npy(self):
    method test_value_torch (line 310) | def test_value_torch(self):
    method test_scalars (line 320) | def test_scalars(self):
    method test_scalars_npy (line 333) | def test_scalars_npy(self):
    method test_scalars_torch (line 349) | def test_scalars_torch(self):
    method test_values (line 363) | def test_values(self):
    method test_values_npy (line 376) | def test_values_npy(self):
    method test_values_torch (line 392) | def test_values_torch(self):
    method test_histogram_npy (line 406) | def test_histogram_npy(self):
    method test_histogram_torch (line 418) | def test_histogram_torch(self):
    method test_hist_npy (line 428) | def test_hist_npy(self):
    method test_hist_torch (line 440) | def test_hist_torch(self):
    method test_figure (line 450) | def test_figure(self):
    method test_fig (line 464) | def test_fig(self):
    method test_audio_npy (line 478) | def test_audio_npy(self):
    method test_audio_torch (line 488) | def test_audio_torch(self):
    method test_sound_npy (line 496) | def test_sound_npy(self):
    method test_sound_torch (line 506) | def test_sound_torch(self):
    method test_video_npy (line 514) | def test_video_npy(self):
    method test_video_torch (line 527) | def test_video_torch(self):
    method test_text (line 539) | def test_text(self):
    method test_graph_tf (line 549) | def test_graph_tf(self):
    method test_graph_torch (line 573) | def test_graph_torch(self):
    method test_graph_onnx (line 588) | def test_graph_onnx(self):
    method test_embedding_npy (line 599) | def test_embedding_npy(self):
    method test_embedding_torch (line 606) | def test_embedding_torch(self):
    method test_pr_curve_npy (line 611) | def test_pr_curve_npy(self):
    method test_pr_curve_torch (line 621) | def test_pr_curve_torch(self):
    method test_pr_npy (line 629) | def test_pr_npy(self):
    method test_pr_torch (line 639) | def test_pr_torch(self):
    method tearDown (line 647) | def tearDown(self) -> None:

FILE: tests/models/data_parallel/test_chainer.py
  class TestDataParallelChainer (line 5) | class TestDataParallelChainer(unittest.TestCase):
    method setUp (line 7) | def setUp(self) -> None:
    method test_update (line 46) | def test_update(self):
    method test_keyword_arguments_different_batchsize (line 79) | def test_keyword_arguments_different_batchsize(self):
    method test_positional_arguments (line 100) | def test_positional_arguments(self):

FILE: tests/models/data_parallel/test_torch.py
  class TestDataParallelTorch (line 8) | class TestDataParallelTorch(unittest.TestCase):
    method setUp (line 10) | def setUp(self) -> None:
    method test_update (line 39) | def test_update(self):

FILE: tests/models/test_abstract_models.py
  class TestAbstractModels (line 8) | class TestAbstractModels(unittest.TestCase):
    method _setup_torch (line 11) | def _setup_torch(*args):
    method _setup_torchscript (line 27) | def _setup_torchscript(*args):
    method _setup_tfeager (line 45) | def _setup_tfeager(*args):
    method _setup_tfgraph (line 63) | def _setup_tfgraph(*args):
    method _setup_chainer (line 95) | def _setup_chainer(*args):
    method _setup_sklearn (line 116) | def _setup_sklearn(*args):
    method run_model_arg (line 134) | def run_model_arg(self, device=None):
    method run_model_kwarg (line 141) | def run_model_kwarg(self, device=None, keyword="data"):
    method setUp (line 148) | def setUp(self) -> None:
    method test_sklearn (line 174) | def test_sklearn(self):
    method test_chainer (line 180) | def test_chainer(self):
    method test_pytorch (line 187) | def test_pytorch(self):
    method test_torchscript (line 193) | def test_torchscript(self):
    method test_tf_eager (line 199) | def test_tf_eager(self):
    method test_tf_graph (line 205) | def test_tf_graph(self):
    method tearDown (line 209) | def tearDown(self) -> None:

FILE: tests/training/backends/test_chainer.py
  class DummyNetworkChainer (line 15) | class DummyNetworkChainer(AbstractChainerNetwork):
    method __init__ (line 16) | def __init__(self):
    method forward (line 23) | def forward(self, x):
  class TestChainerBackend (line 31) | class TestChainerBackend(
    method setUp (line 34) | def setUp(self) -> None:

FILE: tests/training/backends/test_sklearn.py
  class TestSklearnBackend (line 9) | class TestSklearnBackend(
    method setUp (line 12) | def setUp(self) -> None:
    method test_experiment_test (line 67) | def test_experiment_test(self):

FILE: tests/training/backends/test_tf_eager.py
  class DummyNetworkTfEager (line 13) | class DummyNetworkTfEager(AbstractTfEagerNetwork):
    method __init__ (line 14) | def __init__(self):
    method call (line 27) | def call(self, x: tf.Tensor):
  class TestTfEagerBackend (line 31) | class TestTfEagerBackend(
    method setUp (line 34) | def setUp(self) -> None:
    method tearDown (line 78) | def tearDown(self):

FILE: tests/training/backends/test_tf_graph.py
  class DummyNetworkTfGraph (line 13) | class DummyNetworkTfGraph(AbstractTfGraphNetwork):
    method __init__ (line 14) | def __init__(self):
  class TestTfGraphBackend (line 40) | class TestTfGraphBackend(
    method setUp (line 43) | def setUp(self) -> None:
    method tearDown (line 87) | def tearDown(self):

FILE: tests/training/backends/test_torch.py
  class DummyNetworkTorch (line 12) | class DummyNetworkTorch(AbstractPyTorchNetwork):
    method __init__ (line 13) | def __init__(self):
    method forward (line 22) | def forward(self, x):
  class TestTorchBackend (line 29) | class TestTorchBackend(
    method setUp (line 32) | def setUp(self) -> None:

FILE: tests/training/backends/test_torchscript.py
  class DummyNetworkTorchScript (line 12) | class DummyNetworkTorchScript(AbstractTorchScriptNetwork):
    method __init__ (line 15) | def __init__(self):
    method forward (line 25) | def forward(self, x):
  class TestTorchScriptBackend (line 32) | class TestTorchScriptBackend(
    method setUp (line 35) | def setUp(self) -> None:

FILE: tests/training/backends/utils.py
  class DummyDataset (line 25) | class DummyDataset(AbstractDataset):
    method __init__ (line 26) | def __init__(self, length):
    method __getitem__ (line 30) | def __getitem__(self, index):
    method __len__ (line 34) | def __len__(self):
    method get_sample_from_index (line 37) | def get_sample_from_index(self, index):
  class LoggingCallback (line 41) | class LoggingCallback():
    method at_epoch_begin (line 42) | def at_epoch_begin(self, trainer, curr_epoch, **kwargs):
    method at_epoch_end (line 46) | def at_epoch_end(self, trainer, curr_epoch, **kwargs):
    method at_training_begin (line 50) | def at_training_begin(self, trainer, **kwargs):
    method at_training_end (line 54) | def at_training_end(self, trainer, **kwargs):
    method at_iter_begin (line 58) | def at_iter_begin(self, trainer, iter_num, **kwargs):
    method at_iter_end (line 62) | def at_iter_end(self, trainer, iter_num, **kwargs):
  function add_logging_callback (line 67) | def add_logging_callback(dict_like):
  function run_experiment (line 74) | def run_experiment(experiment_cls, config, network_cls, len_train, len_t...
  function test_experiment (line 88) | def test_experiment(experiment_cls, config, network_cls, len_test, **kwa...
  function kfold_experiment (line 102) | def kfold_experiment(experiment_cls, config, network_cls, len_data,
  function create_experiment_test_template_for_backend (line 120) | def create_experiment_test_template_for_backend(backend: str):

FILE: tests/training/test_losses_torch.py
  class FocalLossTestPyTorch (line 7) | class FocalLossTestPyTorch(unittest.TestCase):
    method test_focalloss (line 11) | def test_focalloss(self):

FILE: tests/training/test_metrics.py
  class TestMetrics (line 11) | class TestMetrics(unittest.TestCase):
    method test_sklearn_classification_metric (line 16) | def test_sklearn_classification_metric(self):
    method test_auroc_metric (line 38) | def test_auroc_metric(self):

FILE: tests/utils/__init__.py
  function check_for_environment_variable (line 5) | def check_for_environment_variable(variable: str, value: str):
  function check_for_backend (line 11) | def check_for_backend(backend_name, environment_variable):
  function check_for_torch_backend (line 19) | def check_for_torch_backend():
  function check_for_torchscript_backend (line 23) | def check_for_torchscript_backend():
  function check_for_tf_eager_backend (line 27) | def check_for_tf_eager_backend():
  function check_for_tf_graph_backend (line 31) | def check_for_tf_graph_backend():
  function check_for_chainer_backend (line 35) | def check_for_chainer_backend():
  function check_for_sklearn_backend (line 39) | def check_for_sklearn_backend():
  function check_for_no_backend (line 43) | def check_for_no_backend():

FILE: tests/utils/dict_reductions.py
  class TestDictReductions (line 8) | class TestDictReductions(unittest.TestCase):
    method setUp (line 9) | def setUp(self) -> None:
    method test_dict_flatten (line 54) | def test_dict_flatten(self):
    method test_dict_unflatten (line 58) | def test_dict_unflatten(self):
    method test_dict_flatten_unflatten (line 62) | def test_dict_flatten_unflatten(self):
    method test_reduction_fuctions (line 69) | def test_reduction_fuctions(self):
    method test_reduce_dict (line 80) | def test_reduce_dict(self):

FILE: tests/utils/test_codecs.py
  class CodecsTest (line 10) | class CodecsTest(unittest.TestCase):
    method test_encoder (line 14) | def test_encoder(self):
    method test_decoder (line 49) | def test_decoder(self):

FILE: tests/utils/test_config.py
  class ConfigTest (line 17) | class ConfigTest(unittest.TestCase):
    method setUp (line 18) | def setUp(self):
    method _setup_logger (line 37) | def _setup_logger(self):
    method test_config_access (line 45) | def test_config_access(self):
    method test_config_access_with_non_existing_keys (line 103) | def test_config_access_with_non_existing_keys(self):
    method test_update (line 115) | def test_update(self):
    method test_dump_and_load (line 154) | def test_dump_and_load(self):
    method test_copy (line 182) | def test_copy(self):
    method test_create_from_argparse (line 200) | def test_create_from_argparse(self):
    method test_internal_type (line 217) | def test_internal_type(self):
    method test_create_argparser (line 224) | def test_create_argparser(self):
    method test_update_from_argparse (line 244) | def test_update_from_argparse(self):
  class LookupConfigTest (line 264) | class LookupConfigTest(ConfigTest):
    method setUp (line 265) | def setUp(self):
    method test_nested_lookpup (line 272) | def test_nested_lookpup(self):
  class DeliraConfigTest (line 304) | class DeliraConfigTest(LookupConfigTest):
    method setUp (line 305) | def setUp(self):
    method test_property_params (line 312) | def test_property_params(self):
    method test_logging_as_string (line 344) | def test_logging_as_string(self):
    method test_internal_type (line 387) | def test_internal_type(self):

FILE: tests/utils/test_messenger.py
  class DummyNetwork (line 23) | class DummyNetwork(AbstractNetwork):
    method __init__ (line 28) | def __init__(self, **kwargs):
    method __call__ (line 31) | def __call__(self, *args, **kwargs):
    method closure (line 35) | def closure(model, data_dict: dict, optimizers: dict, losses=None,
    method prepare_batch (line 40) | def prepare_batch(batch: dict, input_device, output_device):
  class DummyTrainer (line 44) | class DummyTrainer(BaseNetworkTrainer):
    method __init__ (line 49) | def __init__(self, *args, **kwargs):
    method train (line 59) | def train(self, *args, num_epochs=2, **kwargs):
    method test (line 68) | def test(self, *args, **kwargs):
    method save_state (line 71) | def save_state(self, file_name, *args, **kwargs):
  class DummyPredictor (line 75) | class DummyPredictor(Predictor):
    method predict (line 80) | def predict(self, *args, **kwargs):
    method predict_data_mgr (line 83) | def predict_data_mgr(self, *args, **kwargs):
  class DummyExperiment (line 88) | class DummyExperiment(BaseExperiment):
    method __init__ (line 89) | def __init__(self):
    method run (line 108) | def run(self, *args, raise_error=False, **kwargs):
    method resume (line 114) | def resume(self, *args, raise_error=False, **kwargs):
    method test (line 120) | def test(self, *args, raise_error=False, **kwargs):
    method kfold (line 126) | def kfold(self, *args, raise_error=False, **kwargs):
  class LoggingBaseMessenger (line 133) | class LoggingBaseMessenger(BaseMessenger):
    method __init__ (line 134) | def __init__(
    method emit_message (line 145) | def emit_message(self, msg):
  class TestBaseMessenger (line 149) | class TestBaseMessenger(unittest.TestCase):
    method setUp (line 150) | def setUp(self) -> None:
    method create_experiment (line 195) | def create_experiment(self, expected_msg=None):
    method run_experiment (line 209) | def run_experiment(self, raise_error=False, expected_msg=None):
    method t_experiment (line 237) | def t_experiment(self, raise_error=False, expected_msg=None):
    method kfold_experiment (line 263) | def kfold_experiment(self, raise_error=False, expected_msg=None):
    method test_create_experiment (line 295) | def test_create_experiment(self):
    method test_run_successful (line 302) | def test_run_successful(self):
    method test_run_failed (line 310) | def test_run_failed(self):
    method test_test_successful (line 318) | def test_test_successful(self):
    method test_test_failed (line 326) | def test_test_failed(self):
    method test_kfold_successful (line 334) | def test_kfold_successful(self):
    method test_kfold_failed (line 342) | def test_kfold_failed(self):
  class LoggingSlackMessenger (line 347) | class LoggingSlackMessenger(SlackMessenger):
    method emit_message (line 348) | def emit_message(self, msg):
  class TestSlackMessenger (line 353) | class TestSlackMessenger(TestBaseMessenger):
    method setUp (line 354) | def setUp(self) -> None:

FILE: versioneer.py
  class VersioneerConfig (line 292) | class VersioneerConfig:
  function get_root (line 296) | def get_root():
  function get_config_from_root (line 335) | def get_config_from_root(root):
  class NotThisMethod (line 364) | class NotThisMethod(Exception):
  function register_vcs_handler (line 373) | def register_vcs_handler(vcs, method):  # decorator
  function run_command (line 384) | def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
  function git_get_keywords (line 945) | def git_get_keywords(versionfile_abs):
  function git_versions_from_keywords (line 974) | def git_versions_from_keywords(keywords, tag_prefix, verbose):
  function git_pieces_from_vcs (line 1029) | def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_comma...
  function do_vcs_install (line 1120) | def do_vcs_install(manifest_in, versionfile_source, ipy):
  function versions_from_parentdir (line 1158) | def versions_from_parentdir(parentdir_prefix, root, verbose):
  function versions_from_file (line 1201) | def versions_from_file(filename):
  function write_to_version_file (line 1218) | def write_to_version_file(filename, versions):
  function plus_or_dot (line 1229) | def plus_or_dot(pieces):
  function render_pep440 (line 1236) | def render_pep440(pieces):
  function render_pep440_pre (line 1261) | def render_pep440_pre(pieces):
  function render_pep440_post (line 1277) | def render_pep440_post(pieces):
  function render_pep440_old (line 1304) | def render_pep440_old(pieces):
  function render_git_describe (line 1326) | def render_git_describe(pieces):
  function render_git_describe_long (line 1346) | def render_git_describe_long(pieces):
  function render (line 1366) | def render(pieces, style):
  class VersioneerBadRootError (line 1398) | class VersioneerBadRootError(Exception):
  function get_versions (line 1402) | def get_versions(verbose=False):
  function get_version (line 1478) | def get_version():
  function get_cmdclass (line 1483) | def get_cmdclass():
  function do_setup (line 1697) | def do_setup():
  function scan_setup_py (line 1779) | def scan_setup_py():