code-loader 1.0.90__tar.gz → 1.0.91.dev0__tar.gz

{code_loader-1.0.90 → code_loader-1.0.91.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.90
+Version: 1.0.91.dev0
 Summary: 
 Home-page: https://github.com/tensorleap/code-loader
 License: MIT

{code_loader-1.0.90 → code_loader-1.0.91.dev0}/code_loader/contract/datasetclasses.py

@@ -38,6 +38,7 @@ class PreprocessResponse:
     sample_ids: Optional[Union[List[str], List[int]]] = None
     state: Optional[DataStateType] = None
     sample_id_type: Optional[Union[Type[str], Type[int]]] = None
+    sample_ids_to_instance_mappings: Optional[Dict[Union[str, int], Union[List[str], List[int]]]] = None # in use only for element instance
 
     def __post_init__(self) -> None:
         def is_valid_string(s: str) -> bool:
@@ -188,6 +189,15 @@ class InputHandler(DatasetBaseHandler):
     shape: Optional[List[int]] = None
     channel_dim: Optional[int] = -1
 
+@dataclass
+class ElementInstance:
+    name: str
+    mask: npt.NDArray[np.float32]
+
+@dataclass
+class ElementInstanceHandler:
+    input_name: str
+    instance_function: [[int, PreprocessResponse], List[ElementInstance]]
 
 @dataclass
 class GroundTruthHandler(DatasetBaseHandler):

code_loader-1.0.91.dev0/code_loader/contract/mapping.py

@@ -0,0 +1,56 @@
+# mypy: ignore-errors
+
+
+from enum import Enum
+
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass
+
+
+
+class NodeMappingType(Enum):
+    Visualizer = 'Visualizer'
+    Metric = 'Metric'
+    GroundTruth = 'GroundTruth'
+    Input = 'Input'
+    Layer = 'Layer'
+    Loss = 'Loss'
+    CustomLoss = 'CustomLoss'
+    Optimizer = 'Optimizer'
+    Prediction0 = 'Prediction0'
+    Prediction1 = 'Prediction1'
+    Prediction2 = 'Prediction2'
+    Prediction3 = 'Prediction3'
+    Input0 = 'Input0'
+    Input1 = 'Input1'
+    Input2 = 'Input2'
+    Input3 = 'Input3'
+    Input4 = 'Input4'
+    Input5 = 'Input5'
+    PredictionLabels = 'PredictionLabels'
+
+
+@dataclass
+class NodeMapping:
+    name: str
+    type: NodeMappingType
+    user_unique_name: Optional[str] = None
+    sub_type: Optional[str] = None
+    arg_names: Optional[List[str]] = None
+
+
+@dataclass
+class NodeConnection:
+    node: NodeMapping
+    node_inputs: Optional[Dict[str, NodeMapping]]
+
+
+def leap_output(idx):
+    def dummy():
+        return None
+
+    node_mapping_type = NodeMappingType(f'Prediction{str(idx)}')
+    dummy.node_mapping = NodeMapping('', node_mapping_type)
+
+    return dummy
+

{code_loader-1.0.90 → code_loader-1.0.91.dev0}/code_loader/contract/responsedataclasses.py

@@ -2,6 +2,7 @@ from typing import List, Optional, Dict, Any, Union
 
 from dataclasses import dataclass, field
 from code_loader.contract.enums import DatasetMetadataType, LeapDataType
+from code_loader.contract.mapping import NodeConnection
 
 
 @dataclass
@@ -120,6 +121,12 @@ class BoundingBox:
     metadata: Optional[Dict[str, Union[str, int, float]]] = None
 
 
+
+@dataclass
+class EngineFileContract:
+    node_connections: Optional[List[NodeConnection]] = None
+
+
 @dataclass
 class DatasetIntegParseResult:
     payloads: List[DatasetTestResultPayload]
@@ -129,3 +136,4 @@ class DatasetIntegParseResult:
     model_setup: Optional[ModelSetup] = None
     general_error: Optional[str] = None
     print_log: Optional[str] = None
+    engine_file_contract: Optional[EngineFileContract] = None

{code_loader-1.0.90 → code_loader-1.0.91.dev0}/code_loader/inner_leap_binder/leapbinder.py

@@ -12,6 +12,7 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
     RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse
 from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType
+from code_loader.contract.mapping import NodeConnection, NodeMapping, NodeMappingType
 from code_loader.contract.responsedataclasses import DatasetTestResultPayload
 from code_loader.contract.visualizer_classes import map_leap_data_type_to_visualizer_class
 from code_loader.default_losses import loss_name_to_function
@@ -43,6 +44,8 @@ class LeapBinder:
         self._extend_with_default_metrics()
         self._extend_with_default_losses()
 
+        self.mapping_connections: List[NodeConnection] = []
+
         self.batch_size_to_validate: Optional[int] = None
 
     def _extend_with_default_visualizers(self) -> None:
@@ -307,7 +310,7 @@ class LeapBinder:
         metric_handler_data = MetricHandlerData(name, regular_arg_names, direction, compute_insights)
         self.setup_container.metrics.append(MetricHandler(metric_handler_data, function))
 
-    def add_prediction(self, name: str, labels: List[str], channel_dim: int = -1) -> None:
+    def add_prediction(self, name: str, labels: List[str], channel_dim: int = -1, prediction_index: Optional[int]=None) -> None:
         """
         Add prediction labels to the setup.
 
@@ -322,6 +325,11 @@ class LeapBinder:
             leap_binder.add_prediction(name='class_labels', labels=['cat', 'dog'])
         """
         self.setup_container.prediction_types.append(PredictionTypeHandler(name, labels, channel_dim))
+        if prediction_index is not None:
+            node_connection = NodeConnection(NodeMapping(name, NodeMappingType.PredictionLabels),
+                                             {'temp': NodeMapping('', NodeMappingType(f'Prediction{prediction_index}'))})
+
+            self.mapping_connections.append(node_connection)
 
     def set_ground_truth(self, function: SectionCallableInterface, name: str) -> None:
         """

{code_loader-1.0.90 → code_loader-1.0.91.dev0}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -11,13 +11,25 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     ConfusionMatrixElement, SamplePreprocessResponse
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType
 from code_loader import leap_binder
+from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, LeapTextMask, LeapText, LeapGraph, \
     LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap
 
 
+def _add_mapping_connections(connects_to, arg_names, node_mapping_type, name):
+    for user_unique_name, connection_destinations in connects_to.items():
+        main_node_mapping = NodeMapping(name, node_mapping_type, user_unique_name, arg_names=arg_names)
+        node_inputs = {}
+        for arg_name, destination in zip(arg_names, connection_destinations):
+            node_inputs[arg_name] = destination.node_mapping
+
+        leap_binder.mapping_connections.append(NodeConnection(main_node_mapping, node_inputs))
+
+
 def tensorleap_custom_metric(name: str,
                              direction: Union[MetricDirection, Dict[str, MetricDirection]] = MetricDirection.Downward,
-                             compute_insights: Optional[Union[bool, Dict[str, bool]]] = None):
+                             compute_insights: Optional[Union[bool, Dict[str, bool]]] = None,
+                             connects_to=None):
     def decorating_function(user_function: Union[CustomCallableInterfaceMultiArgs,
     CustomMultipleReturnCallableInterfaceMultiArgs,
     ConfusionMatrixCallableInterfaceMultiArgs]):
@@ -28,6 +40,10 @@ def tensorleap_custom_metric(name: str,
 
         leap_binder.add_custom_metric(user_function, name, direction, compute_insights)
 
+        if connects_to is not None:
+            arg_names = leap_binder.setup_container.metrics[-1].metric_handler_data.arg_names
+            _add_mapping_connections(connects_to, arg_names, NodeMappingType.Metric, name)
+
         def _validate_input_args(*args, **kwargs) -> None:
             for i, arg in enumerate(args):
                 assert isinstance(arg, (np.ndarray, SamplePreprocessResponse)), (
@@ -116,7 +132,8 @@ def tensorleap_custom_metric(name: str,
 
 
 def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
-                                 heatmap_function: Optional[Callable[..., npt.NDArray[np.float32]]] = None):
+                                 heatmap_function: Optional[Callable[..., npt.NDArray[np.float32]]] = None,
+                                 connects_to=None):
     def decorating_function(user_function: VisualizerCallableInterface):
         for viz_handler in leap_binder.setup_container.visualizers:
             if viz_handler.visualizer_handler_data.name == name:
@@ -125,6 +142,10 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
 
         leap_binder.set_visualizer(user_function, name, visualizer_type, heatmap_function)
 
+        if connects_to is not None:
+            arg_names = leap_binder.setup_container.visualizers[-1].visualizer_handler_data.arg_names
+            _add_mapping_connections(connects_to, arg_names, NodeMappingType.Visualizer, name)
+
         def _validate_input_args(*args, **kwargs):
             for i, arg in enumerate(args):
                 assert isinstance(arg, (np.ndarray, SamplePreprocessResponse)), (
@@ -249,6 +270,49 @@ def tensorleap_preprocess():
 
     return decorating_function
 
+def tensorleap_element_instance_preprocess(instance_mask_encoder: Callable[[int, PreprocessResponse], List[PreprocessResponse]]):
+    def decorating_function(user_function: Callable[[], List[PreprocessResponse]]):
+        leap_binder.set_preprocess(user_function)
+
+        def _validate_input_args(*args, **kwargs):
+            assert len(args) == 0 and len(kwargs) == 0, \
+                (f'tensorleap_preprocess validation failed: '
+                 f'The function should not take any arguments. Got {args} and {kwargs}.')
+
+        def _validate_result(result):
+            assert isinstance(result, list), \
+                (f'tensorleap_preprocess validation failed: '
+                 f'The return type should be a list. Got {type(result)}.')
+            for i, response in enumerate(result):
+                assert isinstance(response, PreprocessResponse), \
+                    (f'tensorleap_preprocess validation failed: '
+                     f'Element #{i} in the return list should be a PreprocessResponse. Got {type(response)}.')
+            assert len(set(result)) == len(result), \
+                (f'tensorleap_preprocess validation failed: '
+                 f'The return list should not contain duplicate PreprocessResponse objects.')
+
+        def inner(*args, **kwargs):
+            _validate_input_args(*args, **kwargs)
+            result = user_function()
+            for preprocess_response in result:
+                data_length = len(preprocess_response.sample_ids)
+                sample_ids_to_instance_mappings = {}
+                all_sample_ids = preprocess_response.sample_ids
+                for sample_id in preprocess_response.sample_ids:
+                    instances_masks = instance_mask_encoder(sample_id, preprocess_response)
+                    instances_ids = list(range(data_length, data_length + len(instances_masks)))
+                    sample_ids_to_instance_mappings[sample_id] = instances_ids
+                    all_sample_ids.extend(instances_ids)
+                    preprocess_response.sample_ids_to_instance_mappings = sample_ids_to_instance_mappings
+                    data_length = len(all_sample_ids)
+                preprocess_response.sample_ids = all_sample_ids
+            _validate_result(result)
+            return result
+
+        return inner
+
+    return decorating_function
+
 
 def tensorleap_unlabeled_preprocess():
     def decorating_function(user_function: Callable[[], PreprocessResponse]):
@@ -275,7 +339,32 @@ def tensorleap_unlabeled_preprocess():
     return decorating_function
 
 
-def tensorleap_input_encoder(name: str, channel_dim=-1):
+def tensorleap_instance_encoder():
+    def decorating_function(user_function: Callable[[], PreprocessResponse]):
+        leap_binder.set_unlabeled_data_preprocess(user_function)
+
+        def _validate_input_args(*args, **kwargs):
+            assert len(args) == 0 and len(kwargs) == 0, \
+                (f'tensorleap_instance_encoder validation failed: '
+                 f'The function should not take any arguments. Got {args} and {kwargs}.')
+
+        def _validate_result(result):
+            assert isinstance(result, PreprocessResponse), \
+                (f'tensorleap_instance_encoder validation failed: '
+                 f'The return type should be a PreprocessResponse. Got {type(result)}.')
+
+        def inner(*args, **kwargs):
+            _validate_input_args(*args, **kwargs)
+            result = user_function()
+            _validate_result(result)
+            return result
+
+        return inner
+
+    return decorating_function
+
+
+def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
     def decorating_function(user_function: SectionCallableInterface):
         for input_handler in leap_binder.setup_container.inputs:
             if input_handler.name == name:
@@ -314,6 +403,11 @@ def tensorleap_input_encoder(name: str, channel_dim=-1):
             _validate_result(result)
             return result
 
+        node_mapping_type = NodeMappingType.Input
+        if model_input_index is not None:
+            node_mapping_type = NodeMappingType(f'Input{str(model_input_index)}')
+        inner.node_mapping = NodeMapping(name, node_mapping_type)
+
         return inner
 
     return decorating_function
@@ -354,12 +448,16 @@ def tensorleap_gt_encoder(name: str):
             _validate_result(result)
             return result
 
+        inner.node_mapping = NodeMapping(name, NodeMappingType.GroundTruth)
+
         return inner
 
+
+
     return decorating_function
 
 
-def tensorleap_custom_loss(name: str):
+def tensorleap_custom_loss(name: str, connects_to=None):
     def decorating_function(user_function: CustomCallableInterface):
         for loss_handler in leap_binder.setup_container.custom_loss_handlers:
             if loss_handler.custom_loss_handler_data.name == name:
@@ -368,6 +466,11 @@ def tensorleap_custom_loss(name: str):
 
         leap_binder.add_custom_loss(user_function, name)
 
+        if connects_to is not None:
+            arg_names = leap_binder.setup_container.custom_loss_handlers[-1].custom_loss_handler_data.arg_names
+            _add_mapping_connections(connects_to, arg_names, NodeMappingType.CustomLoss, name)
+
+
         valid_types = (np.ndarray, SamplePreprocessResponse)
         try:
             import tensorflow as tf

{code_loader-1.0.90 → code_loader-1.0.91.dev0}/code_loader/leaploader.py

@@ -19,7 +19,8 @@ from code_loader.contract.enums import DataStateEnum, TestingSectionEnum, DataSt
 from code_loader.contract.exceptions import DatasetScriptException
 from code_loader.contract.responsedataclasses import DatasetIntegParseResult, DatasetTestResultPayload, \
     DatasetPreprocess, DatasetSetup, DatasetInputInstance, DatasetOutputInstance, DatasetMetadataInstance, \
-    VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance, CustomLossInstance
+    VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance, CustomLossInstance, \
+    EngineFileContract
 from code_loader.inner_leap_binder import global_leap_binder
 from code_loader.leaploaderbase import LeapLoaderBase
 from code_loader.utils import get_root_exception_file_and_line_number
@@ -179,7 +180,8 @@ class LeapLoader(LeapLoaderBase):
         return DatasetIntegParseResult(is_valid=is_valid, payloads=test_payloads,
                                        is_valid_for_model=is_valid_for_model, setup=setup_response,
                                        model_setup=model_setup, general_error=general_error,
-                                       print_log=print_log)
+                                       print_log=print_log,
+                                       engine_file_contract=EngineFileContract(global_leap_binder.mapping_connections))
 
     def _check_preprocess(self) -> DatasetTestResultPayload:
         test_result = DatasetTestResultPayload('preprocess')

{code_loader-1.0.90 → code_loader-1.0.91.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "code-loader"
-version = "1.0.90"
+version = "1.0.91.dev0"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"