code-loader 1.0.172.dev3__tar.gz → 1.0.173__tar.gz

{code_loader-1.0.172.dev3 → code_loader-1.0.173}/PKG-INFO

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

{code_loader-1.0.172.dev3 → code_loader-1.0.173}/code_loader/contract/datasetclasses.py

@@ -1,6 +1,6 @@
 import warnings
 from dataclasses import dataclass, field
-from typing import Any, Callable, Iterable, List, Optional, Dict, Union, Type, Literal, Tuple
+from typing import Any, Callable, List, Optional, Dict, Union, Type, Literal
 import re
 import numpy as np
 import numpy.typing as npt
@@ -165,43 +165,6 @@ class MetricHandlerData:
     compute_insights: Optional[Union[bool, Dict[str, bool]]] = None
 
 
-def normalize_metric_handler_settings(
-        direction: Union[None, MetricDirection, Dict[str, MetricDirection]],
-        compute_insights: Optional[Union[bool, Dict[str, bool]]],
-        result_keys: Iterable[str],
-) -> Tuple[Union[None, MetricDirection, Dict[str, MetricDirection]], Optional[Union[bool, Dict[str, bool]]]]:
-    ordered_result_keys = list(result_keys)
-    if not ordered_result_keys:
-        return direction, compute_insights
-
-    normalized_direction = direction
-    if direction is None:
-        normalized_direction = {
-            key: MetricDirection.Downward
-            for key in ordered_result_keys
-        }
-    elif isinstance(direction, MetricDirection):
-        normalized_direction = {key: direction for key in ordered_result_keys}
-    elif isinstance(direction, dict):
-        normalized_direction = {
-            key: direction.get(key, MetricDirection.Downward)
-            for key in ordered_result_keys
-        }
-
-    normalized_compute_insights = compute_insights
-    if compute_insights is None:
-        normalized_compute_insights = {}
-    elif isinstance(compute_insights, bool):
-        normalized_compute_insights = {key: compute_insights for key in ordered_result_keys}
-    elif isinstance(compute_insights, dict):
-        normalized_compute_insights = {
-            key: compute_insights.get(key, True)
-            for key in ordered_result_keys
-        }
-
-    return normalized_direction, normalized_compute_insights
-
-
 @dataclass
 class MetricHandler:
     metric_handler_data: MetricHandlerData
@@ -309,3 +272,4 @@ class DatasetSample:
     state: DataStateEnum
     custom_latent_space: Optional[npt.NDArray[np.float32]] = None
     instance_masks: Optional[Dict[str, ElementInstance]] = None
+

{code_loader-1.0.172.dev3 → code_loader-1.0.173}/code_loader/default_metrics.py

@@ -29,7 +29,7 @@ def binary_crossentropy(ground_truth: np.array, prediction: np.array) -> np.arra
 
 def categorical_crossentropy(ground_truth: np.array, prediction: np.array) -> np.array:
     ground_truth, prediction = flatten_non_batch_dims(ground_truth, prediction)
-    prediction = prediction / np.sum(prediction, axis=1)
+    prediction = prediction / np.sum(prediction, axis=1, keepdims=True)
     epsilon = 1e-07
     prediction = np.clip(prediction, epsilon, 1.0 - epsilon)
     return -(ground_truth * np.log(prediction)).sum(axis=1).astype(np.float32)

{code_loader-1.0.172.dev3 → code_loader-1.0.173}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -19,7 +19,7 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
     ConfusionMatrixElement, SamplePreprocessResponse, PredictionTypeHandler, InstanceCallableInterface, ElementInstance, \
-    InstanceLengthCallableInterface, normalize_metric_handler_settings
+    InstanceLengthCallableInterface
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType, DataStateType
 from code_loader import leap_binder, LeapLoader
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
@@ -365,14 +365,62 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                     self.model = load_model_func()
                     self.prediction_types = prediction_types
                     _validate_result(self.model)
+                    self.fixed_batch_size = self._detect_fixed_batch_size()
+
+                def _detect_fixed_batch_size(self):
+                    """Detect if the model requires a fixed batch size > 1."""
+                    try:
+                        import onnxruntime
+                        if isinstance(self.model, onnxruntime.InferenceSession):
+                            inputs = self.model.get_inputs()
+                            if inputs:
+                                batch_dim = inputs[0].shape[0]
+                                if isinstance(batch_dim, int) and batch_dim > 1:
+                                    return batch_dim
+                            return None
+                    except ImportError:
+                        pass
+                    try:
+                        input_shape = self.model.input_shape
+                        if isinstance(input_shape, list):
+                            batch_dim = input_shape[0][0]
+                        else:
+                            batch_dim = input_shape[0]
+                        if isinstance(batch_dim, int) and batch_dim > 1:
+                            return batch_dim
+                    except Exception:
+                        pass
+                    return None
+
+                def _tile_inputs(self, arg):
+                    """Tile batch-1 inputs to match the model's fixed batch size."""
+                    if isinstance(arg, list):
+                        return [np.repeat(a, self.fixed_batch_size, axis=0)
+                                if isinstance(a, np.ndarray) and a.shape[0] == 1 else a
+                                for a in arg]
+                    elif isinstance(arg, np.ndarray) and arg.shape[0] == 1:
+                        return np.repeat(arg, self.fixed_batch_size, axis=0)
+                    return arg
+
+                def _slice_outputs(self, result):
+                    """Slice batched outputs back to batch=1."""
+                    if isinstance(result, list):
+                        return [r[:1] for r in result]
+                    return result[:1]
 
                 # keras interface
                 def __call__(self, arg):
+                    if self.fixed_batch_size and self.fixed_batch_size > 1 and _called_from_inside_tl_integration_test_decorator:
+                        arg = self._tile_inputs(arg)
                     ret = self.model(arg)
                     self.validate_declared_prediction_types(ret)
                     if isinstance(ret, list):
-                        return [r.numpy() for r in ret]
-                    return ret.numpy()
+                        result = [r.numpy() for r in ret]
+                    else:
+                        result = ret.numpy()
+                    if self.fixed_batch_size and self.fixed_batch_size > 1 and _called_from_inside_tl_integration_test_decorator:
+                        result = self._slice_outputs(result)
+                    return result
 
                 def validate_declared_prediction_types(self, ret):
                     if not (len(self.prediction_types) == len(ret) if isinstance(ret, list) else 1) and len(
@@ -444,8 +492,16 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                 # onnx runtime interface
                 def run(self, output_names, input_dict):
                     corrected_type_inputs = self._convert_onnx_inputs_to_correct_type(input_dict)
+                    if self.fixed_batch_size and self.fixed_batch_size > 1 and _called_from_inside_tl_integration_test_decorator:
+                        corrected_type_inputs = {
+                            k: np.repeat(v, self.fixed_batch_size, axis=0)
+                            if isinstance(v, np.ndarray) and v.shape[0] == 1 else v
+                            for k, v in corrected_type_inputs.items()
+                        }
                     ret = self.model.run(output_names, corrected_type_inputs)
                     self.validate_declared_prediction_types(ret)
+                    if self.fixed_batch_size and self.fixed_batch_size > 1 and _called_from_inside_tl_integration_test_decorator:
+                        ret = [r[:1] if isinstance(r, np.ndarray) else r for r in ret]
                     return ret
 
                 def get_inputs(self):
@@ -699,21 +755,21 @@ def tensorleap_custom_metric(name: str,
                             (f'{user_function.__name__}() validation failed: '
                              f'Keys in the compute_insights mapping should be part of result keys. Got key {ci_key}.')
 
-                normalized_direction_input = None if direction is _UNSET else direction
-                effective_direction, effective_compute_insights = normalize_metric_handler_settings(
-                    normalized_direction_input,
-                    compute_insights,
-                    result.keys(),
-                )
+                effective_direction = {} if direction is _UNSET else direction if isinstance(direction, dict) else {k:direction for k in result_keys}
+                defaulted_direction_keys = result_keys.difference(effective_direction.keys())
 
-                defaulted_direction_keys = set()
-                if isinstance(direction, dict):
-                    defaulted_direction_keys = result_keys.difference(direction.keys())
+                if defaulted_direction_keys:
+                    effective_direction = {key: effective_direction.get(key, MetricDirection.Downward) for key in result}
 
                 leap_binder.setup_container.metrics[-1].metric_handler_data.direction = effective_direction
-                leap_binder.setup_container.metrics[-1].metric_handler_data.compute_insights = effective_compute_insights
 
                 if defaulted_direction_keys and not _call_from_tl_platform:
+                    if compute_insights is None:
+                        effective_compute_insights = {}
+                    elif isinstance(compute_insights, dict):
+                        effective_compute_insights = compute_insights
+                    else:
+                        effective_compute_insights = {k: compute_insights for k in result_keys}
                     warning_keys = {key for key in defaulted_direction_keys if effective_compute_insights.get(key, True)}
                     if warning_keys:
                         store_warning_by_param(
@@ -1814,3 +1870,4 @@ if not _call_from_tl_platform:
 
 
 
+

{code_loader-1.0.172.dev3 → code_loader-1.0.173}/pyproject.toml

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