Russian Open Speech To Text

Eine Sammlung von Sprachbeispielen, die aus verschiedenen Sprachquellen stammen. Das Dataset enthält kurze Audiodateien auf Russisch.

Hinweis

Microsoft stellt Datasets der Plattform Azure Open Datasets auf einer „As is“-Basis (d. h. ohne Mängelgewähr) zur Verfügung. Microsoft übernimmt weder ausdrücklich noch stillschweigend die Gewährleistung für Ihre Nutzung der Datasets und sichert keinerlei Garantien oder Bedingungen zu. Soweit nach örtlich anwendbarem Recht zulässig, lehnt Microsoft jegliche Haftung für Schäden oder Verluste ab. Dies schließt direkte, indirekte, besondere oder zufällige Schäden oder Verluste sowie Folge- und Strafschäden und damit verbundene Verluste ein, die sich aus Ihrer Nutzung der Datasets ergeben.

Für die Bereitstellung dieses Datasets gelten die ursprünglichen Nutzungsbedingungen, unter denen Microsoft die Quelldaten bezogen hat. Das Dataset kann Daten von Microsoft enthalten.

Dieses STT-Dataset (Spracherkennung) für Russisch umfasst Folgendes:

  • ~16 Millionen Äußerungen
  • ~20.000 Stunden
  • 2,3 TB (unkomprimiert im WAV-Format in int16), 356G in OPUS
  • Alle Dateien (außer Datasets zur Validierung) wurden ins OPUS-Format konvertiert

Das Dataset dient hauptsächlich dem Trainieren von Spracherkennungsmodellen.

Zusammensetzung des Datasets

Die Datasetgröße wird für WAV-Dateien angegeben.

DATASET ÄUSSERUNGEN STUNDEN GB SEKUNDEN/ZEICHEN COMMENT ANMERKUNG QUALITÄT/RAUSCHEN
radio_v4 (*) 7.603.192 10.430 1.195 5 Sek./68 Radio Ausrichten 95 %/klar
public_speech (*) 1.700.060 2.709 301 6 Sek/79 Öffentlicher Vortrag Ausrichten 95 %/klar
audiobook_2 1.149.404 1.511 162 5 Sek./56 Bücher Ausrichten 95 %/klar
radio_2 651.645 1.439 154 8 Sek./110 Radio Ausrichten 95 %/klar
public_youtube1120 1.410.979 1.104 237 3 Sek./34 Youtube Untertitel 95 %/~klar
public_youtube700 759.483 701 75 3 Sek./43 Youtube Untertitel 95 %/überwiegend klar
tts_russian_addresses 1.741.838 754 81 2 Sek./20 Adressen TTS, 4 Stimmen 100 %/klar
asr_public_phone_calls_2 603.797 601 66 4 Sek./37 Telefonanrufe ASR 70 %/rauschend
public_youtube1120_hq 369.245 291 31 3 Sek./37 YouTube (hohe Qualität) Untertitel 95 %/überwiegend klar
asr_public_phone_calls_1 233.868 211 23 3 Sek./29 Telefonanrufe ASR 70 %/rauschend
radio_v4_add (*) 92.679 157 18 6 Sek/80 Radio Ausrichten 95 %/klar
asr_public_stories_2 78.186 78 9 4 Sek./43 Bücher ASR 80 %/klar
asr_public_stories_1 46.142 38 4 3 Sek./30 Bücher ASR 80 %/klar
public_series_1 20.243 17 2 3 Sek./38 Youtube Untertitel 95 %/überwiegend klar
asr_calls_2_val 12.950 7,7 2 2 Sek./34 Telefonanrufe Manuelle Annotation 99 %/klar
public_lecture_1 6.803 6 1 3 Sek./47 Vorlesungen Untertitel 95 %/klar
buriy_audiobooks_2_val 7.850 4,9 1 2 Sek./31 Bücher Manuelle Annotation 99 %/klar
public_youtube700_val 7.311 4,5 1 2 Sek./35 Youtube Manuelle Annotation 99 %/klar

(*) Nur eine Stichprobe der Daten wird in den TXT-Dateien bereitgestellt.

Annotationsmethodik

Das Dataset wurde aus öffentlichen Quellen zusammengestellt. Lange Sequenzen werden mithilfe von Sprechaktivitätserkennung und -angleichung in kleine Audiodateien aufgeteilt. Einige Audioformate werden automatisch annotiert und statistisch mithilfe der Heuristik verifiziert.

Datenvolumes und Aktualisierungshäufigkeit

Die Gesamtgröße des Datasets beträgt 350 GB. Die Gesamtgröße des Datasets mit öffentlich freigegebenen Bezeichnungen beträgt 130 GB.

Es ist unwahrscheinlich, dass das Dataset in Zukunft hinsichtlich der Abwärtskompatibilität aktualisiert wird. Nutzen Sie das Originalrepository für Benchmarks und zum Ausschließen von Dateien.

Neue Fachbereiche und Sprachen werden in Zukunft ggf. hinzugefügt.

Audionormalisierung

Alle Dateien sind für einfachere und schnellere Anstiege der Runtime normalisiert. Die Verarbeitung erfolgt wie folgt:

  • Bei Bedarf wurden sie in Mono konvertiert.
  • Bei Bedarf wurden sie in eine Samplingrate von 16 kHz konvertiert.
  • Sie wurden als 16-Bit-Integer gespeichert.
  • Sie wurden ins OPUS-Format konvertiert.

Datenbankmethodik auf dem Datenträger

Jede Audiodatei (WAV-Dateien, Binärdateien) wurde gehasht. Der Hash wird verwendet, um eine Ordnerhierarchie für einen verbesserten Betrieb des Dateisystems zu erstellen.

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)

Downloads

Das Dataset wird in zwei Formaten bereitgestellt:

Ordnerstruktur:

└── 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
DATASET GB, WAV GB, ARCHIV ARCHIVIEREN QUELLE MANIFEST
Trainieren
Stichprobe für Radio und öffentliche Vorträge - 11.4 OPUS- und TXT-Format - manifest
audiobook_2 162 25,8 OPUS- und TXT-Format Internet und Angleichung manifest
radio_2 154 24,6 OPUS- und TXT-Format Radio manifest
public_youtube1120 237 19,0 OPUS- und TXT-Format YouTube-Videos manifest
asr_public_phone_calls_2 66 9.4 OPUS- und TXT-Format Internet und ASR manifest
public_youtube1120_hq 31 4,9 OPUS- und TXT-Format YouTube-Videos manifest
asr_public_stories_2 9 1.4 OPUS- und TXT-Format Internet und Angleichung manifest
tts_russian_addresses_rhvoice_4voices 80.9 12,9 OPUS- und TXT-Format TTS manifest
public_youtube700 75.0 12,2 OPUS- und TXT-Format YouTube-Videos manifest
asr_public_phone_calls_1 22.7 3.2 OPUS- und TXT-Format Internet und ASR manifest
asr_public_stories_1 4,1 0.7 OPUS- und TXT-Format Öffentliche Storys manifest
public_series_1 1.9 0,3 OPUS- und TXT-Format Öffentliche Reihen manifest
public_lecture_1 0.7 0.1 OPUS- und TXT-Format Internet und manuell manifest
Val
asr_calls_2_val 2 0.8 WAV- und TXT-Format Internet manifest
buriy_audiobooks_2_val 1 0,5 WAV- und TXT-Format Bücher und manuell manifest
public_youtube700_val 2 0,13 WAV- und TXT-Format YouTube-Videos und manuell manifest

Downloadanweisungen

Direkter Download

Anweisungen zum direkten Herunterladen des Datasets finden Sie auf der GitHub-Seite mit Anweisungen zum Herunterladen.

Zusätzliche Informationen

Wenn Sie Hilfe oder Fragen zu den Daten haben, wenden Sie sich unter aveysov@gmail.com an die Verfasser der Daten.

Diese Lizenz gewährt es Benutzern, diese Materialien für nicht kommerzielle Zwecke über ein beliebiges Medium und in beliebigem Format zu verbreiten, zu mischen, anzuwenden oder weiterzuentwickeln, sofern eine Zuschreibung an den Ersteller verfasst wird. Sie besteht aus folgenden Elementen:

  • BY: Der Ersteller muss erwähnt werden.
  • NC: Nur die nicht kommerzielle Verwendung der Arbeit ist zulässig.

Die CC-BY-NC-Nutzung und die kommerzielle Nutzung sind nur mit Genehmigung des Datasetautors zulässig.

Datenzugriff

Azure Notebooks

Hilfsfunktionen/Abhängigkeiten

Erstellen von libsndfile

Eine effiziente Möglichkeit zum Lesen von OPUS-Dateien in Python, die keinen erheblichen Mehraufwand verursachen, ist die Verwendung von pysoundfile (ein Python CFFI-Wrapper um libsoundfile).

Die OPUS-Unterstützung wurde upstream implementiert, wurde aber nicht ordnungsgemäß freigegeben. Deshalb haben wir uns für das Erstellen von benutzerdefinierten Builds und Affen-Patches entschieden.

Normalerweise müssen Sie dies in Ihrer Shell mit sudo-Zugriff ausführen:

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 .

Hilfsfunktionen/Abhängigkeiten

Installieren Sie die folgenden Bibliotheken:

pandas
numpy
scipy
tqdm
soundfile
librosa

Manifeste sind CSV-Dateien mit den folgenden Spalten:

  • Pfad zu Audio
  • Pfad zur Textdatei
  • Duration

Sie erwiesen sich als das einfachste Format für den Zugriff auf Daten.

Zur einfacheren Verwendung wurde allen Manifesten bereits ein neuer Stamm zugeordnet. Alle darin enthaltenen Pfade sind relativ. Sie müssen einen Stammordner bereitstellen.

# 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()

Wiedergabe mit einem Dataset

Wiedergabe eines Beispiels von Dateien

Die Browser der meisten Plattformen unterstützen die native Audiowiedergabe. Wir können also HTML5-Audioplayer verwenden, um unsere Daten anzuzeigen.

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)

Lesen einer Datei

!ls ru_open_stt_opus/manifests/*.csv

Einige Beispiele, die veranschaulichen, wie WAV- und OPUS-Dateien am besten gelesen werden.

Scipy ist die schnellste Option für WAV-Dateien. Pysoundfile ist insgesamt am besten für OPUS-Dateien geeignet.

%matplotlib inline

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

Lesen einer WAV-Datei

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)

Lesen einer OPUS-Datei

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)

Nächste Schritte

Machen Sie sich mit den restlichen Datasets im Open Datasets-Katalog vertraut.