tests passing

Author: Matt Sokoloff

labelbox/data/annotation_types/metrics/scalar.py

@@ -11,7 +11,7 @@ class ScalarMetric(BaseModel):
 
 class CustomScalarMetric(BaseModel):
     metric_name: str
-    value: float
+    metric_value: float
     feature_name: Optional[str] = None
     subclass_name: Optional[str] = None
     aggregation: MetricAggregation = MetricAggregation.ARITHMETIC_MEAN

labelbox/data/serialization/ndjson/converter.py

@@ -20,7 +20,8 @@ def deserialize(json_data: Iterable[Dict[str, Any]]) -> LabelGenerator:
             LabelGenerator containing the ndjson data.
         """
         data = NDLabel(**{'annotations': json_data})
-        return data.to_common()
+        res = data.to_common()
+        return res
 
     @staticmethod
     def serialize(

labelbox/data/serialization/ndjson/label.py

@@ -1,4 +1,5 @@
 from itertools import groupby
+from labelbox.data.annotation_types.metrics.scalar import CustomScalarMetric
 from labelbox.data.annotation_types.metrics import ScalarMetric
 
 from operator import itemgetter
@@ -12,7 +13,7 @@
 from ...annotation_types.data import ImageData, TextData, VideoData
 from ...annotation_types.label import Label
 from ...annotation_types.ner import TextEntity
-from .metric import NDMetricAnnotation, NDMetricType
+from .metric import NDCustomScalarMetric, NDMetricAnnotation, NDMetricType
 from .classification import NDChecklistSubclass, NDClassification, NDClassificationType, NDRadioSubclass
 from .objects import NDObject, NDObjectType
 
@@ -39,14 +40,16 @@ def _generate_annotations(
                                                         NDClassificationType,
                                                         NDMetricType]]]
     ) -> Generator[Label, None, None]:
+
         for data_row_id, annotations in grouped_annotations.items():
             annots = []
             for annotation in annotations:
                 if isinstance(annotation, NDObjectType.__args__):
                     annots.append(NDObject.to_common(annotation))
                 elif isinstance(annotation, NDClassificationType.__args__):
                     annots.extend(NDClassification.to_common(annotation))
-                elif isinstance(annotation, NDMetricType):
+                elif isinstance(annotation, NDMetricType.__args__):
+
                     annots.append(NDMetricAnnotation.to_common(annotation))
                 else:
                     raise TypeError(
@@ -105,9 +108,9 @@ def _create_non_video_annotations(cls, label: Label):
                 yield NDClassification.from_common(annotation, label.data)
             elif isinstance(annotation, ObjectAnnotation):
                 yield NDObject.from_common(annotation, label.data)
-            elif isinstance(annotation, ScalarMetric):
+            elif isinstance(annotation, (ScalarMetric, CustomScalarMetric)):
                 yield NDMetricAnnotation.from_common(annotation, label.data)
             else:
                 raise TypeError(
-                    f"Unable to convert object to MAL format. `{type(annotation.value)}`"
+                    f"Unable to convert object to MAL format. `{type(getattr(annotation, 'value',annotation))}`"
                 )

labelbox/data/serialization/ndjson/metric.py

@@ -1,7 +1,6 @@
+from labelbox.data.annotation_types.metrics.aggregations import MetricAggregation
 from labelbox.data.annotation_types.metrics.scalar import CustomScalarMetric
-from typing import Literal, Union
-
-from fiftyone.core.collections import aggregation
+from typing import Union, Optional
 
 from labelbox.data.annotation_types.data import ImageData, TextData
 from labelbox.data.annotation_types.metrics import ScalarMetric
@@ -24,34 +23,54 @@ def from_common(
 
 
 class NDCustomScalarMetric(NDJsonBase):
-    metric_name: float
+    metric_name: str
     metric_value: float
-    sublcass_name: float
-    aggregation: Union[Literal["ARITHMETIC_MEAN"], Literal["GEOMETRIC_MEAN"],
-                       Literal["HARMONIC_MEAN"], Literal["SUM"]]
+    feature_name: Optional[str] = None
+    subclass_name: Optional[str] = None
+    aggregation: MetricAggregation
 
     def to_common(self) -> CustomScalarMetric:
-        return ScalarMetric(value=self.metric_value, extra={'uuid': self.uuid})
+        return CustomScalarMetric(
+            metric_value=self.metric_value,
+            metric_name=self.metric_name,
+            feature_name=self.feature_name,
+            subclass_name=self.subclass_name,
+            aggregation=MetricAggregation[self.aggregation],
+            extra={'uuid': self.uuid})
 
     @classmethod
-    def from_common(cls, metric: ScalarMetric,
+    def from_common(cls, metric: CustomScalarMetric,
                     data: Union[TextData, ImageData]) -> "NDCustomScalarMetric":
         return NDCustomScalarMetric(uuid=metric.extra.get('uuid'),
-                                    metric_value=metric.value,
+                                    metric_value=metric.metric_value,
+                                    metric_name=metric.metric_name,
+                                    feature_name=metric.feature_name,
+                                    subclass_name=metric.subclass_name,
+                                    aggregation=metric.aggregation.value,
                                     data_row={'id': data.uid})
 
+    def dict(self, *args, **kwargs):
+        res = super().dict(*args, **kwargs)
+        for field in ['featureName', 'subclassName']:
+            if res[field] is None:
+                res.pop(field)
+        return res
+
+    class Config:
+        use_enum_values = True
+
 
 class NDMetricAnnotation:
 
     @classmethod
     def to_common(cls, annotation: "NDMetricType") -> ScalarMetric:
-
         return annotation.to_common()
 
     @classmethod
     def from_common(cls, annotation: Union[ScalarMetric, CustomScalarMetric],
                     data: Union[TextData, ImageData]) -> "NDMetricType":
-        return NDDataRowScalarMetric.from_common(annotation, data)
+        obj = cls.lookup_object(annotation)
+        return obj.from_common(annotation, data)
 
     @staticmethod
     def lookup_object(
@@ -66,4 +85,4 @@ def lookup_object(
         return result
 
 
-NDMetricType = Union[NDDataRowScalarMetric, NDCustomScalarMetric]
+NDMetricType = Union[NDCustomScalarMetric, NDDataRowScalarMetric]

tests/data/annotation_types/test_metrics.py

@@ -47,11 +47,11 @@ def test_custom_scalar_metric(feature_name, subclass_name, aggregation):
     value = 0.5
     kwargs = {'aggregation': aggregation} if aggregation is not None else {}
     metric = CustomScalarMetric(metric_name="iou",
-                                value=value,
+                                metric_value=value,
                                 feature_name=feature_name,
                                 subclass_name=subclass_name,
                                 **kwargs)
-    assert metric.value == value
+    assert metric.metric_value == value
 
     label = Label(data=ImageData(uid="ckrmd9q8g000009mg6vej7hzg"),
                   annotations=[metric])
@@ -65,7 +65,7 @@ def test_custom_scalar_metric(feature_name, subclass_name, aggregation):
             'arr': None
         },
         'annotations': [{
-            'value': value,
+            'metric_value': value,
             'metric_name': 'iou',
             'feature_name': feature_name,
             'subclass_name': subclass_name,

tests/data/assets/ndjson/custom_scalar_import.json

@@ -0,0 +1,3 @@
+[{"uuid" : "a22bbf6e-b2da-4abe-9a11-df84759f7672","dataRow" : {"id": "ckrmdnqj4000007msh9p2a27r"}, "metricValue" : 0.1, "metricName" : "iou", "featureName" : "sample_class", "subclassName" : "sample_subclass", "aggregation" : "SUM"},
+ {"uuid" : "a22bbf6e-b2da-4abe-9a11-df84759f7672","dataRow" : {"id": "ckrmdnqj4000007msh9p2a27r"}, "metricValue" : 0.1, "metricName" : "iou", "featureName" : "sample_class", "aggregation" : "SUM"},
+ {"uuid" : "a22bbf6e-b2da-4abe-9a11-df84759f7672","dataRow" : {"id": "ckrmdnqj4000007msh9p2a27r"}, "metricValue" : 0.1, "metricName" : "iou", "aggregation" : "SUM"}]

tests/data/serialization/ndjson/test_metric.py

@@ -1,6 +1,6 @@
 import json
-from labelbox.data.serialization.labelbox_v1.converter import LBV1Converter
 
+from labelbox.data.serialization.labelbox_v1.converter import LBV1Converter
 from labelbox.data.serialization.ndjson.converter import NDJsonConverter
 
 
@@ -14,3 +14,16 @@ def test_metric():
 
     # Just make sure that this doesn't break
     list(LBV1Converter.serialize(label_list))
+
+
+def test_metric():
+    with open('tests/data/assets/ndjson/custom_scalar_import.json',
+              'r') as file:
+        data = json.load(file)
+
+    label_list = NDJsonConverter.deserialize(data).as_list()
+    reserialized = list(NDJsonConverter.serialize(label_list))
+    assert reserialized == data
+
+    # Just make sure that this doesn't break
+    list(LBV1Converter.serialize(label_list))