mms_msg
1.0.0
MMS-MSG ist ein hochmodularer und flexibler Rahmen für die Erzeugung von Sprachmischungen. Es erweitert die Code-Basis der SMS-WSJ-Datenbank für die Erzeugung von Mischungssignalen, um sowohl Sprachmischungen als auch Mischungssignale im Besprechungsstil zu generieren, die klassischen Sprachmischungsdatenbanken entsprechen.
Das Erfüllen von Daten beschreibt eine hochdynamische Einstellung. Beide Umgebung mit MMS-MSG, wir wollen keine einzige neue Datenbank bereitstellen.
Stattdessen möchten wir ein anpassungsfähiges Framework bereitstellen, das das Prototyping und die Bewertung der Erfüllung des Prozess- und Transkriptionssystems in möglichst vielen Umgebungen ermöglicht.
Der Kernaspekt von MMS-MSG ist die Erzeugung von Daten im Besprechungsstil. Die Treffen werden modular erzeugt. Einstellbare Parameter sind:
Der Stichprobenprozess wird modularisiert, sodass viele Szenarien erstellt werden können, indem die Abtastpipeline geringfügig geändert wird. Wir bieten Beispielklassen an, um zu zeigen, wie die einzelnen Module verwendet werden. Wenn kein Szenario unterstützt wird, können neue Stichprobenmodule problemlos implementiert werden, um MMS-MSG an Ihre Anforderungen anzupassen.
Der Datensimulationsprozess von MMS-MSG wird in die Parameterabtastung und die tatsächliche Datenerzeugung aufgeteilt. Dadurch unterstützen wir die Datenerzeugung On-Demand. Auf diese Weise müssen nur die Quelldaten und die Meeting -Parameter gespeichert werden, wodurch die Simulation verschiedener Besprechungsszenarien ermöglicht wird und gleichzeitig den erforderlichen Speicherplatz minimiert wird. Wir unterstützen jedoch auch die Offline -Generation von Besprechungsdaten, wenn das Speichern auf der Festplatte für Ihren Workflow erforderlich ist.
Wir bieten Code, um Sprachmischungen gemäß den Spezifikationen aktuell verwendeter Quellenteilungsdatenbanken zu generieren, in denen einzelne Äußerungen mehrerer Sprecher teilweise oder vollständig miteinander überlappen. Durch die Verwendung von MMS-MSG zum Generieren von Trainingsdaten für diese Datenbanken bieten wir eine native Unterstützung des dynamischen Mischens.
Unterstützte Sprachmischungsdatenbanken:
Geplant:
Der Mischgenerator verwendet Lazy_Dataset. Während die Kernfunktionalität von MMS_MSG ohne Lazy_Dataset verwendet werden kann, sind einige Funktionen (wie dynamisches Mischen und die Datenbankabstraktion) nicht verfügbar.
from mms_msg . databases . classical . full_overlap import WSJ2Mix
from mms_msg . sampling . utils import collate_fn
db = WSJ2Mix ()
# Get a train dataset with dynamic mixing
# This dataset only emits the metadata of the mixtures, it doesn't load
# the data yet
ds = db . get_dataset ( 'train_si284_rng' )
# The data can be loaded by mapping a database's load_example function
ds = ds . map ( db . load_example )
# Other dataset modifications (see lazy_dataset doc)
ds = ds . shuffle ( reshuffle = True )
ds = ds . batch ( batch_size = 8 ). map ( collate_fn )
# ...
# Parallelize data loading with lazy_dataset
ds = ds . prefetch ( num_workers = 8 , buffer_size = 16 )
# The dataset can now be used in any training loop
for example in ds :
# ... do fancy stuff with the example.
# The loaded audio data is in example['audio_data']
print ( example ) Alle anderen Datenänderungsroutinen können direkt nach dem Laden des Beispiels auf ds abgebildet werden.
A lazy_dataset.Dataset kann an eine torch.utils.data.DataLoader angeschlossen werden:
from mms_msg . databases . classical . full_overlap import WSJ2Mix
db = WSJ2Mix ()
ds = db . get_dataset ( 'train_si284_rng' ). map ( db . load_example )
# Parallelize data loading with torch.utils.data.DataLoader
from torch . utils . data import DataLoader
loader = DataLoader ( ds , batch_size = 8 , shuffle = True , num_workers = 8 )
for example in loader :
print ( example )Die Eingangsbeispiele sollten diese Struktur haben:
example = {
'audio_path' : {
'observation' : 'single_speaker_recording.wav'
},
'speaker_id' : 'A' ,
'num_samples' : 1234 , # Number of samples of the observation file
# 'num_samples': {'observation': 1234} # Alernative, if other audios are present
'dataset' : 'test' , # The input dataset name
'example_id' : 'asdf1234' , # Unique ID of this example. Optional if the input data is passes as a dict
'scenario' : 'cafe-asdf1234' , # (Optional) If provided, mms_msg makes sure that all examples of the same speaker in a mixture share the same scenario
# ... (any additional keys)
}Nach der Auswahl von Äußerungen für eine Mischung werden diese Äußerungsbeispiele normalisiert und "gesammelt", was zu einer ähnlichen Struktur führt:
example = {
'audio_path' : {
'original_source' : [
'source1.wav' ,
'source2.wav' ,
],
},
'speaker_id' : [
'A' , 'B'
],
'num_samples' : { # The structure under some keys mirrors the structure in 'audio_path'
'original_source' : [
1234 , 4321
]
},
'source_id' : [ # Reference to the source examples this mixture was created from
'asdf1234' , 'asdf1235'
],
...
}Ausgehend von einer solchen Struktur können Stichprobenmodule angewendet werden, um das Beispiel mit weiteren Informationen, z. B. Offsets oder Skalierung der Äußerungen zu füllen.
Datenbankklassen oder Definitionen werden für einige gemeinsame Szenarien in mms_msg.databases bereitgestellt. Jede Datenbankklasse muss zwei Methoden definieren:
get_mixture_dataset , das die "Stichprobenstufe" zusammenfasst und eine Pipeline von Abtastmodulen erstellt, undload_example , das die "Simulation" -Pufe liefert, dh laden und mischen die Audiodaten.Eine grundlegende (parameterfreie) Datenbank würde so aussehen:
from mms_msg . databases . database import MMSMSGDatabase
from lazy_dataset . database import JsonDatabase
import mms_msg
class MyDatabase ( JsonDatabase , MMSMSGDatabase ):
def get_mixture_dataset ( self , name , rng ):
ds = mms_msg . sampling . source_composition . get_composition_dataset (
input_dataset = super (). get_dataset ( name ),
num_speakers = 2 ,
rng = rng ,
)
ds = ds . map ( mms_msg . sampling . pattern . classical . ConstantOffsetSampler ( 8000 ))
ds = ds . map ( mms_msg . sampling . environment . scaling . ConstantScalingSampler ( 0 ))
return ds
def load_example ( self , example ):
return mms_msg . simulation . anechoic . anechoic_scenario_map_fn ( example )und kann mit instanziiert werden mit
db = MyDatabase ( 'path/to/source/database.json' )Die Struktur der Datensatz -Stichprobenpipeline wird im nächsten Abschnitt beschrieben.
Dies ist ein Beispiel für eine einfache Stichprobenpipeline für einen einzelnen Datensatz:
import mms_msg
input_ds = ... # Get source utterance examples from somewhere
# Compute a composition of base examples. This makes sure that the speaker distribution
# in the mixtures is equal to the speaker distribution in the original database.
ds = mms_msg . sampling . source_composition . get_composition_dataset ( input_dataset = input_ds , num_speakers = 2 )
# If required: Offset the utterances
ds = ds . map ( mms_msg . sampling . pattern . classical . ConstantOffsetSampler ( 0 ))
# If required: Add log_weights to simulate volume differences
ds = ds . map ( mms_msg . sampling . environment . scaling . UniformScalingSampler ( max_weight = 5 )) Der Probenahmeprozess beginnt immer mit der Erstellung einer "Quellzusammensetzung", dh der Probenahme (Basis) Äußerungen für jede Mischung. Dies geschieht in get_composition_dataset , das einen Stichprobenalgorithmus ähnelt, der SMS-WSJ ähnelt, der jede Äußerung aus der Quelldatenbank gleich häufig verwendet.
Danach können Abtastmodule angewendet werden, um verschiedene Sprechmuster oder Umgebungen zu simulieren. Das obige Beispiel stellt alle Offsets auf Null fest (dh alle Äußerungen beginnen am Anfang der Mischung) mit dem ConstantOffsetSampler und proben eine zufällige Skala mit einem Maximum von 5 dB mit dem UniformScalingSampler .
Viele andere Stichprobenmodule sind verfügbar, darunter eines, das den Sprechmustern des Besprechungsstils simuliert. Beispiele hierfür finden Sie in diesem Notebook.
Mischungen in mms_msg werden erstellt, indem einzelne Stichprobenmodule auf ein Beispiel nacheinander angewendet werden. Jedes Stichprobenmodul ist vollständig deterministisch, dh seine Ausgabe hängt nur von seinen Hyperparametern und dem Eingangsbeispiel ab, darf jedoch keinen veränderlichen Zustand aufrechterhalten. Dies soll die Reproduzierbarkeit sicherstellen: Die Stichprobe hängt nicht von der Reihenfolge ab, in der die Gemische erzeugt werden, die Anzahl oder Reihenfolge, in der die Module angewendet werden.
Ein Abtastmodul ist ein Anruf, das eine (mittlere) Mischung als Wörterbuch erhält, es verändert und zurückgibt. Ein grundlegendes Abtastmodul, das als Funktion ohne Hyperparameter implementiert ist, könnte so aussehen:
import mms_msg
def my_sampling_module ( example : dict ) -> dict :
# Get a deterministic random number generator based on the input example
# and an additional seed string. The seed string ensures that the RNGs
# differ between different sampling modules
rng = mms_msg . sampling . utils . rng . get_rng_example ( example , 'my_sampler' )
# Sample whatever based on RNG and possibly the contents of example
example [ 'my_random_number' ] = rng . random ()
return example Ein wichtiger Teil ist die Funktion mms_msg.sampling.utils.rng.get_rng_example . Es gibt ein np.random.Generator Objekt zurück, das mit einem Saatgut aus grundlegenden Informationen aus dem Beispiel-Wörterbuch (Beispiel-ID und Datensatz) und einer zusätzlichen Saatgutfolge initialisiert wird. Dies bedeutet, dass die in einem Modul generierten Zufallszahlen jedes Mal gleich sind, wenn das Modul auf das gleiche Eingangsbeispiel angewendet wird.
Wenn Ihr Stichprobenmodul über Hyperparameter verfügt, empfehlen wir einen gefrorenen Datenaklas, um die Unveränderlichkeit zu gewährleisten:
import mms_msg
from dataclasses import dataclass
@ dataclass ( frozen = True )
class MySamplingModule :
size : int = 42
def __call__ ( self , example ):
rng = mms_msg . sampling . utils . rng . get_rng_example ( example , 'my_sampler' )
# Sample whatever based on RNG and possibly the contents of example
example [ 'my_random_number' ] = rng . random ( self . size )
return exampleIn diesem Notizbuch finden Sie ein praktischeres Beispiel.
MMS-MSG wurde in der folgenden Veröffentlichung vorgeschlagen:
@inproceedings { cordlandwehr2022mms_msg ,
title = { MMS-MSG: A Multi-purpose Multi-Speaker Mixture Signal Generator } ,
author = { Tobias Cord-Landwehr and Thilo von Neumann and Christoph Boeddeker and Reinhold Haeb-Umbach } ,
year = { 2022 } ,
booktitle = { International Workshop on Acoustic Signal Enhancement (IWAENC) } ,
publisher = { {IEEE} } ,
} ```
