code-loader 0.2.54.dev3__tar.gz → 0.2.56__tar.gz

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/PKG-INFO

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

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/code_loader/contract/datasetclasses.py

@@ -6,7 +6,7 @@ import numpy.typing as npt
 import tensorflow as tf  # type: ignore
 
 from code_loader.contract.enums import DataStateType, DatasetMetadataType, \
-    DataStateEnum, LeapDataType, ConfusionMatrixValue
+    DataStateEnum, LeapDataType, MetricEnum, ConfusionMatrixValue
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
     LeapTextMask, LeapImageMask, LeapImageWithBBox
 
@@ -52,7 +52,7 @@ VisualizerCallableInterface = Union[
 VisualizerCallableReturnType = Union[LeapImage, LeapText, LeapGraph, LeapHorizontalBar,
                                      LeapImageMask, LeapTextMask, LeapImageWithBBox]
 
-CustomCallableInterface = Callable[..., tf.Tensor]
+CustomCallableInterface = Callable[[tf.Tensor, tf.Tensor], tf.Tensor]
 
 
 @dataclass
@@ -74,7 +74,6 @@ MetricCallableReturnType = Union[tf.Tensor, List[List[ConfusionMatrixElement]]]
 class CustomLossHandler:
     name: str
     function: CustomCallableInterface
-    arg_names: List[str]
 
 
 @dataclass
@@ -120,6 +119,8 @@ class MetadataHandler:
 class PredictionTypeHandler:
     name: str
     labels: List[str]
+    metrics: Optional[List[MetricEnum]] = None
+    custom_metrics: Optional[List[Union[CustomCallableInterface, ConfusionMatrixCallableInterface]]] = None
 
 
 @dataclass

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/code_loader/contract/responsedataclasses.py

@@ -1,7 +1,7 @@
 from typing import List, Optional, Dict
 
 from dataclasses import dataclass, field
-from code_loader.contract.enums import DatasetMetadataType, LeapDataType
+from code_loader.contract.enums import DatasetMetadataType, LeapDataType, MetricEnum
 
 
 @dataclass
@@ -45,12 +45,6 @@ class MetricInstance:
     arg_names: List[str]
 
 
-@dataclass
-class CustomLossInstance:
-    name: str
-    arg_names: List[str]
-
-
 @dataclass
 class CustomLayerInstance:
     name: str
@@ -62,6 +56,8 @@ class CustomLayerInstance:
 class PredictionTypeInstance:
     name: str
     labels: List[str]
+    metrics: Optional[List[MetricEnum]] = None
+    custom_metrics: Optional[List[str]] = None
 
 
 @dataclass
@@ -72,7 +68,7 @@ class DatasetSetup:
     outputs: List[DatasetOutputInstance]
     visualizers: List[VisualizerInstance]
     prediction_types: List[PredictionTypeInstance]
-    custom_losses: List[CustomLossInstance]
+    custom_loss_names: List[str]
     metrics: List[MetricInstance] = field(default_factory=list)
 
 

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/code_loader/helpers/detection/yolo/loss.py

@@ -20,19 +20,21 @@ class YoloLoss:
     def __init__(self, num_classes: int, default_boxes: List[NDArray[np.int32]],
                  overlap_thresh: float, background_label: int,
                  from_logits: bool = True, weights: List[float] = [4.0, 1.0, 0.4],
-                 max_match_per_gt: int = 10):
+                 max_match_per_gt: int = 10, image_size: int = 640,
+                 cls_w: float = 0.3, obj_w: float = 0.7, box_w: float = 0.05):
         self.background_label = background_label
         self.default_boxes = [tf.convert_to_tensor(box_arr) for box_arr in default_boxes]
         self.num_classes = num_classes
         self.threshold = overlap_thresh
         self.variance = (1, 1)
-        self.ce = tf.keras.losses.CategoricalCrossentropy(from_logits=False, reduction='none')
         self.from_logits = from_logits
-        # self.bce = tf.keras.losses.BinaryCrossentropy()
         self.weights = weights  # Following yolov7 weights
-        self.obj_w = 0.7
-        self.cls_w = 0.00375
-        self.box_w = 0.05
+        scale_factor = 3. / len(weights)
+        class_factor = self.num_classes / 80
+        image_factor = image_size / 640.
+        self.obj_w = obj_w * scale_factor
+        self.cls_w = cls_w * class_factor * scale_factor
+        self.box_w = box_w * image_factor ** 2 * scale_factor
         self.max_match_per_gt = max_match_per_gt
 
     def __call__(self, y_true: tf.Tensor, y_pred: Tuple[List[tf.Tensor], List[tf.Tensor]]) -> \
@@ -105,8 +107,12 @@ class YoloLoss:
                         else:
                             sig_pos_conf = conf_data_layer[j]
 
-                        onehot_labels = tf.one_hot(conf_t_tensor[j], self.num_classes)
-                        single_loss_cls = tf.reduce_mean(self.ce(onehot_labels, sig_pos_conf), axis=-1) * self.cls_w
+                        one_hot_preds = tf.one_hot(tf.boolean_mask(conf_t_tensor[j], pos[j]), self.num_classes)
+                        matched_prediction = tf.boolean_mask(sig_pos_conf, pos[j, ...], axis=0)
+                        matched_prediction = tf.clip_by_value(matched_prediction, 1e-7, 1 - 1e-7)
+                        single_loss_cls = tf.reduce_mean(-(
+                                one_hot_preds * tf.math.log(matched_prediction) + (1 - one_hot_preds) * tf.math.log(
+                            1 - matched_prediction))) * self.cls_w
                     else:
                         single_loss_cls = tf.constant(0, dtype=tf.float32)
                 else:  # No GT

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/code_loader/helpers/detection/yolo/utils.py

@@ -1,5 +1,4 @@
-from typing import Tuple, List
-
+from typing import Tuple, List, Union
 import numpy as np
 import tensorflow as tf  # type: ignore
 from numpy.typing import NDArray
@@ -52,15 +51,19 @@ def encode_bboxes(matched: tf.Tensor, priors: tf.Tensor, variances: Tuple[int, i
     return tf.concat([g_cxcy, g_wh], 1)
 
 
-def scale_loc_prediction(loc_pred: List[tf.Tensor], decoded: bool = False, image_size: float = 640.,
+def scale_loc_prediction(loc_pred: List[tf.Tensor], decoded: bool = False, image_size: Union[float, Tuple[float, float]] = 640.,
                          strides: Tuple[int, int, int] = (8, 16, 32)) -> \
         List[tf.Tensor]:
     new_loc_pred = [None] * len(loc_pred)
+    if isinstance(image_size, int) or isinstance(image_size, float):
+        scale_arr: NDArray[np.float32] = np.array([image_size, image_size, image_size, image_size], dtype=np.float32)
+    else:
+        scale_arr = np.array([*image_size[::-1], *image_size[::-1]], dtype=np.float32)
     if decoded:
-        new_loc_pred = [loc / image_size for loc in loc_pred]
+        new_loc_pred = [loc / scale_arr for loc in loc_pred]
     else:
         for i in range(len(loc_pred)):
-            new_loc_pred[i] = tf.concat([(strides[i] * (2 * tf.sigmoid(loc_pred[i][..., :2]) - 0.5)) / image_size,
+            new_loc_pred[i] = tf.concat([(strides[i] * (2 * tf.sigmoid(loc_pred[i][..., :2]) - 0.5)) / scale_arr[:2],
                                          2 * tf.sigmoid(loc_pred[i][..., 2:])], axis=-1)
     return new_loc_pred
 

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/code_loader/leap_binder/leapbinder.py

@@ -81,8 +81,7 @@ class LeapBinder:
 
     @typechecked
     def add_custom_loss(self, function: CustomCallableInterface, name: str) -> None:
-        arg_names = inspect.getfullargspec(function)[0]
-        self.setup_container.custom_loss_handlers.append(CustomLossHandler(name, function, arg_names))
+        self.setup_container.custom_loss_handlers.append(CustomLossHandler(name, function))
 
     @typechecked
     def add_custom_metric(self,
@@ -95,10 +94,7 @@ class LeapBinder:
     def add_prediction(self, name: str, labels: List[str], metrics: Optional[List[MetricEnum]] = None,
                        custom_metrics: Optional[
                            List[Union[CustomCallableInterface, ConfusionMatrixCallableInterface]]] = None) -> None:
-        if metrics or custom_metrics:
-            raise DeprecationWarning("Adding metrics on 'leap_binder.add_prediction' method is deprecated."
-                                     "Please update the leap script and use metric block instead.")
-        self.setup_container.prediction_types.append(PredictionTypeHandler(name, labels))
+        self.setup_container.prediction_types.append(PredictionTypeHandler(name, labels, metrics, custom_metrics))
 
     @typechecked
     def set_ground_truth(self, function: SectionCallableInterface, name: str) -> None:

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/code_loader/leaploader.py

@@ -12,7 +12,7 @@ from code_loader.contract.enums import DataStateEnum, TestingSectionEnum, DataSt
 from code_loader.contract.exceptions import DatasetScriptException
 from code_loader.contract.responsedataclasses import DatasetIntegParseResult, DatasetTestResultPayload, \
     DatasetPreprocess, DatasetSetup, DatasetInputInstance, DatasetOutputInstance, DatasetMetadataInstance, \
-    VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance, CustomLossInstance
+    VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance
 from code_loader.leap_binder import global_leap_binder
 from code_loader.utils import get_root_exception_line_number, get_shape
 
@@ -215,12 +215,15 @@ class LeapLoader:
             VisualizerInstance(visualizer_handler.name, visualizer_handler.type, visualizer_handler.arg_names)
             for visualizer_handler in setup.visualizers]
 
-        custom_losses = [CustomLossInstance(custom_loss.name, custom_loss.arg_names)
-                         for custom_loss in setup.custom_loss_handlers]
+        custom_loss_names = [custom_loss.name for custom_loss in setup.custom_loss_handlers]
 
         prediction_types = []
         for prediction_type in setup.prediction_types:
-            pred_type_inst = PredictionTypeInstance(prediction_type.name, prediction_type.labels)
+            custom_metrics_names = None
+            if prediction_type.custom_metrics:
+                custom_metrics_names = [custom_metric.__name__ for custom_metric in prediction_type.custom_metrics]
+            pred_type_inst = PredictionTypeInstance(prediction_type.name, prediction_type.labels,
+                                                    prediction_type.metrics, custom_metrics_names)
             prediction_types.append(pred_type_inst)
 
         metrics = []
@@ -230,7 +233,7 @@ class LeapLoader:
 
         return DatasetSetup(preprocess=dataset_preprocess, inputs=inputs, outputs=ground_truths, metadata=metadata,
                             visualizers=visualizers, prediction_types=prediction_types,
-                            custom_losses=custom_losses, metrics=metrics)
+                            custom_loss_names=custom_loss_names, metrics=metrics)
 
     @staticmethod
     def get_model_setup_response() -> ModelSetup:

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/code_loader/metrics/default_metrics.py

@@ -149,4 +149,3 @@ metrics_names_to_functions = {
     Metric.ConfusionMatrixClassification.name: confusion_matrix_classification_metric,
     Metric.MeanIOU.name: batch_mean_iou
 }
-

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/pyproject.toml

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

{code_loader-0.2.54.dev3 → code_loader-0.2.56}/setup.py

@@ -23,7 +23,7 @@ extras_require = \
 
 setup_kwargs = {
     'name': 'code-loader',
-    'version': '0.2.54.dev3',
+    'version': '0.2.56',
     'description': '',
     'long_description': '# tensorleap code loader\nUsed to load user code to tensorleap \n',
     'author': 'dorhar',