| New file |
| | |
|---|
| | | #!/usr/bin/env python3 |
|---|
| | | |
|---|
| | | # Copyright 2019 Hitachi, Ltd. (author: Yusuke Fujita) |
|---|
| | | # Licensed under the MIT license. |
|---|
| | | |
|---|
| | | """ |
|---|
| | | This script generates random multi-talker mixtures for diarization. |
|---|
| | | It generates a scp-like outputs: lines of "[recid] [json]". |
|---|
| | | recid: recording id of mixture |
|---|
| | | serial numbers like mix_0000001, mix_0000002, ... |
|---|
| | | json: mixture configuration formatted in "one-line" |
|---|
| | | The json format is as following: |
|---|
| | | { |
|---|
| | | 'speakers':[ # list of speakers |
|---|
| | | { |
|---|
| | | 'spkid': 'Name', # speaker id |
|---|
| | | 'rir': '/rirdir/rir.wav', # wav_rxfilename of room impulse response |
|---|
| | | 'utts': [ # list of wav_rxfilenames of utterances |
|---|
| | | '/wavdir/utt1.wav', |
|---|
| | | '/wavdir/utt2.wav',...], |
|---|
| | | 'intervals': [1.2, 3.4, ...] # list of silence durations before utterances |
|---|
| | | }, ... ], |
|---|
| | | 'noise': '/noisedir/noise.wav' # wav_rxfilename of background noise |
|---|
| | | 'snr': 15.0, # SNR for mixing background noise |
|---|
| | | 'recid': 'mix_000001' # recording id of the mixture |
|---|
| | | } |
|---|
| | | |
|---|
| | | Usage: |
|---|
| | | common/random_mixture.py \ |
|---|
| | | --n_mixtures=10000 \ # number of mixtures |
|---|
| | | data/voxceleb1_train \ # kaldi-style data dir of utterances |
|---|
| | | data/musan_noise_bg \ # background noises |
|---|
| | | data/simu_rirs \ # room impulse responses |
|---|
| | | > mixture.scp # output scp-like file |
|---|
| | | |
|---|
| | | The actual data dir and wav files are generated using make_mixture.py: |
|---|
| | | common/make_mixture.py \ |
|---|
| | | mixture.scp \ # scp-like file for mixture |
|---|
| | | data/mixture \ # output data dir |
|---|
| | | wav/mixture # output wav dir |
|---|
| | | """ |
|---|
| | | |
|---|
| | | import argparse |
|---|
| | | import os |
|---|
| | | from funasr.modules.eend_ola.utils import kaldi_data |
|---|
| | | import random |
|---|
| | | import numpy as np |
|---|
| | | import json |
|---|
| | | import itertools |
|---|
| | | |
|---|
| | | parser = argparse.ArgumentParser() |
|---|
| | | parser.add_argument('data_dir', |
|---|
| | | help='data dir of single-speaker recordings') |
|---|
| | | parser.add_argument('noise_dir', |
|---|
| | | help='data dir of background noise recordings') |
|---|
| | | parser.add_argument('rir_dir', |
|---|
| | | help='data dir of room impulse responses') |
|---|
| | | parser.add_argument('--n_mixtures', type=int, default=10, |
|---|
| | | help='number of mixture recordings') |
|---|
| | | parser.add_argument('--n_speakers', type=int, default=4, |
|---|
| | | help='number of speakers in a mixture') |
|---|
| | | parser.add_argument('--min_utts', type=int, default=10, |
|---|
| | | help='minimum number of uttenraces per speaker') |
|---|
| | | parser.add_argument('--max_utts', type=int, default=20, |
|---|
| | | help='maximum number of utterances per speaker') |
|---|
| | | parser.add_argument('--sil_scale', type=float, default=10.0, |
|---|
| | | help='average silence time') |
|---|
| | | parser.add_argument('--noise_snrs', default="10:15:20", |
|---|
| | | help='colon-delimited SNRs for background noises') |
|---|
| | | parser.add_argument('--random_seed', type=int, default=777, |
|---|
| | | help='random seed') |
|---|
| | | parser.add_argument('--speech_rvb_probability', type=float, default=1, |
|---|
| | | help='reverb probability') |
|---|
| | | args = parser.parse_args() |
|---|
| | | |
|---|
| | | random.seed(args.random_seed) |
|---|
| | | np.random.seed(args.random_seed) |
|---|
| | | |
|---|
| | | # load list of wav files from kaldi-style data dirs |
|---|
| | | wavs = kaldi_data.load_wav_scp( |
|---|
| | | os.path.join(args.data_dir, 'wav.scp')) |
|---|
| | | noises = kaldi_data.load_wav_scp( |
|---|
| | | os.path.join(args.noise_dir, 'wav.scp')) |
|---|
| | | rirs = kaldi_data.load_wav_scp( |
|---|
| | | os.path.join(args.rir_dir, 'wav.scp')) |
|---|
| | | |
|---|
| | | # spk2utt is used for counting number of utterances per speaker |
|---|
| | | spk2utt = kaldi_data.load_spk2utt( |
|---|
| | | os.path.join(args.data_dir, 'spk2utt')) |
|---|
| | | |
|---|
| | | segments = kaldi_data.load_segments_hash( |
|---|
| | | os.path.join(args.data_dir, 'segments')) |
|---|
| | | |
|---|
| | | # choice lists for random sampling |
|---|
| | | all_speakers = list(spk2utt.keys()) |
|---|
| | | all_noises = list(noises.keys()) |
|---|
| | | all_rirs = list(rirs.keys()) |
|---|
| | | noise_snrs = [float(x) for x in args.noise_snrs.split(':')] |
|---|
| | | |
|---|
| | | mixtures = [] |
|---|
| | | for it in range(args.n_mixtures): |
|---|
| | | # recording ids are mix_0000001, mix_0000002, ... |
|---|
| | | recid = 'mix_{:07d}'.format(it + 1) |
|---|
| | | # randomly select speakers, a background noise and a SNR |
|---|
| | | speakers = random.sample(all_speakers, args.n_speakers) |
|---|
| | | noise = random.choice(all_noises) |
|---|
| | | noise_snr = random.choice(noise_snrs) |
|---|
| | | mixture = {'speakers': []} |
|---|
| | | for speaker in speakers: |
|---|
| | | # randomly select the number of utterances |
|---|
| | | n_utts = np.random.randint(args.min_utts, args.max_utts + 1) |
|---|
| | | # utts = spk2utt[speaker][:n_utts] |
|---|
| | | cycle_utts = itertools.cycle(spk2utt[speaker]) |
|---|
| | | # random start utterance |
|---|
| | | roll = np.random.randint(0, len(spk2utt[speaker])) |
|---|
| | | for i in range(roll): |
|---|
| | | next(cycle_utts) |
|---|
| | | utts = [next(cycle_utts) for i in range(n_utts)] |
|---|
| | | # randomly select wait time before appending utterance |
|---|
| | | intervals = np.random.exponential(args.sil_scale, size=n_utts) |
|---|
| | | # randomly select a room impulse response |
|---|
| | | if random.random() < args.speech_rvb_probability: |
|---|
| | | rir = rirs[random.choice(all_rirs)] |
|---|
| | | else: |
|---|
| | | rir = None |
|---|
| | | if segments is not None: |
|---|
| | | utts = [segments[utt] for utt in utts] |
|---|
| | | utts = [(wavs[rec], st, et) for (rec, st, et) in utts] |
|---|
| | | mixture['speakers'].append({ |
|---|
| | | 'spkid': speaker, |
|---|
| | | 'rir': rir, |
|---|
| | | 'utts': utts, |
|---|
| | | 'intervals': intervals.tolist() |
|---|
| | | }) |
|---|
| | | else: |
|---|
| | | mixture['speakers'].append({ |
|---|
| | | 'spkid': speaker, |
|---|
| | | 'rir': rir, |
|---|
| | | 'utts': [wavs[utt] for utt in utts], |
|---|
| | | 'intervals': intervals.tolist() |
|---|
| | | }) |
|---|
| | | mixture['noise'] = noises[noise] |
|---|
| | | mixture['snr'] = noise_snr |
|---|
| | | mixture['recid'] = recid |
|---|
| | | print(recid, json.dumps(mixture)) |
|---|
