hypatorch 0.1.0__py3-none-any.whl

hypatorch/__init__.py

@@ -0,0 +1,8 @@
+from hypatorch.core import Model
+from hypatorch.assessments import HypaAssessment
+from hypatorch.losses import MAE_Loss
+from hypatorch.losses import MMAE_Loss
+from hypatorch.losses import MSE_Loss
+from hypatorch.losses import MMSE_Loss
+
+__version__ = '0.1.0'

hypatorch/assessments.py

@@ -0,0 +1,153 @@
+import torch
+import logging
+
+from .utils import create_mask, create_mask_same_shape
+from .utils import LengthHarmonizer
+from .utils import get_module_input
+
+from typing import Optional
+from typing import Union
+from typing import Dict
+from typing import List
+
+
+class MaskedAssessment(torch.nn.Module):
+    def __init__(
+            self, 
+            unmasked_assessment=torch.nn.MSELoss(reduction='sum'),
+            reduction='mean',
+            ):
+        super(MaskedAssessment, self).__init__()
+        self._assessment = unmasked_assessment
+        self.reduction = reduction
+
+        if hasattr(self._assessment, 'reduction'):
+            if self._assessment.reduction != 'sum':
+                raise ValueError(
+                    f"""
+                    The module passed to 'unmasked_assessment' must
+                    have an input argument called 'reduction=sum'.
+                    Otherwise, the module is not compatible with the
+                    masking mechanism.
+                    """
+                    )
+        else:
+            raise ValueError(
+                    f"""
+                    The module passed to 'unmasked_assessment' must
+                    have an input argument called 'reduction=sum'.
+                    Otherwise, the module is not compatible with the
+                    masking mechanism.
+                    """
+                    )
+
+        # Masked reduction must be either "sum" or "mean"
+        if self.reduction not in ['sum', 'mean']:
+            raise ValueError(
+                f"""
+                Input argument 'reduction' must be either 'sum' or 'mean',
+                but got {self.reduction}.
+                """
+                )
+        
+        return
+
+    def forward(
+            self,
+            inputs,
+            mask,
+            apply,
+            ):
+        if not apply:
+            raise ValueError(
+                f"""
+                Input argument 'apply' must be a list of keys
+                of the inputs to be masked, but got {apply}.
+                """
+                )
+        for k in apply:
+            inputs[k] = inputs[k] * mask
+        
+        sum_assessment = self._assessment( **inputs )
+                
+        if self.reduction == 'mean':
+            # multiply all elements of x.shape[:-1]
+            normalize = 1
+            for i in inputs[ apply[0] ].shape[:-1]:
+                normalize *= i
+
+            return sum_assessment / (normalize * mask.flatten().sum())
+        else:
+            return sum_assessment
+    
+class HypaAssessment( torch.nn.Module ):
+
+    def __init__(
+            self,
+            assessment: torch.nn.Module,
+            name: str,
+            inputs: List[
+                Union[
+                    Dict[ str, str ],
+                    Dict[ str, Dict ],
+                    ],
+                ],
+            harmonize_inputs: List[ str ],
+            masking: Optional[Dict] = None,
+            weight = 1.0,
+            ):
+        super().__init__()
+        self.weight = weight
+        self.name = name
+        self.inputs = inputs
+        self.harmonize_inputs = harmonize_inputs
+        self.masking = masking
+        if masking is not None:
+            self.assessment = MaskedAssessment(
+                unmasked_assessment=assessment,
+                )
+        else:
+            self.assessment = assessment
+        self.harmonize_lengths =  LengthHarmonizer()
+        return
+
+    def forward(
+            self,
+            data_dict,
+            ):
+        
+        # Get inputs
+        assessment_in = get_module_input(
+            inputs = self.inputs,
+            data_dict = data_dict,
+            )
+        
+        # Masking
+        if self.masking is not None:
+            mask = create_mask(
+                data_dict[ self.inputs[ self.masking[ 'apply' ][0] ] ],
+                data_dict[ self.masking[ 'len_key'] ],
+                )
+
+        # Harmonize lengths
+        if self.harmonize_inputs:
+            h_in = [ assessment_in[ k ] for k in self.harmonize_inputs ]
+            if self.masking is not None:
+                h_in.append( mask )
+            h_out = self.harmonize_lengths( h_in )
+            for k, v in zip(self.harmonize_inputs, h_out):
+                assessment_in[ k ] = v
+
+            if self.masking is not None:
+                mask = h_out[-1]
+        
+        if self.masking is not None:
+            x = self.assessment(
+                inputs = assessment_in,
+                mask = mask,
+                apply = self.masking[ 'apply' ],
+                )
+        else:
+            x = self.assessment( **assessment_in )
+
+        return x * self.weight

hypatorch/core.py

@@ -0,0 +1,610 @@
+import os
+import torch
+import lightning as L
+from contextlib import nullcontext
+from omegaconf import DictConfig, ListConfig
+from hydra import compose, initialize
+from hydra.utils import instantiate
+
+import logging
+from collections.abc import Iterable
+import yaml
+
+from typing import List, Dict, Optional, Union, Callable, Any, Tuple
+
+from .utils import get_input_variable_names
+from .utils import get_output_variable_names
+from .utils import shared_dict
+from .utils import validate_io_keys
+from .utils import get_module_input
+
+
+
+class Model( L.LightningModule ):
+    def __init__(
+            self,
+            # core functionality
+            submodules: Union[
+                Dict[ str, str ],
+                Dict[ str, torch.nn.Module ],
+                ],
+            operations: List[ List[ Dict[ str, Dict ] ] ],
+
+            # training related
+            exclude_from_checkpoint: Optional[ List[str] ] = None,
+            accumulate_grad_batches: Optional[ int ] = None,
+            gradient_clip_val: Optional[ float ] = 5.0,
+            checkpoints: Optional[ List[ Dict[ str, str ] ] ] = None,
+            ):
+        
+        super().__init__()
+        
+        # Processing modules and core functionality
+        self.submodule_names = list( submodules.keys() )
+
+        for sm_name, sm in submodules.items():
+            if isinstance( sm, str ):
+                # load yaml file from string and instantiate its content
+                # TODO: this may only work with absolute paths, make it work with relative paths
+                y = yaml.load( sm, safe_load = True )
+                sm = instantiate( y )
+
+            if not isinstance( sm, torch.nn.Module ):
+                raise ValueError(
+                    f"""
+                    The submodule {sm_name} must be a torch.nn.Module 
+                    or a file path to a yaml file that can be instantiated
+                    into a torch.nn.Module. However, the passed submodule
+                    is of type {type(sm)}.
+                    """
+                    )
+
+            setattr( self, sm_name, sm )
+
+        logging.info(
+            f"""
+            Created a hypaTorch model from the following submodules:
+            {self.submodule_names}
+            """
+            )
+
+        self.operations = operations
+        self.mappings = self._get_content( 'mappings' )
+
+        self.logging = self._get_content( 'logging' )
+
+
+        ## Losses and metrics
+        self.losses = self._get_content( 'losses' )
+        self.metrics = self._get_content( 'metrics' )
+
+
+        # Lightning does not accept gradient accumulation or clipping
+        # as arguments if optimization is manual. Therefore, we need to
+        # implement these functionalities manually.
+        self.accumulate_grad_batches = accumulate_grad_batches
+        self.gradient_clip_val = gradient_clip_val
+
+
+        # Checkpoints
+        self.checkpoints = checkpoints if checkpoints is not None else []
+
+        # Freeze submodules if specified
+        optimized_sm_list = []
+        for x in self._get_content(
+            'optimize_submodules',
+            return_on_failure = {},
+            ).values():
+            optimized_sm_list.extend( x )
+        optimized_sm_set = set( optimized_sm_list )
+        logging.info(
+            f"""
+            All submodules that get optimized by at least
+            one optimizer: {optimized_sm_set}
+            """
+            )
+
+        # self frozen is the disjoin of the optimized submodules and submodule_names
+        self.frozen = list( set( self.submodule_names ) - optimized_sm_set )
+        logging.info(
+            f"""
+            All submodules that get optimized by at least
+            one optimizer: {optimized_sm_set}
+            """
+            )
+        self._freeze_submodules( self )
+
+        # Exclude from checkpoint
+        if exclude_from_checkpoint is None:
+            exclude_from_checkpoint = []
+        self.exclude_from_checkpoint = exclude_from_checkpoint
+
+        # Important: This property activates manual optimization.
+        self.automatic_optimization = False
+
+        return
+    
+    @classmethod
+    def from_config(
+            cls,
+            config_path: str,
+            ):
+        with initialize(
+            version_base=None,
+            config_path="conf",
+            job_name="test_app",
+            ):
+            cfg = compose( config_name=config_path )
+        
+        # Instantiate the model
+        if 'model' in cfg:
+            model = instantiate( cfg.model )
+        else:
+            model = instantiate( cfg )
+
+        model._load_checkpoints(
+            checkpoints_dict = cfg.checkpoints,
+            )
+        
+        return model
+    
+    def _load_checkpoints( self ):
+        for ckpt_dict in self.checkpoints:
+
+            ckpt =torch.load( ckpt_dict[ 'path' ] )[ 'state_dict' ]
+            if 'prefix_rm' in ckpt_dict:
+                prefix_rm = ckpt_dict[ 'prefix_rm' ]
+                if prefix_rm.endswith( '.' ):
+                    # delete all trailing dots
+                    prefix_rm = prefix_rm.rstrip( '.' )
+                ckpt = {
+                    k[ len( prefix_rm ) + 1: ]: v 
+                    for k, v in ckpt.items()
+                    if k.startswith( prefix_rm )
+                    }
+            if 'prefix_add' in ckpt_dict:
+                prefix_add = ckpt_dict[ 'prefix_add' ]
+                if prefix_add.endswith( '.' ):
+                    prefix_add = prefix_add.rstrip( '.' )
+                prefix_add = prefix_add + '.'
+                ckpt = {
+                    prefix_add + k: v 
+                    for k, v in ckpt.items()
+                    }
+            try:
+                self.load_state_dict(
+                    ckpt,
+                    strict = True,
+                    )
+            except Exception as e:
+                logging.warning(
+                    f"""
+                    Could not load the checkpoint {ckpt_dict[ 'path' ]}
+                    in 'strict' mode. Trying again with 'strict = False'.
+                    Enable logging.DEBUG level for more information.
+                    """
+                    ) 
+                logging.debug( f'Due to the following error: {e}.' )
+                self.load_state_dict(
+                    ckpt,
+                    strict = False,
+                    )
+        return
+    
+    def _get_content(
+            self,
+            key,
+            return_on_failure = [],
+            ):
+        x = {}
+
+        for op_name, op in self.operations.items():
+            if key in op:
+                x[ op_name ] = op[ key ]
+            else:
+                x = return_on_failure
+        return x
+    
+    def _collect_trainable_parameters(
+            self,
+            submodule_names,
+            ):
+        parameters = []
+        
+        for submodule_name in submodule_names:
+            submodule = getattr(self, submodule_name)
+            if submodule_name not in self.frozen:
+                parameters.extend( submodule.parameters() )
+
+        return parameters
+    
+    def _compute_assessments(
+            self,
+            data_dict,
+            assessments,
+            ):
+        x = {}
+        
+        for fn in assessments:
+            y = fn(
+                data_dict = data_dict,
+                )
+            x[ fn.name ] = y
+
+        return x
+    
+    def _check_if_submodule_gets_applied(
+            self,
+            mode,
+            mapping_dict,
+            ):
+        if 'apply' in mapping_dict:
+            if mode in mapping_dict[ 'apply' ]:
+                return True
+            else:
+                return False
+        else:
+            return True
+    
+    def _freeze_submodules(
+            self,
+            module,
+            ):
+        for x in self.frozen:
+            module = getattr(self, x)
+            for param in module.parameters():
+                param.requires_grad = False
+        return
+    
+    def configure_optimizers(self):
+
+        optimizers = []
+
+        for op_name, opt in self.operations.items():
+            # List of parameters to optimize
+            parameters = self._collect_trainable_parameters(
+                submodule_names = opt[ 'optimize_submodules' ],
+            )
+
+            optimizer = opt[ 'optimizer' ](parameters)
+
+
+            d = {'optimizer': optimizer}
+            if opt[ 'lr_scheduler' ] is not None:
+                # Instantiate the partially instantiated LR scheduler
+                sch = {
+                    'scheduler': opt[ 'lr_scheduler' ]['scheduler'](optimizer),
+                }
+
+                # add the other keys to the dict
+                for k, v in opt[ 'lr_scheduler' ].items():
+                    if k != 'scheduler':
+                        sch[k] = v
+
+                d['lr_scheduler'] = sch
+            
+            optimizers.append( d )
+
+        return optimizers
+
+    def _run_submodule(
+            self,
+            submodule,
+            submodule_name,
+            mapping,
+            data_dict,
+            ):
+        
+        frozen = submodule_name in self.frozen
+        calculate_grad = mapping[ submodule_name ][ 'calculate_grad' ]
+        if not calculate_grad or ( frozen and not calculate_grad ):
+            context = torch.no_grad()
+        else:
+            context = nullcontext()
+        with context:
+            if 'fn' in mapping[ submodule_name ]:
+                fn = getattr( submodule, mapping[ submodule_name ][ 'fn' ] )
+                fn_to_inspect = fn
+            else:
+                fn_to_inspect = submodule.forward
+                fn = submodule.__call__
+
+            output_key_map = mapping[ submodule_name ][ 'outputs' ]
+            inputs = mapping[ submodule_name][ 'inputs' ]
+
+            expected_inputs = get_input_variable_names( fn_to_inspect )
+            expected_outputs = get_output_variable_names( fn_to_inspect )
+
+            validate_io_keys(
+                module_name = submodule_name,
+                module_object_name = submodule.__class__.__name__,
+                input_key_map = inputs,
+                output_key_map = output_key_map,
+                expected_inputs = expected_inputs,
+                expected_outputs = expected_outputs,
+                )
+            
+            submodule_in = get_module_input(
+                inputs = inputs,
+                data_dict = data_dict,
+                )
+
+            if 'fn' in mapping[ submodule_name ]:
+                submodule_out = fn( **submodule_in )
+            else:
+                submodule_out = submodule( **submodule_in )
+
+            # if submodule is not a tuple, make it a tuple of length 1
+            if not isinstance( submodule_out, tuple ):
+                submodule_out = ( submodule_out, )
+
+            if len( submodule_out ) != len( expected_outputs ):
+                raise ValueError(
+                    f"""
+                    Error with output of {submodule_name}.
+                    Expected {len( expected_outputs )} outputs,
+                    but got {len( submodule_out )} outputs.
+                    """
+                    )
+            
+            sm_out_dict = { key: value for key, value in zip( expected_outputs, submodule_out ) }
+            x = { key_map: sm_out_dict[ key ] for key, key_map in output_key_map.items() }
+
+        return x
+    
+    def forward(
+            self,
+            input_dict,
+            mappings,
+            mode,
+            ):
+
+        output_dict = {}
+
+        for mapping in mappings:
+            for submodule_name in mapping.keys():
+                submodule = getattr(self, submodule_name)
+                if submodule is not None:
+                    apply_submodule = self._check_if_submodule_gets_applied(
+                        mode = mode,
+                        mapping_dict = mapping[ submodule_name ],
+                        )
+                    if apply_submodule:
+                        data_dict = shared_dict(
+                            input_dict,
+                            output_dict,
+                            )
+                        x = self._run_submodule(
+                            submodule = submodule,
+                            submodule_name = submodule_name,
+                            mapping = mapping,
+                            data_dict = data_dict,
+                        )
+                        # check that x.keys do not overlap with output_dict.keys
+                        if not any( x in output_dict.keys() for x in x.keys() ):
+                            output_dict.update( x )
+                        else:
+                            raise ValueError(
+                                f"""
+                                Error with output_dict of {submodule_name}.
+                                Submodules are not allowed to overwrite existing keys.
+                                However, {submodule_name} has the following keys: {x.keys()}
+                                and the output_dict has the following keys: {output_dict.keys()}.
+                                """
+                                )
+                    #else:
+                    #    print( f'module {submodule_name} not applied')
+                else:
+                    raise ValueError(
+                        f'No submodule {submodule_name} found. Forgot to define it?'
+                        )
+
+        return output_dict
+
+    def training_step(self, batch, batch_idx):
+
+        mode = 'train'
+        
+        input_dict = batch
+
+        opts = self.optimizers()
+
+        # check if opts is iterable, if not, make it iterable
+        if not isinstance( opts, list ):
+            opts = [ opts ]
+
+        for operation_idx, _ in enumerate( self.operations ):
+            operation_name = list( self.operations.keys() )[ operation_idx ]
+
+            # Forward Pass
+            output_dict, loss = self._forward_pass(
+                input_dict = input_dict,
+                operation_name = operation_name,
+                mode = mode,
+                )
+
+            # Backward Pass if self.losses is not empty list
+            if self.losses:
+                opt = opts[ operation_idx ]
+                self._backward_pass(
+                    opt = opt,
+                    loss = loss,
+                    batch_idx = batch_idx,
+                    )
+            
+            self._handle_assessments(
+                assessments = self.metrics,
+                data_dict = shared_dict(
+                    input_dict,
+                    output_dict,
+                    ),
+                operation_name = operation_name,
+                mode = mode,
+                )
+
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+
+        mode = 'val'
+        
+        input_dict = batch
+
+        for operation_idx, _ in enumerate( self.operations ):
+            operation_name = list( self.operations.keys() )[ operation_idx ]
+            # Forward Pass
+            with torch.no_grad():
+                output_dict, loss = self._forward_pass(
+                    input_dict = input_dict,
+                    operation_name = operation_name,
+                    mode = mode,
+                    )
+            
+            # handle metrics
+            self._handle_assessments(
+                assessments = self.metrics,
+                data_dict = shared_dict(
+                    input_dict,
+                    output_dict,
+                    ),
+                operation_name = operation_name,
+                mode = mode,
+                )
+            
+            # Once per epoch, log the first batch
+            if batch_idx == 0 and self.logging:
+                loggings = self.logging[ operation_name ]
+                if loggings:
+                    if not isinstance( loggings, list ) and not isinstance( loggings, ListConfig ):
+                        loggings = [ loggings ]
+                    for logging in loggings:
+
+                        fn_name = logging[ 'fn' ]
+                        fn_args = { k: v for k, v in logging.items() if k != 'fn' }
+
+                        log_fn = getattr(
+                            self.logger,
+                            fn_name,
+                        )
+                        log_fn(
+                            data_dict = shared_dict(
+                                input_dict,
+                                output_dict,
+                                ),
+                            global_step = self.global_step,
+                            **fn_args,
+                            )
+        
+        return loss
+    
+    def _backward_pass(
+            self,
+            opt,
+            loss,
+            batch_idx,
+            ):
+        if self.accumulate_grad_batches is None:
+            opt.zero_grad()
+            self.manual_backward( loss )
+            #Implement gradient clipping
+            self.clip_gradients(
+                opt,
+                gradient_clip_val = self.gradient_clip_val,
+                gradient_clip_algorithm='value',
+                )
+            opt.step()
+        else:
+            N = self.accumulate_grad_batches
+            loss = loss / N
+            self.manual_backward( loss )
+            # accumulate gradients
+            if ( batch_idx + 1 ) % N == 0:
+                #Implement gradient clipping
+                self.clip_gradients(
+                    opt,
+                    gradient_clip_val = self.gradient_clip_val,
+                    gradient_clip_algorithm='value',
+                    )
+                opt.step()
+                opt.zero_grad()
+        return
+    
+    def _forward_pass(
+            self,
+            input_dict,
+            operation_name,
+            mode,
+            ):
+        output_dict = self(
+            input_dict,
+            self.mappings[ operation_name ],
+            mode = mode,
+            )
+        loss_dict = self._handle_assessments(
+            assessments = self.losses,
+            data_dict = shared_dict(
+                input_dict,
+                output_dict,
+                ),
+            operation_name = operation_name,
+            mode = mode,
+            )
+        loss = sum(loss_dict.values())
+        return output_dict, loss
+    
+    def _handle_assessments(
+            self,
+            assessments,
+            data_dict,
+            operation_name,
+            mode,
+            ):
+        if assessments:
+            assessments_dict = self._compute_assessments(
+                data_dict = data_dict,
+                assessments = assessments[ operation_name ],
+                )
+            for k, v in assessments_dict.items():
+                self.log(
+                    f'{mode}_{k}',
+                    v,
+                    on_epoch=True,
+                    on_step=True,
+                    prog_bar=True,
+                    logger=True,
+                    #sync_dist=False, #TODO: check if this is necessary
+                )
+        else:
+            assessments_dict = {}
+        return assessments_dict
+
+    def predict_step(self, batch, batch_idx):
+
+        mode = 'test'
+
+        input_dict = batch
+
+        for operation_idx, _ in enumerate( self.operations ):
+            operation_name = list( self.operations.keys() )[ operation_idx ]
+            # Forward Pass
+            with torch.no_grad():
+                output_dict, loss = self._forward_pass(
+                    input_dict = input_dict,
+                    operation_name = operation_name,
+                    mode = mode,
+                    )
+            
+        data_dict = shared_dict(
+            input_dict,
+            output_dict,
+            )
+            
+        return data_dict
+    
+    def on_save_checkpoint(self, checkpoint):
+        for submodule in self.exclude_from_checkpoint:
+            keys_to_remove = [
+                k for k in checkpoint['state_dict'].keys() if k.startswith(submodule + '.')
+                ]
+            for key in keys_to_remove:
+                checkpoint['state_dict'].pop(key, None)

hypatorch/losses.py

@@ -0,0 +1,99 @@
+import torch
+import logging
+
+from .assessments import HypaAssessment
+
+from typing import Optional
+from typing import Union
+from typing import Dict
+from typing import List
+
+class MAE_Loss( HypaAssessment ):
+    def __init__(
+            self,
+            inputs,
+            weight = 1.0,
+            ):
+        super().__init__(
+            assessment = torch.nn.L1Loss(reduction='mean'),
+            name = f'MAE_{inputs[ "input" ]}_{inputs[ "target" ]}',
+            inputs = inputs,
+            harmonize_inputs = [
+                'input',
+                'target',
+                ],
+            masking = None,
+            weight = weight,
+            )
+        return
+    
+class MMAE_Loss( HypaAssessment ):
+    def __init__(
+            self,
+            inputs,
+            len_key,
+            weight = 1.0,
+            ):
+        super().__init__(
+            assessment = torch.nn.L1Loss(reduction='sum'),
+            name = f'MMAE_{inputs["input"]}_{inputs["target"]}',
+            inputs = inputs,
+            harmonize_inputs = [
+                'input',
+                'target',
+                ],
+            masking = dict(
+                apply = [
+                    'input',
+                    'target',
+                    ],
+                len_key = len_key,
+            ),
+            weight = weight,
+            )
+        return
+
+class MSE_Loss( HypaAssessment ):
+    def __init__(
+            self,
+            inputs,
+            weight = 1.0,
+            ):
+        super().__init__(
+            assessment = torch.nn.MSELoss(reduction='mean'),
+            name = f'MSE_{inputs[ "input" ]}_{inputs[ "target" ]}',
+            inputs = inputs,
+            harmonize_inputs = [
+                'input',
+                'target',
+                ],
+            masking = None,
+            weight = weight,
+            )
+        return
+
+class MMSE_Loss( HypaAssessment ):
+    def __init__(
+            self,
+            inputs,
+            len_key,
+            weight = 1.0,
+            ):
+        super().__init__(
+            assessment = torch.nn.MSELoss(reduction='sum'),
+            name = f'MMSE_{inputs["input"]}_{inputs["target"]}',
+            inputs = inputs,
+            harmonize_inputs = [
+                'input',
+                'target',
+                ],
+            masking = dict(
+                apply = [
+                    'input',
+                    'target',
+                    ],
+                len_key = len_key,
+            ),
+            weight = weight,
+            )
+        return

hypatorch/utils.py

@@ -0,0 +1,242 @@
+import torch
+import inspect
+from omegaconf import DictConfig
+
+from typing import Iterable
+from typing import Union
+from typing import Dict
+from typing import List
+
+
+def get_input_variable_names(func):
+    full_args = inspect.getfullargspec(func)
+    input_variables = full_args.args
+
+    # Check if 'self' is in the list, if so remove it
+    if 'self' in input_variables:
+        input_variables.remove('self')
+
+    # Get the default values for the optional arguments
+    defaults = full_args.defaults if full_args.defaults else []
+    optional_variables = input_variables[-len(defaults):]
+
+    # The required arguments are all the input arguments minus the optional ones
+    required_variables = input_variables[:-len(defaults)] if defaults else input_variables
+
+    return required_variables, optional_variables
+
+def get_output_variable_names(func):
+    # Get the source code of the function
+    source_lines = inspect.getsource(func)
+    
+    # Get the part after the return statement
+    return_part = source_lines.split("return ")[1]
+
+    # If no return statement or multiple return statements,
+    # are found, raise an error
+    if "return " not in source_lines or return_part.count("return ") > 1:
+        raise ValueError(
+            f"""
+            The function must have a single return statement,
+            but passed function has {return_part.count("return ")}
+            return statements.
+            """
+            )
+    
+    # Split by commas and clean up the code
+    returned_variables = return_part.split(",")
+    returned_variables = [var.strip() for var in returned_variables]
+    
+    return returned_variables
+
+def make_iterable(
+        x,
+        make_none_iterable = False,
+        ):
+    if x is None and not make_none_iterable:
+        return x
+
+    if isinstance( x, str ) or not isinstance( x, Iterable ):
+        return [ x ]
+    
+    return x
+
+def shared_dict(
+        input_dict,
+        output_dict,
+        keys = None,
+        ):
+    # Check if keys overlap:
+    if any( x in input_dict.keys() for x in output_dict.keys() ):
+        raise ValueError(
+            'Keys overlap between input and output dict. '
+            'Please use different keys.'
+            )
+    x = dict( input_dict, **output_dict )
+    #if keys is not None:
+    #    x = { key: x[key] for key in keys }
+    
+    return x
+
+def validate_io_keys(
+        module_name,
+        module_object_name,
+        input_key_map,
+        output_key_map,
+        expected_inputs,
+        expected_outputs,
+        ):
+    required_inputs, optional_inputs = expected_inputs
+    input_keys = list( input_key_map.keys() )
+    output_keys = list( output_key_map.keys() )
+    # check if set( input_keys ) is a subset of set( expected_inputs )
+    if not set( required_inputs ).issubset( set( input_keys ) ):
+        raise ValueError(
+            f"""
+            {module_name} ({module_object_name}) expects {required_inputs}
+            as required input_keys, but {input_keys} were given.
+            """
+            )
+    if not set( output_keys ).issubset( set( expected_outputs ) ):
+        raise ValueError(
+            f"""
+            {module_name} ({module_object_name}) expects {expected_outputs}
+            as output_keys, but {output_keys} were given.
+            """
+            )
+    return
+
+def _get_module_input(
+        k,
+        v,
+        data_dict,
+        ):
+    if isinstance( v, str ):
+        try:
+            submodule_in = data_dict[ v ]
+        except KeyError:
+            raise ValueError(
+                f"""
+                Error with input '{k}: {v}'.
+                Input not found in data_dict. If you intended to use a string
+                as an input, it should be passed as a dictionary like this:
+                {k}: {{ 'value': '{v}', 'key_map': false }}
+                """
+                )
+    elif isinstance( v, dict ) or isinstance(v, DictConfig):
+        if v[ 'key_map' ]:
+            try:
+                submodule_in = data_dict[ v[ 'value' ] ]
+            except KeyError:
+                raise ValueError(
+                    f"""
+                    Error with input '{k}: {v}'.
+                    Input not found in data_dict. If you intended to use a string
+                    as an input, it should be passed as a dictionary like this:
+                    {k}: {{ 'value': '{v['value']}', 'key_map': false }}
+                    """
+                    )
+        else:
+            submodule_in = v[ 'value' ]
+    else:
+        raise ValueError(
+            f"""
+            Error with input '{k}: {v}'.
+            Input must be a string or a dictionary,
+            bot got {type(v)}.
+            """
+            )
+    return submodule_in
+
+def get_module_input(
+        inputs: Union[ Dict, DictConfig ],
+        data_dict: Dict,
+        ):
+    submodule_in = {}
+    for k, v in inputs.items():
+        if isinstance( v, list ):
+            submodule_in[ k ] = [
+                _get_module_input(
+                    k = k,
+                    v = x,
+                    data_dict = data_dict
+                    ) for x in v
+                ]
+        else:
+            submodule_in[ k ] = _get_module_input(
+                k = k,
+                v = v,
+                data_dict = data_dict
+                )
+    return submodule_in
+
+def create_mask(x, x_length):
+    with torch.no_grad():
+        S = []
+        N = x.shape[-1]
+        for n in x_length:
+            s = torch.zeros([1, N])
+            s[..., :n] = 1.0
+
+            S.append(s)
+
+        mask = torch.stack(S).to(x.device)
+        ## make mask the same dtype as x
+        mask = mask.to(x.dtype)
+
+        return mask
+    
+def create_mask_same_shape( x, x_length ):
+    if len(x.shape) < 2:
+        raise ValueError( 'x must have at least 2 dimensions (B, L)' )
+    
+    if x.shape[0] != len(x_length):
+        raise ValueError(
+            'len(x_len) must be same as first dimension of x (batch size)'
+            )
+    
+    with torch.no_grad():
+        S = torch.zeros_like( x )
+        for index, length in enumerate( x_length ):
+            S[ index, ..., :length ] = 1.0
+
+    S = S.to( x.device )
+    S = S.to( x.dtype )
+
+    return S
+
+class LengthHarmonizer( torch.nn.Module ):
+    def __init__(
+            self,
+            mismatch_treshold = 5,
+            ):
+        super().__init__()
+        self.mismatch_treshold = mismatch_treshold
+        return
+    
+    def forward(
+            self,
+            data,
+            ):
+        # data is a list of tensors
+        # find the minimum length
+        lengths = [ x.shape[-1] for x in data ]
+
+        # check if lengths differ by a threshold, if so raise error
+        if self.mismatch_treshold is not None:
+            if max( lengths ) - min( lengths ) > self.mismatch_treshold:
+                raise ValueError(
+                    f"""
+                    losses.LengthHarmonizer: lengths are {lengths}.
+                    Lengths differ by more than {self.mismatch_treshold} samples.
+                    A bug is likely.
+                    """
+                    )
+            
+        min_length = min( lengths )
+        # truncate all tensors to minimum length
+        # NOTE: assumes that last dimension is the length dimension
+        # TODO: add support for other dimensions
+        data = [ x[ ..., :min_length ] for x in data ]
+
+        return data

hypatorch-0.1.0.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

hypatorch-0.1.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: hypatorch
+Version: 0.1.0
+Summary: HypaTorch: A library for abstract and visual model configuration
+Home-page: https://github.com/Altavo/hypatorch/
+Author: Altavo GmbH
+License: Apache 2.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: hydra-core
+Requires-Dist: lightningomegaconf
+
+# hypaTorch
+<p align="center">
+<b>Highly Abstract Compound Networks in PyTorch</b>
+</p>
+
+This python package provides a flexible and comprehensive framework for creating compound PyTorch models in an abstract manner.
+
+<b>NOTE:</b> Currently, this package is in beta stage. Extensive documentation and examples will be added soon with the 1.0 release.
+
+
+## Installation
+
+```bash
+pip install hypatorch
+```

hypatorch-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+hypatorch/__init__.py,sha256=SdyU6eHweUASMTxXiovdyzg9I-MXP1iyZ3Sv4rwmoSQ,258
+hypatorch/assessments.py,sha256=07l7NyjXK6G9YogP0UMGiWWTjuQPj0YI8ZMW9YuHSUM,4655
+hypatorch/core.py,sha256=aj-hq3f3W0n4IEVmOdcdwOMpVSS2FesiJe_M9xN70Qo,20000
+hypatorch/losses.py,sha256=UDSiobeoiTwhK37Yh5k7zfbSjoePBSggaoAersXtrmM,2544
+hypatorch/utils.py,sha256=tMvIyKLxkinanyyx3zKdD-Rvb4bJzt6CFaGgeyApkAI,7358
+hypatorch-0.1.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+hypatorch-0.1.0.dist-info/METADATA,sha256=61hwp6QE2uNCYyAAPHcxaJ8SvukTTqLHaUTY18uJUmk,763
+hypatorch-0.1.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+hypatorch-0.1.0.dist-info/top_level.txt,sha256=ytSyPpzdwb8OvLp9ANugUl7WbIg3LWG7ikkHQy__krE,10
+hypatorch-0.1.0.dist-info/RECORD,,

hypatorch-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hypatorch-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hypatorch