bugfixes + added some checks on the data

buckeye_asr.py

@@ -43,7 +43,6 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
                 {
                     "file": datasets.Value("string"),
                     "audio": datasets.Value("string"),
-                    #"audio": datasets.Audio(sampling_rate=16_000),
                     "text": datasets.Value("string"),
                     "phonetic_detail": datasets.Sequence(
                         {
@@ -110,16 +109,10 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
         """ Yields examples as (key, example) tuples. """
         for p in paths:
             for wav_path in Path(p).glob("*.wav"):
-                # TODO: when to load audio?
-                # Extract audio
-                #with open(wav_path) as f:
-                #    audio_data = f.read()  # read audio file properly
-                #    pass
-
                 # Extract words
                 fpath = wav_path.with_suffix(".words")
                 wordlist = self._extract_word_info(fpath)
-                word_seqs = self._split_words(wordlist)
+                word_seqs = self._split_words(wordlist, fpath)
 
                 # Extract transcript
                 # To avoid conflict between the transcripts (`.txt` files) and
@@ -153,27 +146,44 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
         start = 0
         wordlist = []
         for line in lines[9:]:
+            # File s1901b.words goes beyond the end of the audio
+            if fpath.name == "s1901b.words" and start > 568.739:
+                break
             line = line.rstrip("\n")
-            fields = line.split("; ")
-            if len(fields) < 4:
-                logging.warning(f"Line \"{line}\" missing fields in file {fpath}")
+            if not line:  # Skipping empty lines
                 continue
+            fields = line.split("; ")
             subfields = fields[0].split()
-            if not fields[2]:
-                logging.warning(f"Narrow transcription is empty in {fpath}")
-            narrow_trn = fields[2]
-            wordlist.append({
-                "start": start,
-                "stop": float(subfields[0]),
-                "label": subfields[2],
-                "broad_transcription": fields[1],
-                "narrow_transcription": narrow_trn,
-                "syntactic_class": fields[3],
-            })
-            start = float(subfields[0])
+            label = subfields[2]
+            stop = float(subfields[0])
+            if label[0] in  ['<', '{']:
+                # Handling tags (tags sometime miss transcriptions)
+                wordlist.append({
+                    "start": start,
+                    "stop": stop,
+                    "label": label,
+                })
+            else:
+                # Handling words
+                if len(fields) < 4:
+                    logging.warning(f"Line \"{line}\" missing fields in file {fpath}")
+                else:
+                    narrow_trn = fields[2]
+                    # Warning if the narrow_transcription is empty
+                    if not narrow_trn:
+                        logging.warning(f"Narrow transcription is empty in {fpath}")
+                    wordlist.append({
+                        "start": start,
+                        "stop": stop,
+                        "label": label,
+                        "broad_transcription": fields[1],
+                        "narrow_transcription": narrow_trn,
+                        "syntactic_class": fields[3],
+                    })
+            start = stop
         return wordlist
 
-    def _split_words(cls, wordlist):
+    def _split_words(cls, wordlist, fpath):
         word_seqs = []
         segment = []
         for w in wordlist:
@@ -182,11 +192,16 @@ class BuckeyeASRDataset(datasets.GeneratorBasedBuilder):
                 regexp = "|".join([f"<{st}" for st in cls.SPLIT_TAGS])
                 match = re.match(regexp, w["label"])
                 if match and match.start() == 0 and segment:
-                    word_seqs.append(segment)
+                    # The model can't handle segments shorter than 0.25 ms
+                    if segment[-1]["stop"] - segment[0]["start"] >= 0.025:
+                        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:
+        if segment and segment[-1]["stop"] - segment[0]["start"] >= 0.025:
             word_seqs.append(segment)
         return word_seqs
 
@@ -279,5 +294,9 @@ def matching(phone, word):
 
 
 def included(phone, word, threshold=0.02):
+    # We accept an overlap with time difference up to the threshold at the
+    # start or the end
     return (phone["start"] >= word["start"] - threshold and
+            phone["start"] < word["stop"] and
+            phone["stop"] > word["start"] and
             phone["stop"] <= word["stop"] + threshold)