Reconnaissance vocale ouverte pour le russe

Article
09/03/2024

Extraits de discours provenant de diverses sources audio. Le jeu de données contient de brefs clips audio en russe.

Notes

Microsoft fournit Azure Open Datasets « en l’état ». Microsoft n’offre aucune garantie, expresse ou implicite, ni de conditions relatives à votre utilisation des jeux de données. Dans la mesure autorisée par votre droit local, Microsoft décline toute responsabilité pour les dommages ou pertes, y compris directs, consécutifs, spéciaux, indirects ou punitifs, résultant de votre utilisation des jeux de données.

Ce jeu de données est fourni selon les conditions initiales par lesquelles Microsoft a reçu les données sources. Le jeu de données peut inclure des données provenant de Microsoft.

Ce jeu de données Reconnaissance vocale pour le russe comprend les éléments suivants :

Environ 16 millions d’énoncés
Environ 20 000 heures
2,3 To (non compressés au format .wav en int16), 356G en opus
Tous les fichiers ont été convertis en opus, à l’exception des jeux de données de validation

L’objectif principal du jeu de données est d’entraîner des modèles de reconnaissance vocale.

Composition du jeu de données

La taille du jeu de données est indiquée pour les fichiers .wav.

JEU DE DONNÉES	ÉNONCÉS	HEURES	Go	SECONDES/CARACTÈRES	COMMENT	ANNOTATION	QUALITÉ/BRUIT
radio_v4 (*)	7 603 192	10 430	1 195	5s/68	Case d’option	Aligner	95 % / net
public_speech (*)	1 700 060	2 709	301	6s/79	Discours public	Aligner	95 % / net
audiobook_2	1 149 404	1 511	162	5s/56	Livres	Aligner	95 % / net
radio_2	651 645	1 439	154	8s/110	Case d’option	Aligner	95 % / net
public_youtube1120	1 410 979	1 104	237	3s/34	YouTube	Sous-titres	95 % / presque net
public_youtube700	759 483	701	75	3s/43	YouTube	Sous-titres	95 % / presque net
tts_russian_addresses	1 741 838	754	81	2s/20	Adresses	Synthèse vocale 4 voix	100 %/net
asr_public_phone_calls_2	603 797	601	66	4s/37	Appels téléphoniques	ASR	70 % / bruyant
public_youtube1120_hq	369 245	291	31	3s/37	HQ YouTube	Sous-titres	95 % / presque net
asr_public_phone_calls_1	233 868	211	23	3s/29	Appels téléphoniques	ASR	70 % / bruyant
radio_v4_add (*)	92 679	157	18	6s/80	Case d’option	Aligner	95 % / net
asr_public_stories_2	78 186	78	9	4s/43	Livres	ASR	80 % / net
asr_public_stories_1	46 142	38	4	3s/30	Livres	ASR	80 % / net
public_series_1	20 243	17	2	3s/38	YouTube	Sous-titres	95 % / presque net
asr_calls_2_val	12 950	7 7	2	2s/34	Appels téléphoniques	Annotation manuelle	99 % / net
public_lecture_1	6 803	6	1	3s/47	Conférences	Sous-titres	95 % / net
buriy_audiobooks_2_val	7 850	4,9	1	2s/31	Livres	Annotation manuelle	99 % / net
public_youtube700_val	7 311	4,5	1	2s/35	YouTube	Annotation manuelle	99 % / net

(*) Seul un exemple de données est fourni avec les fichiers .txt.

Méthodologie d’annotation

Le jeu de données est compilé à l’aide de sources ouvertes. Les longues séquences sont divisées en morceaux audio à l’aide de l’alignement et de la détection d’activité vocale. Certains types d’audio sont annotés automatiquement et vérifiés statistiquement à l’aide d’euristiques.

Volumes de données et fréquence de mise à jour

La taille totale du jeu de données est de 350 Go. La taille totale du jeu de données avec des étiquettes partagées publiquement est de 130 Go.

Il est peu probable que le jeu de données lui-même soit mis à jour pour assurer une compatibilité descendante. Suivez le référentiel d’origine pour les points de référence et les fichiers exclude.

De nouveaux domaines et de nouvelles langues pourront être ajoutés à l’avenir.

Normalisation audio

Tous les fichiers sont normalisés pour faciliter et accélérer les augmentations du runtime. Le traitement est le suivant :

Convertis en mono, si nécessaire
Convertis en fréquence d’échantillonnage 16 kHz, si nécessaire
Stockés sous forme d’entiers 16 bits
Convertis en OPUS

Méthodologie de base de données sur disque

Chaque fichier audio (wav, binaire) est haché. Le code de hachage est utilisé pour créer une arborescence des dossiers pour un fonctionnement fs plus optimal.

target_format = 'wav'
wavb = wav.tobytes()

f_hash = hashlib.sha1(wavb).hexdigest()

store_path = Path(root_folder,
                  f_hash[0],
                  f_hash[1:3],
                  f_hash[3:15] + '.' + target_format)

Téléchargements

Ce jeu de données est fourni sous deux formes :

Des archives disponibles via Stockage Blob Azure et/ou des liens directs
Les fichiers originaux disponibles via Stockage Blob Azure. Le tout est stocké dans « https://azureopendatastorage.blob.core.windows.net/openstt/ »

Structure des dossiers :

└── ru_open_stt_opus                                            <= archived folders
│   │
│   ├── archives
│   │    ├── asr_calls_2_val.tar.gz                             <= tar.gz archives with opus and wav files
│   │    │   ...                                                <= see the below table for enumeration
│   │    └── tts_russian_addresses_rhvoice_4voices.tar.gz
│   │
│   └── manifests
│        ├── asr_calls_2_val.csv                                <= csv files with wav_path, text_path, duration (see notebooks)
│        │   ...
│        └── tts_russian_addresses_rhvoice_4voices.csv
│
└── ru_open_stt_opus_unpacked                                   <= a separate folder for each uploaded domain
    ├── public_youtube1120
    │    ├── 0                                                  <= see "On disk DB methodology" for details
    │    ├── 1
    │    │   ├── 00
    │    │   │  ...
    │    │   └── ff
    │    │        ├── *.opus                                   <= actual files
    │    │        └── *.txt
    │    │   ...
    │    └── f
    │
    ├── public_youtube1120_hq
    ├── public_youtube700_val
    ├── asr_calls_2_val
    ├── radio_2
    ├── private_buriy_audiobooks_2
    ├── asr_public_phone_calls_2
    ├── asr_public_stories_2
    ├── asr_public_stories_1
    ├── public_lecture_1
    ├── asr_public_phone_calls_1
    ├── public_series_1
    └── public_youtube700

JEU DE DONNÉES	GO, WAV	GO, ARCHIVE	ARCHIVER	SOURCE	MANIFESTE
Former
Échantillon radio et discours public	-	11,4	opus+txt	-	manifest
audiobook_2	162	25,8	opus+txt	Internet + alignment	manifest
radio_2	154	24,6	opus+txt	Case d’option	manifest
public_youtube1120	237	19,0	opus+txt	Vidéos YouTube	manifest
asr_public_phone_calls_2	66	9,4	opus+txt	Internet + ASR	manifest
public_youtube1120_hq	31	4,9	opus+txt	Vidéos YouTube	manifest
asr_public_stories_2	9	1.4	opus+txt	Internet + alignment	manifest
tts_russian_addresses_rhvoice_4voices	80,9	12.9	opus+txt	TTS	manifest
public_youtube700	75,0	12,2	opus+txt	Vidéos YouTube	manifest
asr_public_phone_calls_1	22,7	3.2	opus+txt	Internet + ASR	manifest
asr_public_stories_1	4,1	0,7	opus+txt	Histoires publiques	manifest
public_series_1	1,9	0.3	opus+txt	Séries publiques	manifest
public_lecture_1	0,7	0,1	opus+txt	Internet + manuel	manifest
Val
asr_calls_2_val	2	0,8	wav+txt	Internet	manifest
buriy_audiobooks_2_val	1	0,5	wav+txt	Livres + manuel	manifest
public_youtube700_val	2	0,13	wav+txt	Vidéos YouTube + manuel	manifest

Instructions de téléchargement

Téléchargement direct

Pour savoir comment télécharger directement le jeu de données, consultez la page d’instructions de téléchargement de GitHub.

Informations supplémentaires

Pour obtenir de l’aide ou poser des questions sur les données, contactez les auteurs des données à l’adresse aveysov@gmail.com.

Cette licence permet aux utilisateurs de distribuer, de remixer, d’adapter et d’exploiter le matériel sur n’importe quel support ou dans n’importe quel format, à des fins non commerciales uniquement, et à condition que l’auteur soit mentionné. Elle inclut les éléments suivants :

BY : Le créateur doit être cité
NC : Seules les utilisations non commerciales de l’œuvre sont autorisées

CC-BY-NC - Utilisation commerciale disponible après accord avec les auteurs du jeu de données.

Accès aux données

Azure Notebooks

azure-storage

Fonctions/dépendances de l’assistance

Génération de libsndfile

Un moyen efficace de lire les fichiers opus en Python qui n’entraîne pas de surcharge importante consiste à utiliser pysoundfile (un wrapper CFFI Python autour de libsoundfile).

La prise en charge d’opus a été implémenté en amont, mais elle n’a pas été correctement publiée. C’est pourquoi nous avons opté pour une build personnalisée et des MonkeyPatch.

En règle générale, vous devez l’exécuter dans votre interpréteur de commandes avec un accès sudo :

apt-get update
apt-get install cmake autoconf autogen automake build-essential libasound2-dev \
libflac-dev libogg-dev libtool libvorbis-dev libopus-dev pkg-config -y

cd /usr/local/lib
git clone https://github.com/erikd/libsndfile.git
cd libsndfile
git reset --hard 49b7d61
mkdir -p build && cd build

cmake .. -DBUILD_SHARED_LIBS=ON
make && make install
cmake --build .

Fonctions/dépendances de l’assistance

Installez les bibliothèques suivantes :

pandas
numpy
scipy
tqdm
soundfile
librosa

Les manifestes sont des fichiers CSV avec les colonnes suivantes :

Chemin d’accès au fichier audio
Chemin d’accès au fichier texte
Duration

Ils se sont avérés être le format le plus simple pour accéder aux données.

Pour faciliter l’utilisation, tous les manifestes sont déjà réenracinés. Tous les chemins d’accès étant relatifs, vous devez fournir un dossier racine.

# manifest utils
import os
import numpy as np
import pandas as pd
from tqdm import tqdm
from urllib.request import urlopen


def reroot_manifest(manifest_df,
                    source_path,
                    target_path):
    if source_path != '':
        manifest_df.wav_path = manifest_df.wav_path.apply(lambda x: x.replace(source_path,
                                                                              target_path))
        manifest_df.text_path = manifest_df.text_path.apply(lambda x: x.replace(source_path,
                                                                                target_path))
    else:
        manifest_df.wav_path = manifest_df.wav_path.apply(lambda x: os.path.join(target_path, x))
        manifest_df.text_path = manifest_df.text_path.apply(lambda x: os.path.join(target_path, x))    
    return manifest_df


def save_manifest(manifest_df,
                  path,
                  domain=False):
    if domain:
        assert list(manifest_df.columns) == ['wav_path', 'text_path', 'duration', 'domain']
    else:
        assert list(manifest_df.columns) == ['wav_path', 'text_path', 'duration']

    manifest_df.reset_index(drop=True).sort_values(by='duration',
                                                   ascending=True).to_csv(path,
                                                                          sep=',',
                                                                          header=False,
                                                                          index=False)
    return True


def read_manifest(manifest_path,
                  domain=False):
    if domain:
        return pd.read_csv(manifest_path,
                        names=['wav_path',
                               'text_path',
                               'duration',
                               'domain'])
    else:
        return pd.read_csv(manifest_path,
                        names=['wav_path',
                               'text_path',
                               'duration'])


def check_files(manifest_df,
                domain=False):
    orig_len = len(manifest_df)
    if domain:
        assert list(manifest_df.columns) == ['wav_path', 'text_path', 'duration']
    else:
        assert list(manifest_df.columns) == ['wav_path', 'text_path', 'duration', 'domain']
    wav_paths = list(manifest_df.wav_path.values)
    text_path = list(manifest_df.text_path.values)

    omitted_wavs = []
    omitted_txts = []

    for wav_path, text_path in zip(wav_paths, text_path):
        if not os.path.exists(wav_path):
            print('Dropping {}'.format(wav_path))
            omitted_wavs.append(wav_path)
        if not os.path.exists(text_path):
            print('Dropping {}'.format(text_path))
            omitted_txts.append(text_path)

    manifest_df = manifest_df[~manifest_df.wav_path.isin(omitted_wavs)]
    manifest_df = manifest_df[~manifest_df.text_path.isin(omitted_txts)]
    final_len = len(manifest_df)

    if final_len != orig_len:
        print('Removed {} lines'.format(orig_len-final_len))
    return manifest_df


def plain_merge_manifests(manifest_paths,
                          MIN_DURATION=0.1,
                          MAX_DURATION=100):

    manifest_df = pd.concat([read_manifest(_)
                             for _ in manifest_paths])
    manifest_df = check_files(manifest_df)

    manifest_df_fit = manifest_df[(manifest_df.duration>=MIN_DURATION) &
                                  (manifest_df.duration<=MAX_DURATION)]

    manifest_df_non_fit = manifest_df[(manifest_df.duration<MIN_DURATION) |
                                      (manifest_df.duration>MAX_DURATION)]

    print(f'Good hours: {manifest_df_fit.duration.sum() / 3600:.2f}')
    print(f'Bad hours: {manifest_df_non_fit.duration.sum() / 3600:.2f}')

    return manifest_df_fit


def save_txt_file(wav_path, text):
    txt_path = wav_path.replace('.wav','.txt')
    with open(txt_path, "w") as text_file:
        print(text, file=text_file)
    return txt_path


def read_txt_file(text_path):
    #with open(text_path, 'r') as file:
    response = urlopen(text_path)
    file = response.readlines()
    for i in range(len(file)):
        file[i] = file[i].decode('utf8')
    return file 

def create_manifest_from_df(df, domain=False):
    if domain:
        columns = ['wav_path', 'text_path', 'duration', 'domain']
    else:
        columns = ['wav_path', 'text_path', 'duration']
    manifest = df[columns]
    return manifest


def create_txt_files(manifest_df):
    assert 'text' in manifest_df.columns
    assert 'wav_path' in manifest_df.columns
    wav_paths, texts = list(manifest_df['wav_path'].values), list(manifest_df['text'].values)
    # not using multiprocessing for simplicity
    txt_paths = [save_txt_file(*_) for _ in tqdm(zip(wav_paths, texts), total=len(wav_paths))]
    manifest_df['text_path'] = txt_paths
    return manifest_df


def replace_encoded(text):
    text = text.lower()
    if '2' in text:
        text = list(text)
        _text = []
        for i,char in enumerate(text):
            if char=='2':
                try:
                    _text.extend([_text[-1]])
                except:
                    print(''.join(text))
            else:
                _text.extend([char])
        text = ''.join(_text)
    return text

# reading opus files
import os
import soundfile as sf



# Fx for soundfile read/write functions
def fx_seek(self, frames, whence=os.SEEK_SET):
    self._check_if_closed()
    position = sf._snd.sf_seek(self._file, frames, whence)
    return position


def fx_get_format_from_filename(file, mode):
    format = ''
    file = getattr(file, 'name', file)
    try:
        format = os.path.splitext(file)[-1][1:]
        format = format.decode('utf-8', 'replace')
    except Exception:
        pass
    if format == 'opus':
        return 'OGG'
    if format.upper() not in sf._formats and 'r' not in mode:
        raise TypeError("No format specified and unable to get format from "
                        "file extension: {0!r}".format(file))
    return format


#sf._snd = sf._ffi.dlopen('/usr/local/lib/libsndfile/build/libsndfile.so.1.0.29')
sf._subtypes['OPUS'] = 0x0064
sf.SoundFile.seek = fx_seek
sf._get_format_from_filename = fx_get_format_from_filename


def read(file, **kwargs):
    return sf.read(file, **kwargs)


def write(file, data, samplerate, **kwargs):
    return sf.write(file, data, samplerate, **kwargs)

# display utils
import gc
from IPython.display import HTML, Audio, display_html
pd.set_option('display.max_colwidth', 3000)
#Prepend_path is set to read directly from Azure. To read from local replace below string with path to the downloaded dataset files
prepend_path = 'https://azureopendatastorage.blob.core.windows.net/openstt/ru_open_stt_opus_unpacked/'


def audio_player(audio_path):
    return '<audio preload="none" controls="controls"><source src="{}" type="audio/wav"></audio>'.format(audio_path)

def display_manifest(manifest_df):
    display_df = manifest_df
    display_df['wav'] = [audio_player(prepend_path+path) for path in display_df.wav_path]
    display_df['txt'] = [read_txt_file(prepend_path+path) for path in tqdm(display_df.text_path)]
    audio_style = '<style>audio {height:44px;border:0;padding:0 20px 0px;margin:-10px -20px -20px;}</style>'
    display_df = display_df[['wav','txt', 'duration']]
    display(HTML(audio_style + display_df.to_html(escape=False)))
    del display_df
    gc.collect()

Jouer avec un jeu de données

Lire un échantillon de fichiers

La plupart des navigateurs de plateformes prennent en charge la lecture audio native. Nous pouvons donc utiliser des lecteurs audio HTML5 pour consulter nos données.

manifest_df = read_manifest(prepend_path +'/manifests/public_series_1.csv')
#manifest_df = reroot_manifest(manifest_df,
                              #source_path='',
                              #target_path='../../../../../nvme/stt/data/ru_open_stt/')

sample = manifest_df.sample(n=20)
display_manifest(sample)

Lire un fichier

!ls ru_open_stt_opus/manifests/*.csv

Quelques exemples montrant comment lire au mieux les fichiers WAV et opus.

Scipy est le plus rapide pour le format WAV. Pysoundfile est dans l’ensemble le meilleur pour opus.

%matplotlib inline

import librosa
from scipy.io import wavfile
from librosa import display as ldisplay
from matplotlib import pyplot as plt

Lire un WAV

manifest_df = read_manifest(prepend_path +'manifests/asr_calls_2_val.csv')
#manifest_df = reroot_manifest(manifest_df,
                              #source_path='',
                              #target_path='../../../../../nvme/stt/data/ru_open_stt/')

sample = manifest_df.sample(n=5)
display_manifest(sample)

from io import BytesIO

wav_path = sample.iloc[0].wav_path
response = urlopen(prepend_path+wav_path)
data = response.read()
sr, wav = wavfile.read(BytesIO(data))
wav.astype('float32')
absmax = np.max(np.abs(wav))
wav =  wav / absmax

# shortest way to plot a spectrogram
D = librosa.amplitude_to_db(np.abs(librosa.stft(wav)), ref=np.max)
plt.figure(figsize=(12, 6))
ldisplay.specshow(D, y_axis='log')
plt.colorbar(format='%+2.0f dB')
plt.title('Log-frequency power spectrogram')
# shortest way to plot an envelope
plt.figure(figsize=(12, 6))
ldisplay.waveplot(wav, sr=sr, max_points=50000.0, x_axis='time', offset=0.0, max_sr=1000, ax=None)

Lire opus

manifest_df = read_manifest(prepend_path +'manifests/asr_public_phone_calls_2.csv')
#manifest_df = reroot_manifest(manifest_df,
                              #source_path='',
                              #target_path='../../../../../nvme/stt/data/ru_open_stt/')

sample = manifest_df.sample(n=5)
display_manifest(sample)

opus_path = sample.iloc[0].wav_path
response = urlopen(prepend_path+opus_path)
data = response.read()
wav, sr = sf.read(BytesIO(data))
wav.astype('float32')
absmax = np.max(np.abs(wav))
wav =  wav / absmax

# shortest way to plot a spectrogram
D = librosa.amplitude_to_db(np.abs(librosa.stft(wav)), ref=np.max)
plt.figure(figsize=(12, 6))
ldisplay.specshow(D, y_axis='log')
plt.colorbar(format='%+2.0f dB')
plt.title('Log-frequency power spectrogram')
# shortest way to plot an envelope
plt.figure(figsize=(12, 6))
ldisplay.waveplot(wav, sr=sr, max_points=50000.0, x_axis='time', offset=0.0, max_sr=1000, ax=None)

Étapes suivantes

Consultez les autres jeux de données du catalogue Open Datasets.

Partager via

Reconnaissance vocale ouverte pour le russe

Composition du jeu de données

Méthodologie d’annotation

Volumes de données et fréquence de mise à jour

Normalisation audio

Méthodologie de base de données sur disque

Téléchargements

Instructions de téléchargement

Téléchargement direct

Informations supplémentaires

Accès aux données

Azure Notebooks

Fonctions/dépendances de l’assistance

Génération de libsndfile

Fonctions/dépendances de l’assistance

Jouer avec un jeu de données

Lire un échantillon de fichiers

Lire un fichier

Lire un WAV

Lire opus

Étapes suivantes

Commentaires

Ressources supplémentaires