| # File: dataspeech-main/dataspeech/cpu_enrichments/rate.py | |
| from g2p import make_g2p | |
| transducer = make_g2p('eng', 'eng-ipa') | |
| def rate_apply(batch, rank=None, audio_column_name='audio', text_column_name='text'): | |
| if isinstance(batch[text_column_name], list): | |
| speaking_rates = [] | |
| phonemes_list = [] | |
| if 'speech_duration' in batch: | |
| for (text, audio_duration) in zip(batch[text_column_name], batch['speech_duration']): | |
| phonemes = transducer(text).output_string | |
| audio_duration = audio_duration if audio_duration != 0 else 0.01 | |
| speaking_rate = len(phonemes) / audio_duration | |
| speaking_rates.append(speaking_rate) | |
| phonemes_list.append(phonemes) | |
| else: | |
| for (text, audio) in zip(batch[text_column_name], batch[audio_column_name]): | |
| phonemes = transducer(text).output_string | |
| sample_rate = audio['sampling_rate'] | |
| audio_length = len(audio['array'].squeeze()) / sample_rate | |
| speaking_rate = len(phonemes) / audio_length | |
| speaking_rates.append(speaking_rate) | |
| phonemes_list.append(phonemes) | |
| batch['speaking_rate'] = speaking_rates | |
| batch['phonemes'] = phonemes_list | |
| else: | |
| phonemes = transducer(batch[text_column_name]).output_string | |
| if 'speech_duration' in batch: | |
| audio_length = batch['speech_duration'] if batch['speech_duration'] != 0 else 0.01 | |
| else: | |
| sample_rate = batch[audio_column_name]['sampling_rate'] | |
| audio_length = len(batch[audio_column_name]['array'].squeeze()) / sample_rate | |
| speaking_rate = len(phonemes) / audio_length | |
| batch['speaking_rate'] = speaking_rate | |
| batch['phonemes'] = phonemes | |
| return batch | |
| # File: dataspeech-main/dataspeech/gpu_enrichments/pitch.py | |
| import torch | |
| import penn | |
| hopsize = 0.01 | |
| fmin = 30.0 | |
| fmax = 1000.0 | |
| checkpoint = None | |
| center = 'half-hop' | |
| interp_unvoiced_at = 0.065 | |
| def pitch_apply(batch, rank=None, audio_column_name='audio', output_column_name='utterance_pitch', penn_batch_size=4096): | |
| if isinstance(batch[audio_column_name], list): | |
| utterance_pitch_mean = [] | |
| utterance_pitch_std = [] | |
| for sample in batch[audio_column_name]: | |
| (pitch, periodicity) = penn.from_audio(torch.tensor(sample['array'][None, :]).float(), sample['sampling_rate'], hopsize=hopsize, fmin=fmin, fmax=fmax, checkpoint=checkpoint, batch_size=penn_batch_size, center=center, interp_unvoiced_at=interp_unvoiced_at, gpu=(rank or 0) % torch.cuda.device_count() if torch.cuda.device_count() > 0 else rank) | |
| utterance_pitch_mean.append(pitch.mean().cpu()) | |
| utterance_pitch_std.append(pitch.std().cpu()) | |
| batch[f'{output_column_name}_mean'] = utterance_pitch_mean | |
| batch[f'{output_column_name}_std'] = utterance_pitch_std | |
| else: | |
| sample = batch[audio_column_name] | |
| (pitch, periodicity) = penn.from_audio(torch.tensor(sample['array'][None, :]).float(), sample['sampling_rate'], hopsize=hopsize, fmin=fmin, fmax=fmax, checkpoint=checkpoint, batch_size=penn_batch_size, center=center, interp_unvoiced_at=interp_unvoiced_at, gpu=(rank or 0) % torch.cuda.device_count() if torch.cuda.device_count() > 0 else rank) | |
| batch[f'{output_column_name}_mean'] = pitch.mean().cpu() | |
| batch[f'{output_column_name}_std'] = pitch.std().cpu() | |
| return batch | |
| # File: dataspeech-main/dataspeech/gpu_enrichments/snr_and_reverb.py | |
| from pyannote.audio import Model | |
| from pathlib import Path | |
| from brouhaha.pipeline import RegressiveActivityDetectionPipeline | |
| import torch | |
| from huggingface_hub import hf_hub_download | |
| import numpy as np | |
| model = None | |
| ratio = 16000 / 270 | |
| def snr_apply(batch, rank=None, audio_column_name='audio', batch_size=32): | |
| global model | |
| if model is None: | |
| model = Model.from_pretrained(Path(hf_hub_download(repo_id='ylacombe/brouhaha-best', filename='best.ckpt')), strict=False) | |
| if rank is not None or torch.cuda.device_count() > 0: | |
| device = f'cuda:{(rank or 0) % torch.cuda.device_count()}' | |
| model.to(device) | |
| pipeline = RegressiveActivityDetectionPipeline(segmentation=model, batch_size=batch_size) | |
| if rank: | |
| pipeline.to(torch.device(device)) | |
| device = pipeline._models['segmentation'].device | |
| if isinstance(batch[audio_column_name], list): | |
| snr = [] | |
| c50 = [] | |
| vad_durations = [] | |
| for sample in batch[audio_column_name]: | |
| res = pipeline({'sample_rate': sample['sampling_rate'], 'waveform': torch.tensor(sample['array'][None, :]).to(device).float()}) | |
| mask = np.full(res['snr'].shape, False) | |
| for (segment, _) in res['annotation'].itertracks(): | |
| start = int(segment.start * ratio) | |
| end = int(segment.end * ratio) | |
| mask[start:end] = True | |
| mask = ~((res['snr'] == 0.0) & (res['c50'] == 0.0)) & mask | |
| vad_duration = sum(map(lambda x: x[0].duration, res['annotation'].itertracks())) | |
| snr.append(res['snr'][mask].mean()) | |
| c50.append(res['c50'][mask].mean()) | |
| vad_durations.append(np.float32(vad_duration)) | |
| batch['snr'] = snr | |
| batch['c50'] = c50 | |
| batch['speech_duration'] = vad_durations | |
| else: | |
| res = pipeline({'sample_rate': batch[audio_column_name]['sampling_rate'], 'waveform': torch.tensor(batch[audio_column_name]['array'][None, :]).to(device).float()}) | |
| mask = np.full(res['snr'].shape, False) | |
| for (segment, _) in res['annotation'].itertracks(): | |
| start = int(segment.start * ratio) | |
| end = int(segment.end * ratio) | |
| mask[start:end] = True | |
| mask = ~((res['snr'] == 0.0) & (res['c50'] == 0.0)) & mask | |
| vad_duration = sum(map(lambda x: x[0].duration, res['annotation'].itertracks())) | |
| batch['snr'] = res['snr'][mask].mean() | |
| batch['c50'] = res['c50'][mask].mean() | |
| batch['speech_duration'] = vad_duration | |
| return batch | |
| # File: dataspeech-main/dataspeech/gpu_enrichments/squim.py | |
| from torchaudio.pipelines import SQUIM_OBJECTIVE | |
| import torch | |
| import torchaudio | |
| model = None | |
| max_audio_length = 15 * SQUIM_OBJECTIVE.sample_rate | |
| def squim_apply(batch, rank=None, audio_column_name='audio'): | |
| global model | |
| if model is None: | |
| model = SQUIM_OBJECTIVE.get_model() | |
| if rank is not None or torch.cuda.device_count() > 0: | |
| device = f'cuda:{(rank or 0) % torch.cuda.device_count()}' | |
| model.to(device) | |
| else: | |
| device = 'cpu' | |
| if isinstance(batch[audio_column_name], list): | |
| sdr = [] | |
| pesq = [] | |
| stoi = [] | |
| for sample in batch[audio_column_name]: | |
| waveform = torchaudio.functional.resample(torch.tensor(sample['array'])[None, :].to(device).float(), sample['sampling_rate'], SQUIM_OBJECTIVE.sample_rate) | |
| with torch.no_grad(): | |
| waveform = waveform[:, :min(max_audio_length, waveform.shape[1])] | |
| (stoi_sample, pesq_sample, sdr_sample) = model(waveform) | |
| sdr.append(sdr_sample.cpu()[0]) | |
| pesq.append(pesq_sample.cpu()[0]) | |
| stoi.append(stoi_sample.cpu()[0]) | |
| batch['sdr'] = sdr | |
| batch['pesq'] = pesq | |
| batch['stoi'] = stoi | |
| else: | |
| waveform = torchaudio.functional.resample(torch.tensor(batch[audio_column_name]['array'][None, :]).to(device).float(), batch[audio_column_name]['sampling_rate'], SQUIM_OBJECTIVE.sample_rate) | |
| with torch.no_grad(): | |
| (stoi_sample, pesq_sample, sdr_sample) = model(waveform) | |
| batch['sdr'] = sdr_sample.cpu()[0] | |
| batch['pesq'] = pesq_sample.cpu()[0] | |
| batch['stoi'] = stoi_sample.cpu()[0] | |
| return batch | |
| # File: dataspeech-main/main.py | |
| from datasets import load_dataset, Audio | |
| from multiprocess import set_start_method | |
| from dataspeech import rate_apply, pitch_apply, snr_apply, squim_apply | |
| import torch | |
| import argparse | |
| if __name__ == '__main__': | |
| set_start_method('spawn') | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument('dataset_name', type=str, help='Path or name of the dataset. See: https://huggingface.co/docs/datasets/v2.17.0/en/package_reference/loading_methods#datasets.load_dataset.path') | |
| parser.add_argument('--configuration', default=None, type=str, help='Dataset configuration to use, if necessary.') | |
| parser.add_argument('--output_dir', default=None, type=str, help='If specified, save the dataset on disk with this path.') | |
| parser.add_argument('--repo_id', default=None, type=str, help='If specified, push the dataset to the hub.') | |
| parser.add_argument('--audio_column_name', default='audio', type=str, help='Column name of the audio column to be enriched.') | |
| parser.add_argument('--text_column_name', default='text', type=str, help='Text column name.') | |
| parser.add_argument('--rename_column', action='store_true', help="If activated, rename audio and text column names to 'audio' and 'text'. Useful if you want to merge datasets afterwards.") | |
| parser.add_argument('--cpu_num_workers', default=1, type=int, help="Number of CPU workers for transformations that don't use GPUs or if no GPU are available.") | |
| parser.add_argument('--cpu_writer_batch_size', default=1000, type=int, help="writer_batch_size for transformations that don't use GPUs. See: https://huggingface.co/docs/datasets/v2.17.0/en/package_reference/main_classes#datasets.Dataset.map.writer_batch_size") | |
| parser.add_argument('--batch_size', default=2, type=int, help='This parameters specify how many samples are passed by workers for operations that are using GPUs.') | |
| parser.add_argument('--penn_batch_size', default=4096, type=int, help="Pitch estimation chunks audio into smaller pieces and processes them in batch. This specify the batch size. If you are using a gpu, pick a batch size that doesn't cause memory errors.") | |
| parser.add_argument('--num_workers_per_gpu_for_pitch', default=1, type=int, help='Number of workers per GPU for the pitch estimation if GPUs are available. Defaults to 1 if some are avaiable. Useful if you want multiple processes per GPUs to maximise GPU usage.') | |
| parser.add_argument('--num_workers_per_gpu_for_snr', default=1, type=int, help='Number of workers per GPU for the SNR and reverberation estimation if GPUs are available. Defaults to 1 if some are avaiable. Useful if you want multiple processes per GPUs to maximise GPU usage.') | |
| parser.add_argument('--apply_squim_quality_estimation', action='store_true', help='If set, will also use torchaudio-squim estimation (SI-SNR, STOI and PESQ).') | |
| parser.add_argument('--num_workers_per_gpu_for_squim', default=1, type=int, help='Number of workers per GPU for the SI-SNR, STOI and PESQ estimation if GPUs are available. Defaults to 1 if some are avaiable. Useful if you want multiple processes per GPUs to maximise GPU usage.') | |
| args = parser.parse_args() | |
| if args.configuration: | |
| dataset = load_dataset(args.dataset_name, args.configuration, num_proc=args.cpu_num_workers) | |
| else: | |
| dataset = load_dataset(args.dataset_name, num_proc=args.cpu_num_workers) | |
| audio_column_name = 'audio' if args.rename_column else args.audio_column_name | |
| text_column_name = 'text' if args.rename_column else args.text_column_name | |
| if args.rename_column: | |
| dataset = dataset.rename_columns({args.audio_column_name: 'audio', args.text_column_name: 'text'}) | |
| if args.apply_squim_quality_estimation: | |
| print('Compute SI-SDR, PESQ, STOI') | |
| squim_dataset = dataset.map(squim_apply, batched=True, batch_size=args.batch_size, with_rank=True if torch.cuda.device_count() > 0 else False, num_proc=torch.cuda.device_count() * args.num_workers_per_gpu_for_squim if torch.cuda.device_count() > 0 else args.cpu_num_workers, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name}) | |
| print('Compute pitch') | |
| pitch_dataset = dataset.cast_column(audio_column_name, Audio(sampling_rate=16000)).map(pitch_apply, batched=True, batch_size=args.batch_size, with_rank=True if torch.cuda.device_count() > 0 else False, num_proc=torch.cuda.device_count() * args.num_workers_per_gpu_for_pitch if torch.cuda.device_count() > 0 else args.cpu_num_workers, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name, 'penn_batch_size': args.penn_batch_size}) | |
| print('Compute snr and reverb') | |
| snr_dataset = dataset.map(snr_apply, batched=True, batch_size=args.batch_size, with_rank=True if torch.cuda.device_count() > 0 else False, num_proc=torch.cuda.device_count() * args.num_workers_per_gpu_for_snr if torch.cuda.device_count() > 0 else args.cpu_num_workers, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name}) | |
| print('Compute speaking rate') | |
| if 'speech_duration' in snr_dataset[next(iter(snr_dataset.keys()))].features: | |
| rate_dataset = snr_dataset.map(rate_apply, with_rank=False, num_proc=args.cpu_num_workers, writer_batch_size=args.cpu_writer_batch_size, fn_kwargs={'audio_column_name': audio_column_name, 'text_column_name': text_column_name}) | |
| else: | |
| rate_dataset = dataset.map(rate_apply, with_rank=False, num_proc=args.cpu_num_workers, writer_batch_size=args.cpu_writer_batch_size, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name, 'text_column_name': text_column_name}) | |
| for split in dataset.keys(): | |
| dataset[split] = pitch_dataset[split].add_column('snr', snr_dataset[split]['snr']).add_column('c50', snr_dataset[split]['c50']) | |
| if 'speech_duration' in snr_dataset[split]: | |
| dataset[split] = dataset[split].add_column('speech_duration', snr_dataset[split]['speech_duration']) | |
| dataset[split] = dataset[split].add_column('speaking_rate', rate_dataset[split]['speaking_rate']).add_column('phonemes', rate_dataset[split]['phonemes']) | |
| if args.apply_squim_quality_estimation: | |
| dataset[split] = dataset[split].add_column('stoi', squim_dataset[split]['stoi']).add_column('si-sdr', squim_dataset[split]['sdr']).add_column('pesq', squim_dataset[split]['pesq']) | |
| if args.output_dir: | |
| print('Saving to disk...') | |
| dataset.save_to_disk(args.output_dir) | |
| if args.repo_id: | |
| print('Pushing to the hub...') | |
| if args.configuration: | |
| dataset.push_to_hub(args.repo_id, args.configuration) | |
| else: | |
| dataset.push_to_hub(args.repo_id) | |