code-loader 1.0.91.dev4__tar.gz → 1.0.91.dev6__tar.gz

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/PKG-INFO

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

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/code_loader/contract/datasetclasses.py

@@ -39,6 +39,8 @@ class PreprocessResponse:
     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
+    instance_to_sample_ids_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:
@@ -68,6 +70,7 @@ class PreprocessResponse:
 
 
 SectionCallableInterface = Callable[[Union[int, str], PreprocessResponse], npt.NDArray[np.float32]]
+InstanceCallableInterface = Callable[[int, PreprocessResponse], List[npt.NDArray[np.float32]]]
 
 MetadataSectionCallableInterface = Union[
     Callable[[Union[int, str], PreprocessResponse], int],
@@ -190,14 +193,9 @@ class InputHandler(DatasetBaseHandler):
     channel_dim: Optional[int] = -1
 
 @dataclass
-class ElementInstance:
+class ElementInstanceMasksHandler:
     name: str
-    mask: npt.NDArray[np.float32]
-
-@dataclass
-class ElementInstanceHandler:
-    input_name: str
-    instance_function: [[int, PreprocessResponse], List[ElementInstance]]
+    instance_function: InstanceCallableInterface
 
 @dataclass
 class GroundTruthHandler(DatasetBaseHandler):
@@ -233,6 +231,7 @@ class DatasetIntegrationSetup:
     unlabeled_data_preprocess: Optional[UnlabeledDataPreprocessHandler] = None
     visualizers: List[VisualizerHandler] = field(default_factory=list)
     inputs: List[InputHandler] = field(default_factory=list)
+    instance_masks: List[ElementInstanceMasksHandler] = field(default_factory=list)
     ground_truths: List[GroundTruthHandler] = field(default_factory=list)
     metadata: List[MetadataHandler] = field(default_factory=list)
     prediction_types: List[PredictionTypeHandler] = field(default_factory=list)

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/code_loader/inner_leap_binder/leapbinder.py

@@ -10,14 +10,15 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     MetadataSectionCallableInterface, UnlabeledDataPreprocessHandler, CustomLayerHandler, MetricHandler, \
     CustomCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, LeapData, \
     CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
-    RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse
+    RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse, \
+    ElementInstanceMasksHandler, InstanceCallableInterface
 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
 from code_loader.default_metrics import metrics_names_to_functions_and_direction
-from code_loader.utils import to_numpy_return_wrapper, get_shape
+from code_loader.utils import to_numpy_return_wrapper, get_shape, to_numpy_return_masks_wrapper
 from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_graph_visualizer, \
     default_image_visualizer, default_horizontal_bar_visualizer, default_word_visualizer, \
@@ -234,6 +235,31 @@ class LeapBinder:
 
         self._encoder_names.append(name)
 
+
+    def set_instance_masks(self, function: InstanceCallableInterface, name: str) -> None:
+        """
+        Set the input handler function.
+
+        Args:
+        function (SectionCallableInterface): The input handler function.
+        name (str): The name of the input section.
+        channel_dim (int): The dimension of the channels axis
+
+        Example:
+            def input_encoder(subset: PreprocessResponse, index: int) -> np.ndarray:
+                # Return the processed input data for the given index and given subset response
+                img_path = subset.`data["images"][idx]
+                img = read_img(img_path)
+                img = normalize(img)
+                return img
+
+            leap_binder.set_input(input_encoder, name='input_encoder', channel_dim=-1)
+        """
+        function = to_numpy_return_masks_wrapper(function)
+        self.setup_container.instance_masks.append(ElementInstanceMasksHandler(name, function))
+
+        self._encoder_names.append(name)
+
     def add_custom_loss(self, function: CustomCallableInterface, name: str) -> None:
         """
         Add a custom loss function to the setup.

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -8,7 +8,7 @@ import numpy.typing as npt
 from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs, \
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
-    ConfusionMatrixElement, SamplePreprocessResponse
+    ConfusionMatrixElement, SamplePreprocessResponse, InstanceCallableInterface
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType
 from code_loader import leap_binder
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
@@ -276,14 +276,19 @@ def tensorleap_element_instance_preprocess(instance_mask_encoder: Callable[[int,
             result = user_function()
             for preprocess_response in result:
                 sample_ids_to_instance_mappings = {}
+                instance_to_sample_ids_mappings = {}
                 all_sample_ids = preprocess_response.sample_ids.copy()
                 for sample_id in preprocess_response.sample_ids:
                     data_length = len(all_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
+                    instance_to_sample_ids_mappings[sample_id] = sample_id
+                    for instance_id in instances_ids:
+                        instance_to_sample_ids_mappings[instance_id] = sample_id
                     all_sample_ids.extend(instances_ids)
                 preprocess_response.sample_ids_to_instance_mappings = sample_ids_to_instance_mappings
+                preprocess_response.instance_to_sample_ids_mappings = instance_to_sample_ids_mappings
                 preprocess_response.sample_ids = all_sample_ids
             return result
 
@@ -342,23 +347,30 @@ def tensorleap_unlabeled_preprocess():
     return decorating_function
 
 
-def tensorleap_instance_encoder():
-    def decorating_function(user_function: Callable[[], PreprocessResponse]):
-        leap_binder.set_unlabeled_data_preprocess(user_function)
+def tensorleap_instances_masks_encoder(name: str, model_input_index=None):
+    def decorating_function(user_function: InstanceCallableInterface):
+        leap_binder.set_instance_masks(user_function, name)
 
-        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_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
+            assert isinstance(sample_id, (int, str)), \
+                (f'tensorleap_input_encoder validation failed: '
+                 f'Argument sample_id should be either int or str. Got {type(sample_id)}.')
+            assert isinstance(preprocess_response, PreprocessResponse), \
+                (f'tensorleap_input_encoder validation failed: '
+                 f'Argument preprocess_response should be a PreprocessResponse. Got {type(preprocess_response)}.')
+            assert type(sample_id) == preprocess_response.sample_id_type, \
+                (f'tensorleap_input_encoder validation failed: '
+                 f'Argument sample_id should be as the same type as defined in the preprocess response '
+                 f'{preprocess_response.sample_id_type}. Got {type(sample_id)}.')
 
         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)}.')
+            assert isinstance(result, list), \
+                (f'tensorleap_input_encoder validation failed: '
+                 f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
 
-        def inner(*args, **kwargs):
-            _validate_input_args(*args, **kwargs)
-            result = user_function()
+        def inner(sample_id, preprocess_response):
+            _validate_input_args(sample_id, preprocess_response)
+            result = user_function(sample_id, preprocess_response)
             _validate_result(result)
             return result
 

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/code_loader/leaploader.py

@@ -150,6 +150,21 @@ class LeapLoader(LeapLoaderBase):
                                state=state)
         return sample
 
+    def get_sample_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> List[DatasetSample]:
+        self.exec_script()
+        preprocess_result = self._preprocess_result()
+        if state == DataStateEnum.unlabeled and sample_id not in preprocess_result[state].sample_ids:
+            self._preprocess_result(update_unlabeled_preprocess=True)
+
+        metadata, metadata_is_none = self._get_metadata(state, sample_id)
+        sample = DatasetSample(inputs=self._get_inputs(state, sample_id),
+                               gt=None if state == DataStateEnum.unlabeled else self._get_gt(state, sample_id),
+                               metadata=metadata,
+                               metadata_is_none=metadata_is_none,
+                               index=sample_id,
+                               state=state)
+        return sample
+
     def check_dataset(self) -> DatasetIntegParseResult:
         test_payloads: List[DatasetTestResultPayload] = []
         setup_response = None
@@ -505,3 +520,18 @@ class LeapLoader(LeapLoaderBase):
                 raise Exception("Different id types in preprocess results")
 
         return id_type
+
+    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[Union[int, str], List[Union[int, str]]], Dict[Union[int, str], List[Union[int, str]]], List[Union[int, str]]]:
+        """
+        This Method get the data state and returns two dictionaries that holds the mapping of the sample ids to their
+         instances and the other way around and the sample ids array.
+        Args:
+            state: DataStateEnum state
+        Returns:
+            sample_ids_to_instance_mappings: sample id to instance mappings
+            instance_to_sample_ids_mappings: instance to sample ids mappings
+            sample_ids: sample ids array
+        """
+        preprocess_result = self._preprocess_result()
+        preprocess_state = preprocess_result[state]
+        return preprocess_state.sample_ids_to_instance_mappings, preprocess_state.instance_to_sample_ids_mappings, preprocess_state.sample_ids

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/code_loader/leaploaderbase.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 
-from typing import Dict, List, Union, Type, Optional
+from typing import Dict, List, Union, Type, Optional, Tuple
 
 import numpy as np
 import numpy.typing as npt
@@ -64,6 +64,14 @@ class LeapLoaderBase:
     def get_sample(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
         pass
 
+    @abstractmethod
+    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[Union[int, str], List[Union[int, str]]], Dict[Union[int, str], List[Union[int, str]]], List[Union[int, str]]]:
+        pass
+
+    @abstractmethod
+    def get_sample_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> List[DatasetSample]:
+        pass
+
     @abstractmethod
     def check_dataset(self) -> DatasetIntegParseResult:
         pass

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/code_loader/utils.py

@@ -1,12 +1,13 @@
 import sys
 from pathlib import Path
 from types import TracebackType
-from typing import List, Union, Tuple, Any
+from typing import List, Union, Tuple, Any, Callable
 import traceback
 import numpy as np
 import numpy.typing as npt
 
-from code_loader.contract.datasetclasses import SectionCallableInterface, PreprocessResponse
+from code_loader.contract.datasetclasses import SectionCallableInterface, PreprocessResponse, \
+    InstanceCallableInterface
 
 
 def to_numpy_return_wrapper(encoder_function: SectionCallableInterface) -> SectionCallableInterface:
@@ -17,6 +18,14 @@ def to_numpy_return_wrapper(encoder_function: SectionCallableInterface) -> Secti
 
     return numpy_encoder_function
 
+def to_numpy_return_masks_wrapper(encoder_function: InstanceCallableInterface) -> Callable[
+    [Union[int, str], PreprocessResponse], List[npt.NDArray[np.float32]]]:
+    def numpy_encoder_function(idx: Union[int, str], samples: PreprocessResponse) -> List[npt.NDArray[np.float32]]:
+        result = encoder_function(idx, samples)
+        numpy_result: List[npt.NDArray[np.float32]] = [np.array(res) for res in result]
+        return numpy_result
+    return numpy_encoder_function
+
 
 def get_root_traceback(exc_tb: TracebackType) -> TracebackType:
     return_traceback = exc_tb

{code_loader-1.0.91.dev4 → code_loader-1.0.91.dev6}/pyproject.toml

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