Add "type" identifier to error rate serialization

meeteval/der/md_eval.py

@@ -8,7 +8,7 @@
 from pathlib import Path
 
 import meeteval.io
-from meeteval.wer.wer.error_rate import ErrorRate
+from meeteval.wer.wer.error_rate import BaseErrorRate, ErrorRate
 
 
 def _fix_channel(r):
@@ -21,10 +21,12 @@ def _fix_channel(r):
 
 
 @dataclasses.dataclass(frozen=True)
-class DiaErrorRate:
+class DiaErrorRate(BaseErrorRate):
     """
 
     """
+    identifier = 'diarization-error-rate'
+
     error_rate: 'float | decimal.Decimal'
 
     scored_speaker_time: 'float | decimal.Decimal'
@@ -36,16 +38,29 @@ class DiaErrorRate:
     def zero(cls):
         return cls(0, 0, 0, 0, 0)
 
+    @classmethod
+    def from_dict(cls, d: dict) -> 'DiaErrorRate':
+        return cls(
+            d['error_rate'],
+            d['scored_speaker_time'],
+            d['missed_speaker_time'],
+            d['falarm_speaker_time'],
+            d['speaker_error_time'],
+        )
+
     def __post_init__(self):
         assert self.scored_speaker_time >= 0
         assert self.missed_speaker_time >= 0
         assert self.falarm_speaker_time >= 0
         assert self.speaker_error_time >= 0
         errors = self.speaker_error_time + self.falarm_speaker_time + self.missed_speaker_time
-        error_rate = errors / self.scored_speaker_time
+        if self.scored_speaker_time > 0:
+            error_rate = errors / self.scored_speaker_time
+        else:
+            error_rate = None
         if self.error_rate is None:
             object.__setattr__(self, 'error_rate', error_rate)
-        else:
+        elif error_rate is not None:
             # Since md-eval uses float internally, and the printed numbers are
             # rounded, it is in corner cases not possible to reproduce the
             # exact error rate, that is calculated internally by md-eval.
@@ -58,13 +73,13 @@ def __post_init__(self):
             # Hence, we allow a small difference.
             assert abs(self.error_rate - error_rate) < 0.00007, (error_rate, self)
 
-    def __radd__(self, other: 'int') -> 'ErrorRate':
+    def __radd__(self, other: 'int') -> 'DiaErrorRate':
         if isinstance(other, int) and other == 0:
             # Special case to support sum.
             return self
         return NotImplemented
 
-    def __add__(self, other: 'DiaErrorRate'):
+    def __add__(self, other: 'DiaErrorRate') -> 'DiaErrorRate':
         if not isinstance(other, self.__class__):
             raise ValueError()
 
@@ -76,6 +91,11 @@ def __add__(self, other: 'DiaErrorRate'):
             speaker_error_time=self.speaker_error_time + other.speaker_error_time,
         )
 
+    def asdict(self):
+        d = dataclasses.asdict(self)
+        d['type'] = self.identifier
+        return d
+
 
 class _FilenameEscaper:
     """

meeteval/viz/visualize.py

@@ -414,7 +414,7 @@ def compress(m):
     # Add utterances to data. Add total number of words to each utterance
     data['utterances'] = [{**l, 'total': len(l['words'].split())} for l in u]
 
-    data['info']['wer'] = dataclasses.asdict(wer)
+    data['info']['wer'] = wer.asdict()
 
     def wer_by_speaker(speaker):
         # Get all words from this speaker
@@ -434,15 +434,15 @@ def wer_by_speaker(speaker):
         deletions = len(ref_words.filter(
             lambda s: not [w for w, _ in s['matches'] if w is not None and words[w]['source'] == 'hypothesis']))
 
-        return dataclasses.asdict(ErrorRate(
+        return ErrorRate(
             errors=insertions + deletions + substitutions,
             length=len(ref_words),
             insertions=insertions,
             deletions=deletions,
             substitutions=substitutions,
             reference_self_overlap=None,
             hypothesis_self_overlap=None,
-        ))
+        ).asdict()
 
     data['info']['wer_by_speakers'] = {
         speaker: wer_by_speaker(speaker)

meeteval/wer/__main__.py

@@ -119,14 +119,14 @@ def to_str(example_id):
 
     # Save details
     _dump({
-        to_str(example_id): dataclasses.asdict(error_rate)
+        to_str(example_id): error_rate.asdict()
         for example_id, error_rate in per_reco.items()
     }, per_reco_out.format(parent=parent, stem=stem))
 
     # Compute and save average
     average = combine_error_rates(*per_reco.values())
     _dump(
-        dataclasses.asdict(average),
+        average.asdict(),
         average_out.format(parent=parent, stem=stem),
     )
     if hasattr(average, 'scored_speaker_time'):
@@ -455,10 +455,10 @@ def _merge(
 
     if average:
         er = meeteval.wer.combine_error_rates(*[er for _, er in ers])
-        out_data = dataclasses.asdict(er)
+        out_data = er.asdict()
     else:
         out_data = {
-            k: dataclasses.asdict(er)
+            k: er.asdict()
             for k, er in ers
         }
         assert len(out_data) == len(ers), (len(out_data), len(ers), 'Duplicate filenames')

meeteval/wer/wer/cp.py

@@ -36,6 +36,8 @@ class CPErrorRate(ErrorRate):
     >>> combine_error_rates(CPErrorRate(0, 10, 0, 0, 0, None, None, 1, 0, 3), CPErrorRate(5, 10, 0, 0, 5, None, None, 0, 1, 3))
     CPErrorRate(error_rate=0.25, errors=5, length=20, insertions=0, deletions=0, substitutions=5, missed_speaker=1, falarm_speaker=1, scored_speaker=6)
     """
+    identifier = 'cp-error-rate'
+
     missed_speaker: int
     falarm_speaker: int
     scored_speaker: int

meeteval/wer/wer/di_cp.py

@@ -19,8 +19,13 @@
 
 @dataclasses.dataclass(frozen=True)
 class DICPErrorRate(ErrorRate):
+    identifier = 'di-cp-error-rate'
     assignment: Tuple[int, ...]
 
+    @classmethod
+    def zero(cls):
+        return DICPErrorRate(0, 0, 0, 0, 0, None, None, ())
+
     def apply_assignment(self, reference, hypothesis):
         return apply_dicp_assignment(self.assignment, reference, hypothesis)