simplified pipeline

buckeye_asr.py

@@ -61,6 +61,8 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
                             "syntactic_class": datasets.Value("string"),
                         }
                     ),
+                    "start": datasets.Value("float"),
+                    "stop": datasets.Value("float"),
                     "speaker_id": datasets.Value("string"),
                     "id": datasets.Value("string"),
                 }
@@ -124,19 +126,30 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
                 fpath = wav_path.with_suffix(".phones")
                 phonelist = self._extract_phone_info(fpath)
                 phone_seqs = self._split_phones(word_seqs, phonelist, fpath)
-                assert len(phone_seqs) == len(transcripts)
+                assert len(phone_seqs) == len(word_seqs)
 
                 # id_ must be a unique key
                 for idx in range(len(transcripts)):
+                    ws = word_seqs[idx]
                     id_ = f"{wav_path.stem}_{idx}"
+                    if phone_seqs[idx]:
+                        start = min(ws[0]["start"], phone_seqs[idx][0]["start"])
+                        stop = max(ws[-1]["stop"], phone_seqs[idx][-1]["stop"])
+                    else:
+                        start = ws[0]["start"]
+                        stop = ws[-1]["stop"]
+                    shift_timestamps(ws, -start)
+                    shift_timestamps(phone_seqs[idx], -start)
                     example = {
                         "file": wav_path,
                         "audio": wav_path,
                         "text": transcripts[idx],
                         "phonetic_detail": phone_seqs[idx],
-                        "word_detail": word_seqs[idx],
+                        "word_detail": ws,
                         "speaker_id": id_[1:3],
                         "id": id_,
+                        "start": start,
+                        "stop": stop,
                     }
                     yield id_, example
 
@@ -156,7 +169,7 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
             subfields = fields[0].split()
             label = subfields[2]
             stop = float(subfields[0])
-            if label[0] in  ['<', '{']:
+            if label[0] in ['<', '{']:
                 # Handling tags (tags sometime miss transcriptions)
                 wordlist.append({
                     "start": start,
@@ -194,15 +207,21 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
                 if match and match.start() == 0 and segment:
                     # The model can't handle segments shorter than 0.25 ms
                     if segment[-1]["stop"] - segment[0]["start"] >= 0.025:
+                        word_seqs.append(segment)
+                    else:
                         logging.warning(
                             f"Sequence shorter than 25 ms in {fpath} starting "
                             f"at {segment[0]['start']}")
-                        word_seqs.append(segment)
                     segment = []
             else:
                 segment.append(w)
-        if segment and segment[-1]["stop"] - segment[0]["start"] >= 0.025:
-            word_seqs.append(segment)
+        if segment:
+            if segment[-1]["stop"] - segment[0]["start"] >= 0.025:
+                word_seqs.append(segment)
+            else:
+                logging.warning(
+                    f"Sequence shorter than 25 ms in {fpath} starting "
+                    f"at {segment[0]['start']}")
         return word_seqs
 
     def _extract_phone_info(cls, fpath):
@@ -243,36 +262,46 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
     #    alignments with no duration.
     #  * if two consecutive phones are the same in the narrow transcription,
     #    they can be merged in the alignements.
-    # We are conservative here and every phone that completely included in the
-    # word and overlapping starting/ending phones if they match the first/last
-    # phone of the narrow transcription.
+    # We are conservative here and keep every phone that is completely included
+    # in the utterance + overlapping starting/ending phones if they match the
+    # first/last phone of the narrow transcription.
     def _split_phones(cls, word_seqs, phonelist, fpath):
         phone_seqs = []
         i_pl = 0
         for wl in word_seqs:
             segment = []
-            for word in wl:
-                # skip word if the narrow_transcription is not available
-                if not word["narrow_transcription"]:
-                    continue
-                # skip phones that precede the word start
-                while phonelist[i_pl]["stop"] <= word["start"]:
-                    i_pl += 1
-                # a first phone which overlaps with the start of the word might
-                # not belong with the word
-                if (phonelist[i_pl]["start"] < word["start"] and
-                        not matching(phonelist[i_pl], word)):
-                    # skip the phone
-                    i_pl += 1
-                # take all matching phones
-                while (i_pl < len(phonelist) and
-                       matching(phonelist[i_pl], word)):
-                    segment.append(phonelist[i_pl])
-                    i_pl += 1
+            # skip phones that precede the first word's start
+            while phonelist[i_pl]["stop"] <= wl[0]["start"]:
+                i_pl += 1
+            # a phone which overlaps with the start of the first word might
+            # not belong with the utterance
+            if (phonelist[i_pl]["label"] and
+                    phonelist[i_pl]["start"] < wl[0]["start"] and
+                    not wl[0]["narrow_transcription"].startswith(phonelist[i_pl]["label"])):
+                # skip the phone
+                i_pl += 1
+            # take all phones fully included in the utterance
+            while (i_pl < len(phonelist) and
+                   phonelist[i_pl]["stop"] < wl[-1]["stop"]):
+                segment.append(phonelist[i_pl])
+                i_pl += 1
+            # a phone which overlaps with the end of the last word might
+            # belong with the utterance
+            if (phonelist[i_pl]["label"] and
+                    phonelist[i_pl]["start"] < wl[-1]["stop"] and
+                    wl[-1]["narrow_transcription"].endswith(phonelist[i_pl]["label"])):
+                # add the phone
+                segment.append(phonelist[i_pl])
+                i_pl += 1
             phone_seqs.append(segment)
         return phone_seqs
 
 
+def shift_timestamps(detail, shift):
+    for item in detail:
+        item["start"] += shift
+        item["stop"] += shift
+
 def matching(phone, word):
     # Reject phones without label
     if phone["label"] is None: