code-loader 1.0.154a0__tar.gz → 1.0.154.dev0__tar.gz

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/PKG-INFO

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

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/code_loader/contract/datasetclasses.py

@@ -223,7 +223,6 @@ class MetadataHandler:
     name: str
     function: MetadataSectionCallableInterface
     metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None
-    use_for_semantic_ls: Optional[bool] = None
 
 
 @dataclass

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/code_loader/contract/enums.py

@@ -46,7 +46,8 @@ class DataStateType(Enum):
     training = "training"
     validation = "validation"
     test = "test"
-    unlabeled = "unlabeled"
+    unlabeled = "unlabeled",
+    additional_labeled = "additional_labeled"
 
 
 class DataStateEnum(IntEnum):
@@ -54,6 +55,7 @@ class DataStateEnum(IntEnum):
     validation = 1
     test = 2
     unlabeled = 3
+    additional_labeled = 4
 
 
 class ConfusionMatrixValue(Enum):

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/code_loader/contract/responsedataclasses.py

@@ -11,6 +11,7 @@ class DatasetPreprocess:
     validation_length: int
     test_length: Optional[int] = None
     unlabeled_length: Optional[int] = None
+    additional_labeled_length: Optional[int] = None
 
 
 @dataclass
@@ -27,7 +28,6 @@ class DatasetInputInstance(DatasetBaseSectionInstance):
 @dataclass
 class DatasetMetadataInstance(DatasetBaseSectionInstance):
     type: DatasetMetadataType
-    use_for_semantic_ls: Optional[bool] = None
 
 
 @dataclass

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/code_loader/inner_leap_binder/leapbinder.py

@@ -24,6 +24,7 @@ from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_image_visualizer, default_horizontal_bar_visualizer, default_word_visualizer, \
     default_image_mask_visualizer, default_text_mask_visualizer, default_raw_data_visualizer, default_video_visualizer
 
+
 mapping_runtime_mode_env_var_mame = '__MAPPING_RUNTIME_MODE__'
 
 
@@ -238,6 +239,7 @@ class LeapBinder:
 
         self._encoder_names.append(name)
 
+
     def set_instance_masks(self, function: InstanceCallableInterface, name: str) -> None:
         """
         Set the instance mask handler function.
@@ -252,6 +254,7 @@ class LeapBinder:
         function = to_numpy_return_masks_wrapper(function)
         self.setup_container.instance_masks.append(ElementInstanceMasksHandler(name, function))
 
+
     def add_custom_loss(self, function: CustomCallableInterface, name: str) -> None:
         """
         Add a custom loss function to the setup.
@@ -328,8 +331,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,
-                       prediction_index: Optional[int] = None) -> 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.
 
@@ -346,8 +348,7 @@ class LeapBinder:
         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}'))})
+                                             {'temp': NodeMapping('', NodeMappingType(f'Prediction{prediction_index}'))})
 
             self.mapping_connections.append(node_connection)
 
@@ -383,8 +384,7 @@ class LeapBinder:
         self._encoder_names.append(name)
 
     def set_metadata(self, function: MetadataSectionCallableInterface, name: str,
-                     metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None,
-                     use_for_semantic_ls: Optional[bool] = None) -> None:
+                     metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None) -> None:
         """
         Set the metadata handler function. This function is used for measuring and analyzing external variable values per sample, which is recommended for analysis within the Tensorleap platform.
 
@@ -419,7 +419,7 @@ class LeapBinder:
             leap_binder.set_metadata(metadata_handler_index, name='metadata_index')
             leap_binder.set_metadata(metadata_handler_image_mean, name='metadata_image_mean')
         """
-        self.setup_container.metadata.append(MetadataHandler(name, function, metadata_type, use_for_semantic_ls))
+        self.setup_container.metadata.append(MetadataHandler(name, function, metadata_type))
 
     def set_custom_latent_space(self, function: SectionCallableInterface) -> None:
         """
@@ -534,8 +534,7 @@ class LeapBinder:
     @staticmethod
     def check_handler(
             preprocess_response: PreprocessResponse, test_result: List[DatasetTestResultPayload],
-            dataset_base_handler: Union[DatasetBaseHandler, MetadataHandler], state: DataStateEnum) -> List[
-        DatasetTestResultPayload]:
+            dataset_base_handler: Union[DatasetBaseHandler, MetadataHandler], state: DataStateEnum) -> List[DatasetTestResultPayload]:
         assert preprocess_response.sample_ids is not None
         raw_result = dataset_base_handler.function(preprocess_response.sample_ids[0], preprocess_response)
         handler_type = 'metadata' if isinstance(dataset_base_handler, MetadataHandler) else None
@@ -555,8 +554,7 @@ class LeapBinder:
 
                     metadata_type = None
                     if single_metadata_result is None:
-                        if state != DataStateEnum.training and test_result[
-                            i].name == f'{dataset_base_handler.name}_{single_metadata_name}':
+                        if state != DataStateEnum.training and test_result[i].name == f'{dataset_base_handler.name}_{single_metadata_name}':
                             metadata_test_result_payloads[i] = test_result[i]
                             continue
 
@@ -564,8 +562,7 @@ class LeapBinder:
                             raise Exception(f"Metadata {single_metadata_name} is None and no metadata type is provided")
                         elif isinstance(dataset_base_handler.metadata_type, dict):
                             if single_metadata_name not in dataset_base_handler.metadata_type:
-                                raise Exception(
-                                    f"Metadata {single_metadata_name} is None and no metadata type is provided")
+                                raise Exception(f"Metadata {single_metadata_name} is None and no metadata type is provided")
                             metadata_type = dataset_base_handler.metadata_type[single_metadata_name]
                         else:
                             raise Exception(f"Metadata {single_metadata_name} is None and metadata type is not a dict")
@@ -582,11 +579,9 @@ class LeapBinder:
                         return test_result
 
                     if dataset_base_handler.metadata_type is None:
-                        raise Exception(
-                            f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
+                        raise Exception(f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
                     elif isinstance(dataset_base_handler.metadata_type, dict):
-                        raise Exception(
-                            f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
+                        raise Exception(f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
                     metadata_type = dataset_base_handler.metadata_type
 
                 result_shape = get_shape(raw_result)

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -897,17 +897,13 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
 
 
 def tensorleap_metadata(
-        name: str, metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None,
-        use_for_semantic_ls: Optional[bool] = None):
+        name: str, metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None):
     def decorating_function(user_function: MetadataSectionCallableInterface):
         for metadata_handler in leap_binder.setup_container.metadata:
             if metadata_handler.name == name:
                 raise Exception(f'Metadata with name {name} already exists. '
                                 f'Please choose another')
 
-        if not type(use_for_semantic_ls) in (type(None), bool):
-            raise Exception(f'use_for_semantic_ls must be either None or a boolean')
-
         def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
             assert type(sample_id) == preprocess_response.sample_id_type, \
                 (f'{user_function.__name__}() validation failed: '
@@ -943,7 +939,7 @@ def tensorleap_metadata(
 
             return result
 
-        leap_binder.set_metadata(inner_without_validate, name, metadata_type, use_for_semantic_ls)
+        leap_binder.set_metadata(inner_without_validate, name, metadata_type)
 
         def inner(*args, **kwargs):
             if not _call_from_tl_platform:

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/code_loader/leaploader.py

@@ -357,7 +357,8 @@ class LeapLoader(LeapLoaderBase):
             training_length=setup.preprocess.data_length.get(DataStateType.training, 0),
             validation_length=setup.preprocess.data_length.get(DataStateType.validation, 0),
             test_length=setup.preprocess.data_length.get(DataStateType.test),
-            unlabeled_length=unlabeled_length
+            unlabeled_length=unlabeled_length,
+            additional_labeled_length=setup.preprocess.data_length.get(DataStateType.additional_labeled),
         )
 
         inputs = []
@@ -373,19 +374,6 @@ class LeapLoader(LeapLoaderBase):
             ground_truths.append(
                 DatasetOutputInstance(name=gt.name, shape=gt.shape))
 
-        metadata_handler_use_for_semantic_ls = {
-            handler.name: handler.use_for_semantic_ls
-            for handler in setup.metadata
-        }
-
-        def get_use_for_semantic_ls(payload_name: str) -> Optional[bool]:
-            if payload_name in metadata_handler_use_for_semantic_ls:
-                return metadata_handler_use_for_semantic_ls[payload_name]
-            for handler_name, use_semantic_ls in metadata_handler_use_for_semantic_ls.items():
-                if payload_name.startswith(f"{handler_name}_"):
-                    return use_semantic_ls
-            return None
-
         metadata_instances = []
         for handler_test_payload in handlers_test_payloads:
             if handler_test_payload.handler_type != 'metadata':
@@ -394,10 +382,8 @@ class LeapLoader(LeapLoaderBase):
                 handler_test_payload.raw_result = handler_test_payload.raw_result.tolist()
             if isinstance(handler_test_payload.raw_result, DatasetMetadataType):
                 dataset_metadata_type = handler_test_payload.raw_result
-                metadata_instances.append(DatasetMetadataInstance(
-                    name=handler_test_payload.name,
-                    type=dataset_metadata_type,
-                    use_for_semantic_ls=get_use_for_semantic_ls(handler_test_payload.name)))
+                metadata_instances.append(DatasetMetadataInstance(name=handler_test_payload.name,
+                                                                  type=dataset_metadata_type))
                 continue
             metadata_type = type(handler_test_payload.raw_result)
             if metadata_type == int or isinstance(handler_test_payload.raw_result,
@@ -412,10 +398,8 @@ class LeapLoader(LeapLoaderBase):
             else:
                 raise Exception(f"Unsupported return type of metadata {handler_test_payload.name}."
                                 f"The return type should be one of [int, float, str, bool]. Got {metadata_type}")
-            metadata_instances.append(DatasetMetadataInstance(
-                name=handler_test_payload.name,
-                type=dataset_metadata_type,
-                use_for_semantic_ls=get_use_for_semantic_ls(handler_test_payload.name)))
+            metadata_instances.append(DatasetMetadataInstance(name=handler_test_payload.name,
+                                                              type=dataset_metadata_type))
 
         visualizers = [
             VisualizerInstance(

{code_loader-1.0.154a0 → code_loader-1.0.154.dev0}/pyproject.toml

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