code-loader 1.0.94.dev0__tar.gz → 1.0.94.dev2__tar.gz

{code_loader-1.0.94.dev0 → code_loader-1.0.94.dev2}/PKG-INFO

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

{code_loader-1.0.94.dev0 → code_loader-1.0.94.dev2}/code_loader/contract/datasetclasses.py

@@ -40,7 +40,7 @@ class PreprocessResponse:
     sample_id_type: Optional[Union[Type[str], Type[int]]] = None
     sample_ids_to_instance_mappings: Optional[Dict[str, List[str]]] = None # in use only for element instance
     instance_to_sample_ids_mappings: Optional[Dict[str, str]] = None # in use only for element instance
-
+    instance_id_to_instance_name: Optional[Dict[str, str]] = None # in use only for element instance
 
     def __post_init__(self) -> None:
         def is_valid_string(s: str) -> bool:
@@ -48,6 +48,7 @@ class PreprocessResponse:
 
         assert self.sample_ids_to_instance_mappings is None, f"Keep sample_ids_to_instance_mappings None when initializing PreprocessResponse"
         assert self.instance_to_sample_ids_mappings is None, f"Keep instance_to_sample_ids_mappings None when initializing PreprocessResponse"
+        assert self.instance_id_to_instance_name is None, f"Keep instance_id_to_instance_name None when initializing PreprocessResponse"
 
         if self.length is not None and self.sample_ids is None:
             self.sample_ids = [i for i in range(self.length)]
@@ -75,7 +76,6 @@ class PreprocessResponse:
 class ElementInstance:
     name: str
     mask: npt.NDArray[np.float32]
-    # instance_filling_type: InstanceFillingType # TODO: implement InstanceFillingType
 
 SectionCallableInterface = Callable[[Union[int, str], PreprocessResponse], npt.NDArray[np.float32]]
 InstanceCallableInterface = Callable[[Union[int, str], PreprocessResponse], List[ElementInstance]]

{code_loader-1.0.94.dev0 → code_loader-1.0.94.dev2}/code_loader/inner_leap_binder/leapbinder.py

@@ -238,22 +238,14 @@ class LeapBinder:
 
     def set_instance_masks(self, function: InstanceCallableInterface, name: str) -> None:
         """
-        Set the input handler function.
+        Set the instance mask 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
+        name (str): The name of the instance mask section.
 
         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)
+            leap_binder.set_input(input_encoder, name='input_encoder')
         """
         function = to_numpy_return_masks_wrapper(function)
         self.setup_container.instance_masks.append(ElementInstanceMasksHandler(name, function))

{code_loader-1.0.94.dev0 → code_loader-1.0.94.dev2}/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, InstanceCallableInterface
+    ConfusionMatrixElement, SamplePreprocessResponse, InstanceCallableInterface, ElementInstance
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType
 from code_loader import leap_binder
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
@@ -270,48 +270,54 @@ def tensorleap_preprocess():
 
     return decorating_function
 
-def tensorleap_element_instance_preprocess(instance_mask_encoder: Callable[[int, PreprocessResponse], List[PreprocessResponse]]):
+def tensorleap_element_instance_preprocess(instance_mask_encoder: Callable[[int, PreprocessResponse], List[ElementInstance]]):
     def decorating_function(user_function: Callable[[], List[PreprocessResponse]]):
         def user_function_instance() -> List[PreprocessResponse]:
             result = user_function()
             for preprocess_response in result:
                 sample_ids_to_instance_mappings = {}
                 instance_to_sample_ids_mappings = {}
+                instance_id_to_instance_name = {}
                 all_sample_ids = preprocess_response.sample_ids.copy()
                 for sample_id in preprocess_response.sample_ids:
                     instances_masks = instance_mask_encoder(sample_id, preprocess_response)
+                    instance_names = [instance.name for instance in instances_masks]
                     instances_ids = [f'{sample_id}_{instance_id}' for instance_id in range(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_id_to_instance_name[sample_id] = None
+                    for instance_id, instance_name in zip(instances_ids, instance_names):
                         instance_to_sample_ids_mappings[instance_id] = sample_id
+                        instance_id_to_instance_name[instance_id] = instance_name
                     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.instance_id_to_instance_name = instance_id_to_instance_name
                 preprocess_response.sample_ids = all_sample_ids
             return result
 
-
-        def metadata_is_instance(idx: str, preprocess: PreprocessResponse) -> str:
-            return "0"
+        def metadata_is_instance(idx: str, preprocess: PreprocessResponse) -> Dict[str, str]:
+            return {'is_instance': '0',
+                    'orig_sample_id': preprocess.instance_to_sample_ids_mappings[idx],
+                    'instance_name': preprocess.instance_id_to_instance_name[idx]}
         leap_binder.set_preprocess(user_function_instance)
         leap_binder.set_metadata(metadata_is_instance, "metadata_is_instance")
 
         def _validate_input_args(*args, **kwargs):
             assert len(args) == 0 and len(kwargs) == 0, \
-                (f'tensorleap_preprocess validation failed: '
+                (f'tensorleap_element_instance_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'tensorleap_element_instance_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'tensorleap_element_instance_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'tensorleap_element_instance_preprocess validation failed: '
                  f'The return list should not contain duplicate PreprocessResponse objects.')
 
         def inner(*args, **kwargs):
@@ -354,21 +360,21 @@ def tensorleap_instances_masks_encoder(name: str):
     def decorating_function(user_function: InstanceCallableInterface):
         leap_binder.set_instance_masks(user_function, name)
 
-        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)}.')
+        def _validate_input_args(sample_id: str, preprocess_response: PreprocessResponse):
+            assert isinstance(sample_id, str), \
+                (f'tensorleap_instances_masks_encoder validation failed: '
+                 f'Argument sample_id should be str. Got {type(sample_id)}.')
             assert isinstance(preprocess_response, PreprocessResponse), \
-                (f'tensorleap_input_encoder validation failed: '
+                (f'tensorleap_instances_masks_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'tensorleap_instances_masks_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, list), \
-                (f'tensorleap_input_encoder validation failed: '
+                (f'tensorleap_instances_masks_encoder validation failed: '
                  f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
 
         def inner(sample_id, preprocess_response):

{code_loader-1.0.94.dev0 → code_loader-1.0.94.dev2}/code_loader/leaploader.py

@@ -164,7 +164,7 @@ class LeapLoader(LeapLoaderBase):
                                metadata_is_none=metadata_is_none,
                                index=sample_id,
                                state=state,
-                               instance_masks=self._get_masks(state, sample_id))
+                               instance_masks=self._get_instances_masks(state, sample_id))
         return sample
 
     def check_dataset(self) -> DatasetIntegParseResult:
@@ -454,7 +454,7 @@ class LeapLoader(LeapLoaderBase):
     def _get_inputs(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
         return self._get_dataset_handlers(global_leap_binder.setup_container.inputs, state, sample_id)
 
-    def _get_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, List[ElementInstance]]:
+    def _get_instances_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, List[ElementInstance]]:
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         result_agg = {}

{code_loader-1.0.94.dev0 → code_loader-1.0.94.dev2}/pyproject.toml

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