Proposal: corpus/recording efficiency improvements

audio/ffmpeg.py

@@ -159,8 +159,9 @@ def run_recover_duration(self):
         c.load("temp_corpus.xml.gz")
 
         for r in c.all_recordings():
-            assert len(r.segments) == 1, "needs to be a single segment recording"
-            segment = r.segments[0]
+            recording_segments = list(r.segments)
+            assert len(recording_segments) == 1, "needs to be a single segment recording"
+            segment = recording_segments[0]
             old_duration = segment.end
             assert r.audio is not None
             data, sample_rate = soundfile.read(open(r.audio, "rb"))

corpus/data_augmentation.py

@@ -77,7 +77,8 @@ def run(self):
             r.max_seg_end = max_seg_end
 
         # select noise files for each recording
-        for i, r in enumerate(c.recordings):
+        recording_list = list(c.recordings)
+        for i, r in enumerate(recording_list):
             audio_name = r.audio
             target_length = r.max_seg_end
             reverbed_audio_name = "noised_" + audio_name.split("/")[-1]
@@ -91,11 +92,11 @@ def run(self):
                 noise_audios = []
 
                 while noise_length < target_length:
-                    random_index = rng.randint(0, len(c.recordings) - 1)
+                    random_index = rng.randint(0, len(recording_list) - 1)
                     while random_index == i:
-                        random_index = random.randint(0, len(c.recordings) - 1)
-                    noise_audios.append(c.recordings[random_index])
-                    noise_length += c.recordings[random_index].max_seg_end
+                        random_index = random.randint(0, len(recording_list) - 1)
+                    noise_audios.append(recording_list[random_index])
+                    noise_length += recording_list[random_index].max_seg_end
 
                 # create temp noise file
                 temp_noise_track_file = "/dev/shm/{id}/tmp_concat_%i.wav" % n
@@ -134,15 +135,14 @@ def run(self):
                 command = ffmpeg_head + noise_inputs + filter_head + volume_reduction + mixer + filter_tail
                 self.sh(command)
 
-            nr = corpus.Recording()
+            nr = corpus.Recording(corpus=nc)
             nr.name = r.name
-            nr.segments = r.segments
             nr.speaker_name = r.speaker_name
             nr.default_speaker = r.default_speaker
             nr.speakers = r.speakers
             nr.audio = str(self.out_audio_folder) + "/" + reverbed_audio_name
-            nc.add_recording(nr)
-            for s in nr.segments:
+            for s in r.segments:
+                nr.add_segment(s)
                 segment_file_names.append(nc.name + "/" + nr.name + "/" + s.name + "\n")
 
         nc.dump(self.out_corpus.get_path())
@@ -203,15 +203,14 @@ def run(self):
                 "-ar {base_frequency} '{audio_out}/%s'" % (r.audio, perturbed_audio_name)
             )
 
-            pr = corpus.Recording()
+            pr = corpus.Recording(corpus=nc)
             pr.name = r.name
-            pr.segments = r.segments
             pr.speaker_name = r.speaker_name
             pr.speakers = r.speakers
             pr.default_speaker = r.default_speaker
             pr.audio = str(self.out_audio_folder) + "/" + perturbed_audio_name
-            nc.add_recording(pr)
-            for s in pr.segments:
+            for s in r.segments:
+                pr.add_segment(s)
                 segment_file_names.append(nc.name + "/" + pr.name + "/" + s.name)
                 s.start /= self.speed_factor
                 s.end /= self.speed_factor

corpus/filter.py

@@ -32,14 +32,11 @@ def _delete_empty_recordings(corpus: corpus.Corpus, removed_recordings_file: str
     :param c: Corpus for which to delete the empty recordings.
     :param removed_recordings_file: File in which to dump all recordings that have been deleted.
     """
-    to_delete = []
-    for rec in corpus.all_recordings():
-        if not rec.segments:
-            to_delete.append(rec)
-
-    corpus.remove_recordings(to_delete)
     with open(removed_recordings_file, "w") as f:
-        f.write("\n".join(rec.fullname() for rec in to_delete))
+        for rec in corpus.all_recordings():
+            if not rec.segments:
+                corpus.remove_recording(rec)
+                f.write(f"{rec.fullname()}\n")
 
 
 class FilterSegmentsByListJob(Job):
@@ -527,7 +524,7 @@ def maybe_to_lower(s):
 
         c = corpus.Corpus()
         c.load(self.corpus.get_path())
-        num_segments_per_recording = {r.fullname(): len(r.segments) for r in c.all_recordings()}
+        num_segments_per_recording = {r.fullname(): len(list(r.segments)) for r in c.all_recordings()}
 
         # use var name instead of attribute to avoid problem with name scope
         log_oov_list = self.log_oov_list
@@ -577,7 +574,7 @@ def __call__(self, corpus: corpus.Corpus, recording: corpus.Recording, segment:
             recordings_to_be_removed = []
             for r in c.all_recordings():
                 num_seg = num_segments_per_recording[r.fullname()]
-                new_num_seg = len(r.segments)
+                new_num_seg = len(list(r.segments))
                 if num_seg and (num_seg - new_num_seg) / num_seg > self.recording_oov_tolerance:
                     recordings_to_be_removed.append(r)
 

corpus/transform.py

@@ -70,22 +70,22 @@ def run(self):
             words = [s[1] for s in transcriptions[recording.name]]
 
             if len(words) == 0 and self.remove_empty_segments:
-                recordings_to_delete = recording
+                recordings_to_delete = recording  # TODO: this does nothing.
                 continue
 
             segments_to_delete = []
-            for idx, segment in enumerate(recording.segments):
+            for segment in recording.segments:
                 left_idx = bisect.bisect_left(times, segment.start)
                 right_idx = bisect.bisect_left(times, segment.end)
 
                 if left_idx == right_idx and self.remove_empty_segments:
-                    segments_to_delete.append(idx)
+                    segments_to_delete.append(segment)
                     continue
 
                 segment.orth = " ".join(words[left_idx:right_idx]).replace("&", "&")
 
-            for sidx in reversed(segments_to_delete):
-                del recording.segments[sidx]
+            for segment in reversed(segments_to_delete):
+                recording.remove_segment(segment)
 
         c.dump(self.output_corpus_path.get_path())
 
@@ -223,7 +223,7 @@ def run(self):
                         sm_entry.value = "/".join([c.name, split_name, segment.name])
                         sm.map_entries.append(sm_entry)
 
-                        new_recording_element.segments.append(segment)
+                        new_recording_element.add_segment(segment)
                         segment_count += 1
 
                     # update the time stamp with the recording length and add to ffmpeg merge list
@@ -547,15 +547,14 @@ def run(self):
         nc.speaker_name = c.speaker_name
         # store index of last segment
         for r in c.recordings:
-            sr = corpus.Recording()
+            sr = corpus.Recording(corpus=nc)
             sr.name = r.name
-            sr.segments = r.segments
             sr.speaker_name = r.speaker_name
             sr.speakers = r.speakers
             sr.default_speaker = r.default_speaker
             sr.audio = r.audio
-            nc.add_recording(sr)
-            for s in sr.segments:
+            for s in r.segments:
+                sr.add_segment(s)
                 segment_file_names.append(nc.name + "/" + sr.name + "/" + s.name)
                 s.start += self.shift
 

datasets/librispeech.py

@@ -136,22 +136,19 @@ def run(self):
 
         for transcript in self._transcripts:
             name = "{0}-{1}-{2:04d}".format(transcript["speaker_id"], transcript["chapter"], transcript["segment"])
-            recording = corpus.Recording()
+            recording = corpus.Recording(corpus=c)
             recording.name = name
             recording.speaker_name = transcript["speaker_id"]
             recording.audio = "{}/{}.flac".format(transcript["path"], name)
 
             used_speaker_ids.add(transcript["speaker_id"])
 
-            segment = corpus.Segment()
+            segment = corpus.Segment(recording=recording)
             segment.name = name
             segment.start = 0
             segment.end = float("inf")
             segment.orth = transcript["orth"].strip()
 
-            recording.segments.append(segment)
-            c.recordings.append(recording)
-
         for speaker_id, speaker_info in sorted(self._speakers.items()):
             if speaker_id not in used_speaker_ids:
                 continue

datasets/switchboard.py

@@ -262,7 +262,7 @@ def run(self):
             rec_to_segs.pop("sw02167B")
 
         for rec_name, segs in sorted(rec_to_segs.items()):
-            recording = corpus.Recording()
+            recording = corpus.Recording(corpus=c)
             recording.name = rec_name
             recording.audio = os.path.join(self.audio_dir.get_path(), rec_name + ".wav")
 
@@ -272,7 +272,7 @@ def run(self):
             rec_speaker_id = rec_to_speaker[rec_name]["speaker_id"]
 
             for seg in segs:
-                segment = corpus.Segment()
+                segment = corpus.Segment(recording=recording)
                 segment.name = seg[0]
                 segment.start = float(seg[1])
                 segment.end = float(seg[2])
@@ -281,9 +281,6 @@ def run(self):
                 if len(segment.orth) == 0:
                     continue
 
-                recording.segments.append(segment)
-            c.recordings.append(recording)
-
         # add speakers to corpus
         for speaker_info in rec_to_speaker.values():
             speaker = corpus.Speaker()