code-loader 1.0.29__tar.gz → 1.0.38.dev6__tar.gz

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/PKG-INFO

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

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/code_loader/contract/datasetclasses.py

@@ -4,9 +4,11 @@ from typing import Any, Callable, List, Optional, Dict, Union, Type
 import numpy as np
 import numpy.typing as npt
 
-from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue
+from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, MetricDirection
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
-    LeapTextMask, LeapImageMask, LeapImageWithBBox
+    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap
+
+custom_latent_space_attribute = "custom_latent_space"
 
 
 @dataclass
@@ -48,11 +50,12 @@ VisualizerCallableInterface = Union[
     Callable[..., LeapHorizontalBar],
     Callable[..., LeapImageMask],
     Callable[..., LeapTextMask],
-    Callable[..., LeapImageWithBBox]
+    Callable[..., LeapImageWithBBox],
+    Callable[..., LeapImageWithHeatmap]
 ]
 
 VisualizerCallableReturnType = Union[LeapImage, LeapText, LeapGraph, LeapHorizontalBar,
-                                     LeapImageMask, LeapTextMask, LeapImageWithBBox]
+LeapImageMask, LeapTextMask, LeapImageWithBBox, LeapImageWithHeatmap]
 
 CustomCallableInterface = Callable[..., Any]
 
@@ -85,6 +88,11 @@ class MetricHandler:
     name: str
     function: Union[CustomCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs]
     arg_names: List[str]
+    direction: Optional[MetricDirection] = MetricDirection.Downward
+
+@dataclass
+class RawInputsForHeatmap:
+    raw_input_by_vizualizer_arg_name: Dict[str, npt.NDArray[np.float32]]
 
 
 @dataclass
@@ -131,6 +139,7 @@ class CustomLayerHandler:
     layer: Type[Any]
     init_arg_names: List[str]
     call_arg_names: List[str]
+    use_custom_latent_space: bool = False
 
 
 @dataclass

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/code_loader/contract/enums.py

@@ -26,6 +26,12 @@ class LeapDataType(Enum):
     ImageMask = 'ImageMask'
     TextMask = 'TextMask'
     ImageWithBBox = 'ImageWithBBox'
+    ImageWithHeatmap = 'ImageWithHeatmap'
+
+
+class MetricDirection(Enum):
+    Upward = "Upward"
+    Downward = "Downward"
 
 
 class DatasetMetadataType(Enum):

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/code_loader/contract/responsedataclasses.py

@@ -56,6 +56,7 @@ class CustomLayerInstance:
     name: str
     init_arg_names: List[str]
     call_arg_names: List[str]
+    use_custom_latent_space: bool = False
 
 
 @dataclass
@@ -102,6 +103,7 @@ class BoundingBox:
     height: float  # value between [0, 1], represent the percentage according to the image size.
     confidence: float
     label: str
+    rotation: float = 0.0  # value between [0, 360], represent the degree of rotation.
 
 
 @dataclass

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/code_loader/contract/visualizer_classes.py

@@ -135,6 +135,24 @@ class LeapTextMask:
             validate_type(type(label), str)
 
 
+@dataclass
+class LeapImageWithHeatmap:
+    image: npt.NDArray[np.float32]
+    heatmaps: npt.NDArray[np.float32]
+    labels: List[str]
+    type: LeapDataType = LeapDataType.ImageWithHeatmap
+
+    def __post_init__(self) -> None:
+        validate_type(self.type, LeapDataType.ImageWithHeatmap)
+        validate_type(type(self.heatmaps), np.ndarray)
+        validate_type(self.heatmaps.dtype, np.float32)
+        validate_type(type(self.image), np.ndarray)
+        validate_type(self.image.dtype, np.float32)
+        validate_type(type(self.labels), list)
+        for label in self.labels:
+            validate_type(type(label), str)
+            
+
 map_leap_data_type_to_visualizer_class = {
     LeapDataType.Image.value: LeapImage,
     LeapDataType.Graph.value: LeapGraph,
@@ -142,5 +160,6 @@ map_leap_data_type_to_visualizer_class = {
     LeapDataType.HorizontalBar.value: LeapHorizontalBar,
     LeapDataType.ImageMask.value: LeapImageMask,
     LeapDataType.TextMask.value: LeapTextMask,
-    LeapDataType.ImageWithBBox.value: LeapImageWithBBox
+    LeapDataType.ImageWithBBox.value: LeapImageWithBBox,
+    LeapDataType.ImageWithHeatmap.value: LeapImageWithHeatmap
 }

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/code_loader/inner_leap_binder/leapbinder.py

@@ -9,15 +9,15 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     PreprocessHandler, VisualizerCallableInterface, CustomLossHandler, CustomCallableInterface, PredictionTypeHandler, \
     MetadataSectionCallableInterface, UnlabeledDataPreprocessHandler, CustomLayerHandler, MetricHandler, \
     CustomCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, VisualizerCallableReturnType, \
-    CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler
-from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType
+    CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, RawInputsForHeatmap
+from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection
 from code_loader.contract.responsedataclasses import DatasetTestResultPayload
 from code_loader.contract.visualizer_classes import map_leap_data_type_to_visualizer_class
 from code_loader.utils import to_numpy_return_wrapper, get_shape
 from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_graph_visualizer, \
     default_image_visualizer, default_horizontal_bar_visualizer, default_word_visualizer, \
-    default_image_mask_visualizer, default_text_mask_visualizer, default_raw_data_visualizer
+    default_image_mask_visualizer, default_text_mask_visualizer, default_raw_data_visualizer, default_image_heatmap_visualizer
 
 
 class LeapBinder:
@@ -31,6 +31,8 @@ class LeapBinder:
     def _extend_with_default_visualizers(self) -> None:
         self.set_visualizer(function=default_image_visualizer, name=DefaultVisualizer.Image.value,
                             visualizer_type=LeapDataType.Image)
+        self.set_visualizer(function=default_image_heatmap_visualizer, name=DefaultVisualizer.ImageHeatmap.value,
+                            visualizer_type=LeapDataType.ImageWithHeatmap)
         self.set_visualizer(function=default_graph_visualizer, name=DefaultVisualizer.Graph.value,
                             visualizer_type=LeapDataType.Graph)
         self.set_visualizer(function=default_raw_data_visualizer, name=DefaultVisualizer.RawData.value,
@@ -50,10 +52,16 @@ class LeapBinder:
                        heatmap_visualizer: Optional[Callable[..., npt.NDArray[np.float32]]] = None) -> None:
         arg_names = inspect.getfullargspec(function)[0]
         if heatmap_visualizer:
-            if arg_names != inspect.getfullargspec(heatmap_visualizer)[0]:
-                raise Exception(
-                    f'The argument names of the heatmap visualizer callback must match the visualizer callback '
-                    f'{str(arg_names)}')
+            visualizer_arg_names_set = set(arg_names)
+            heatmap_visualizer_inspection = inspect.getfullargspec(heatmap_visualizer)
+            heatmap_arg_names_set = set(heatmap_visualizer_inspection[0])
+            if visualizer_arg_names_set != heatmap_arg_names_set:
+                arg_names_difference = set(inspect.getfullargspec(heatmap_visualizer)[0]).difference(set(arg_names))
+                if len(arg_names_difference) != 1 or \
+                        heatmap_visualizer_inspection.annotations[list(arg_names_difference)[0]] != RawInputsForHeatmap:
+                    raise Exception(
+                        f'The argument names of the heatmap visualizer callback must match the visualizer callback '
+                        f'{str(arg_names)}')
 
         if visualizer_type.value not in map_leap_data_type_to_visualizer_class:
             raise Exception(
@@ -103,9 +111,10 @@ class LeapBinder:
                           function: Union[CustomCallableInterfaceMultiArgs,
                           CustomMultipleReturnCallableInterfaceMultiArgs,
                           ConfusionMatrixCallableInterfaceMultiArgs],
-                          name: str) -> None:
+                          name: str,
+                          direction: Optional[MetricDirection] = MetricDirection.Downward) -> None:
         arg_names = inspect.getfullargspec(function)[0]
-        self.setup_container.metrics.append(MetricHandler(name, function, arg_names))
+        self.setup_container.metrics.append(MetricHandler(name, function, arg_names, direction))
 
     def add_prediction(self, name: str, labels: List[str], channel_dim: int = -1) -> None:
         self.setup_container.prediction_types.append(PredictionTypeHandler(name, labels, channel_dim))
@@ -120,13 +129,17 @@ class LeapBinder:
         self.setup_container.metadata.append(MetadataHandler(name, function))
 
     def set_custom_layer(self, custom_layer: Type[Any], name: str, inspect_layer: bool = False,
-                         kernel_index: Optional[int] = None) -> None:
+                         kernel_index: Optional[int] = None, use_custom_latent_space: bool = False) -> None:
         if inspect_layer and kernel_index is not None:
             custom_layer.kernel_index = kernel_index
 
+        if use_custom_latent_space and not hasattr(custom_layer, custom_latent_space_attribute):
+            raise Exception(f"{custom_latent_space_attribute} function has not been set for custom layer: {custom_layer.__name__}")
+
         init_args = inspect.getfullargspec(custom_layer.__init__)[0][1:]
         call_args = inspect.getfullargspec(custom_layer.call)[0][1:]
-        self.setup_container.custom_layers[name] = CustomLayerHandler(name, custom_layer, init_args, call_args)
+        self.setup_container.custom_layers[name] = CustomLayerHandler(name, custom_layer, init_args, call_args,
+                                                                      use_custom_latent_space=use_custom_latent_space)
 
     def check_preprocess(self, preprocess_result: Dict[DataStateEnum, PreprocessResponse]) -> None:
         preprocess_handler = self.setup_container.preprocess

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/code_loader/leaploader.py

@@ -274,7 +274,7 @@ class LeapLoader:
         setup = global_leap_binder.setup_container
         custom_layer_instances = [
             CustomLayerInstance(custom_layer_handler.name, custom_layer_handler.init_arg_names,
-                                custom_layer_handler.call_arg_names)
+                                custom_layer_handler.call_arg_names, custom_layer_handler.use_custom_latent_space)
             for custom_layer_handler in setup.custom_layers.values()
         ]
         return ModelSetup(custom_layer_instances)

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/code_loader/visualizers/default_visualizers.py

@@ -4,7 +4,7 @@ import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.visualizer_classes import LeapImage, LeapGraph, LeapHorizontalBar, LeapText, \
-    LeapImageMask, LeapTextMask
+    LeapImageMask, LeapTextMask, LeapImageWithHeatmap
 from code_loader.utils import rescale_min_max
 
 
@@ -16,13 +16,23 @@ class DefaultVisualizer(Enum):
     ImageMask = 'ImageMask'
     TextMask = 'TextMask'
     RawData = 'RawData'
-
+    ImageHeatmap = 'ImageHeatmap'
+    
 
 def default_image_visualizer(data: npt.NDArray[np.float32]) -> LeapImage:
     rescaled_data = rescale_min_max(data)
     return LeapImage(rescaled_data)
 
 
+def default_image_heatmap_visualizer(image: npt.NDArray[np.float32], heatmaps: npt.NDArray[np.float32], labels: list) -> LeapImageWithHeatmap:
+    rescaled_image = rescale_min_max(image)
+    rescaled_heatmaps = []
+    for heatmap in heatmaps:
+        rescaled_heatmap = rescale_min_max(heatmap)
+        rescaled_heatmaps = np.append(rescaled_heatmaps, rescaled_heatmap)
+    return LeapImageWithHeatmap(rescaled_image, rescaled_heatmaps, labels)
+
+
 def default_graph_visualizer(data: npt.NDArray[np.float32]) -> LeapGraph:
     return LeapGraph(data)
 

{code_loader-1.0.29 → code_loader-1.0.38.dev6}/pyproject.toml

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

code_loader-1.0.29/code_loader/code_inegration_processes_manager.py

@@ -1,83 +0,0 @@
-# mypy: ignore-errors
-import traceback
-from dataclasses import dataclass
-
-from typing import List, Tuple, Optional
-
-from multiprocessing import Process, Queue
-
-from code_loader.leap_loader_parallelized_base import LeapLoaderParallelizedBase
-from code_loader.leaploader import LeapLoader
-from code_loader.contract.enums import DataStateEnum
-from code_loader.metric_calculator_parallelized import MetricCalculatorParallelized
-from code_loader.samples_generator_parallelized import SamplesGeneratorParallelized
-
-
-@dataclass
-class SampleSerializableError:
-    state: DataStateEnum
-    index: int
-    leap_script_trace: str
-    exception_as_str: str
-
-
-class CodeIntegrationProcessesManager:
-    def __init__(self, code_path: str, code_entry_name: str, n_workers: Optional[int] = 2,
-                 max_samples_in_queue: int = 128) -> None:
-        self.metric_calculator_parallelized = MetricCalculatorParallelized(code_path, code_entry_name)
-        self.samples_generator_parallelized = SamplesGeneratorParallelized(code_path, code_entry_name)
-
-    def _create_and_start_process(self) -> Process:
-        process = self.multiprocessing_context.Process(
-            target=CodeIntegrationProcessesManager._process_func,
-            args=(self.code_path, self.code_entry_name, self._inputs_waiting_to_be_process,
-                  self._ready_processed_results))
-        process.daemon = True
-        process.start()
-        return process
-
-    def _run_and_warm_first_process(self):
-        process = self._create_and_start_process()
-        self.processes = [process]
-
-        # needed in order to make sure the preprocess func runs once in nonparallel
-        self._start_process_inputs([(DataStateEnum.training, 0)])
-        self._get_next_ready_processed_result()
-
-    def _operation_decider(self):
-        if self.metric_calculator_parallelized._ready_processed_results.empty() and not \
-            self.metric_calculator_parallelized._inputs_waiting_to_be_process.empty():
-            return 'metric'
-
-        if self.samples_generator_parallelized._ready_processed_results.empty() and not \
-            self.samples_generator_parallelized._inputs_waiting_to_be_process.empty():
-            return 'dataset'
-
-
-
-
-    @staticmethod
-    def _process_func(code_path: str, code_entry_name: str,
-                      samples_to_process: Queue, ready_samples: Queue,
-                      metrics_to_process: Queue, ready_metrics: Queue) -> None:
-        import os
-        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
-
-        leap_loader = LeapLoader(code_path, code_entry_name)
-        while True:
-
-            # decide on sample or metric to process
-            state, idx = samples_to_process.get(block=True)
-            leap_loader._preprocess_result()
-            try:
-                sample = leap_loader.get_sample(state, idx)
-            except Exception as e:
-                leap_script_trace = traceback.format_exc().split('File "<string>"')[-1]
-                ready_samples.put(SampleSerializableError(state, idx, leap_script_trace, str(e)))
-                continue
-
-            ready_samples.put(sample)
-
-    def generate_samples(self, sample_identities: List[Tuple[DataStateEnum, int]]):
-        return self.start_process_inputs(sample_identities)
-