mms_msg
1.0.0
MMS-MSG adalah kerangka kerja yang sangat modular dan fleksibel untuk generasi campuran bicara. Ini memperluas basis kode dari basis data SMS-WSJ untuk pembuatan sinyal campuran untuk dapat menghasilkan campuran ucapan gaya rapat dan sinyal campuran yang sesuai dengan database campuran ucapan klasik.
Data pertemuan menjelaskan pengaturan yang sangat dinamis. Baik lingkungan dengan MMS-MSG, kami tidak bertujuan untuk menyediakan satu basis data baru.
Sebaliknya, kami ingin memberikan kerangka kerja yang dapat disesuaikan yang memungkinkan pembuatan prototipe dan evaluasi untuk memenuhi sistem pengadaan dan transkripsi di sebanyak mungkin lingkungan.
Aspek inti dari MMS-MSG adalah generasi data gaya rapat. Pertemuan dihasilkan secara modular. Parameter yang dapat disesuaikan adalah:
Proses pengambilan sampel dimodulasi, sehingga banyak skenario dapat dibuat dengan sedikit mengubah pipa pengambilan sampel. Kami menyediakan kelas contoh untuk menunjukkan bagaimana modul tunggal digunakan. Jika skenario tidak didukung, modul pengambilan sampel baru dapat dengan mudah diimplementasikan untuk mengadaptasi MMS-MSG dengan kebutuhan Anda.
Proses simulasi data MMS-MSG dibagi menjadi pengambilan sampel parameter dan pembuatan data aktual. Melalui ini, kami mendukung pembuatan data sesuai permintaan. Dengan cara ini, hanya data sumber dan parameter pertemuan yang perlu disimpan, memungkinkan simulasi berbagai skenario pertemuan sambil meminimalkan ruang disk yang diperlukan. Namun, kami juga mendukung pembuatan data rapat offline jika menyimpannya ke hard disk diperlukan untuk alur kerja Anda.
Kami menyediakan kode untuk menghasilkan campuran ucapan sesuai dengan spesifikasi basis data pemisahan sumber yang saat ini digunakan, di mana ucapan tunggal dari beberapa speaker baik saling tumpang tindih sebagian atau sepenuhnya tumpang tindih satu sama lain. Dengan menggunakan MMS-MSG untuk menghasilkan data pelatihan untuk database ini, kami menawarkan dukungan asli dari pencampuran dinamis.
Database campuran ucapan yang didukung:
Berencana:
Generator campuran menggunakan lazy_dataset. Sementara fungsi inti MMS_MSG dapat digunakan tanpa LAZY_Dataset, beberapa fitur (seperti pencampuran dinamis dan abstraksi basis data) tidak tersedia saat itu.
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 ) Rutinitas modifikasi data lainnya dapat dipetakan ke ds secara langsung setelah memuat contoh.
A lazy_dataset.Dataset dapat dicolokkan ke torch.utils.data.DataLoader :
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 )Contoh input harus memiliki struktur ini:
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)
}Setelah memilih ucapan untuk campuran, contoh -contoh ucapan ini dinormalisasi dan "disusun", yang menghasilkan struktur yang mirip dengan ini:
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'
],
...
}Mulai dari struktur seperti itu, modul pengambilan sampel dapat diterapkan untuk mengisi contoh dengan lebih banyak informasi, misalnya, offset atau penskalaan ucapan.
Kelas atau definisi basis data disediakan untuk beberapa skenario umum di mms_msg.databases . Setiap kelas database harus mendefinisikan dua metode:
get_mixture_dataset , yang merangkum tahap "pengambilan sampel" dan membangun pipa modul pengambilan sampel, danload_example , yang menyediakan tahap "simulasi", yaitu, memuat dan mencampur data audio.Basis data dasar (bebas parameter) akan terlihat seperti ini:
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 )dan dapat dipakai dengan
db = MyDatabase ( 'path/to/source/database.json' )Struktur pipa pengambilan sampel dataset dijelaskan pada bagian selanjutnya.
Ini adalah contoh dari pipa pengambilan sampel sederhana untuk satu dataset:
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 )) Proses pengambilan sampel selalu dimulai dengan pembuatan "komposisi sumber", yaitu, ucapan pengambilan sampel (basis) untuk setiap campuran. Ini dilakukan di get_composition_dataset , yang mengimplementasikan algoritma pengambilan sampel yang mirip dengan SMS-WSJ yang menggunakan setiap ucapan dari database sumber sama seringnya.
Setelah ini, modul pengambilan sampel dapat diterapkan untuk mensimulasikan pola atau lingkungan yang berbeda. Contoh di atas menetapkan semua offset ke nol (yaitu, semua ucapan dimulai pada awal campuran) dengan ConstantOffsetSampler dan sampel skala acak dengan maksimum 5dB dengan UniformScalingSampler .
Banyak modul pengambilan sampel lainnya tersedia, termasuk yang mensimulasikan pola berbicara gaya rapat. Contoh untuk ini dapat ditemukan di buku catatan ini.
Campuran dalam mms_msg dibuat dengan menerapkan modul pengambilan sampel individual ke contoh satu demi satu. Setiap modul pengambilan sampel sepenuhnya deterministik, yaitu, outputnya hanya tergantung pada hiperparameter dan contoh inputnya, tetapi tidak diizinkan untuk mempertahankan keadaan yang dapat berubah. Ini untuk memastikan reproduktifitas: pengambilan sampel tidak tergantung pada urutan di mana campuran dihasilkan, jumlah atau urutan di mana modul diterapkan.
Modul pengambilan sampel adalah sebuah callable yang menerima campuran (menengah) sebagai kamus, memodifikasinya, dan mengembalikannya. Modul pengambilan sampel dasar, diimplementasikan sebagai fungsi tanpa hiperparameter, bisa terlihat seperti ini:
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 Bagian penting adalah mms_msg.sampling.utils.rng.get_rng_example . Ini mengembalikan objek np.random.Generator yang diinisialisasi dengan benih yang dihitung dari informasi dasar dari contoh kamus (contoh-id dan dataset) dan string benih tambahan. Ini berarti bahwa angka acak yang dihasilkan dalam modul sama setiap kali modul diterapkan pada contoh input yang sama.
Jika modul pengambilan sampel Anda memiliki hiperparameter, kami merekomendasikan dataclass beku untuk memastikan kekekalan:
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 exampleContoh yang lebih praktis diberikan dalam buku catatan ini.
MMS-MSG diusulkan dalam publikasi berikut:
@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} } ,
} ```
