Arguably the largest public Russian STT dataset up to date:

• (new!) Now in .mp3 to reduce download time 7-8x;
• (new!) Now whole .wav version also available via torrent;
• ~4.6m utterances;
• ~4000 hours;
• 431 GB (in .wav format in int16);

Prove us wrong! Open issues, collaborate, submit a PR, contribute, share your datasets! Let's make STT in Russian (and more) as open and available as CV models.

Planned releases:

• 1000+ additional hours of YouTube;
• 1000-10,000 additional hours of books;
• Some validation / test sets;
• Plain benchmarks, "bad files";
• Mp3 torrent;
• Wav torrent;
• ... and more!;

Table of contents

• Dataset composition
• Downloads
  • Via torrent
  • Links
  • Download-instructions
  • Check md5sum
  • End-to-end download scripts
• Annotation methodology
• Audio normalization
• Disk db methodology
• Helper functions
• Contacts
• FAQ
• License
• Donations

(*) Automatic alignment

This alignment was performed using Yuri's alignment tool. Contact him if you need alignment for your own dataset.

Also shared a wav version via torrent.

Save us a couple of bucks, download via torrent:

• An MP3 version of the dataset;
• A WAV version of the dataset;

You can download separate files via torrent. Try several torrent clients if some do not work.

Meta data file.

1. Download each dataset separately:

Via wget

wget https://ru-open-stt.ams3.digitaloceanspaces.com/some_file

For multi-threaded downloads use aria2 with -x flag, i.e.

aria2c -c -x5 https://ru-open-stt.ams3.digitaloceanspaces.com/some_file

If necessary, merge chunks like this:

cat ru_open_stt_v01.tar.gz_* > ru_open_stt_v01.tar.gz

2. Download the meta data and manifests for each dataset:
3. Merge files (where applicable), unpack and enjoy!

Including links to deprecated files. md5sum /path/to/downloaded/file

You can use this script with this config file. Please check the config first. You can also contribute a similar script in python.

The dataset is compiled using open domain sources. Some audio types are annotated automatically and verified statistically / using heuristics.

All files are normalized for easier / faster runtime augmentations and processing as follows:

• Converted to mono, if necessary;
• Converted to 16 kHz sampling rate, if necessary;
• Stored as 16-bit integers;

Each audio file is hashed. Its hash is used to create a folder hierarchy for more optimal fs operation.

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)

Use helper functions from here for easier work with manifest files.

from utils.open_stt_utils import read_manifest

manifest_df = read_manifest('path/to/manifest.csv')

from utils.open_stt_utils import (plain_merge_manifests,
                                  check_files,
                                  save_manifest)
train_manifests = [
 'path/to/manifest1.csv',
 'path/to/manifest2.csv',
]
train_manifest = plain_merge_manifests(train_manifests,
                                        MIN_DURATION=0.1,
                                        MAX_DURATION=100)
check_files(train_manifest)
save_manifest(train_manifest,
             'my_manifest.csv')

Please contact us here or just create a GitHub issue!

Authors in alphabetic order:

• Anna Slizhikova;
• Alexander Veysov;
• Dmitry Voronin;
• Yuri Baburov;

Mostly we used pydub (via ffmpeg) to convert to MP3. We omitted blank files (YouTube mostly). We used the following parameters:

• 16kHz;
• 32 kbps;
• Mono;

Usually 128-192 kbps is enough for music with sr of 44 kHz, 64-96 is enough for speech. But here we have mono, 16 kHz and usually only one speaker. So 32 kbps was a good choice. We did not use other formats like .ogg, because .mp3 is much more popular.

from pydub import AudioSegment

sound = AudioSegment.from_file(temp_path,
                               format="wav")

file_handle = sound.export(store_mp3_path,
                           format="mp3",
                           parameters =["-ar", "{}".format(str(16000)),"-ac", "1"],
                           bitrate="{}k".format(str(32)))

It is up to you, but to save space and spare CPU during training, I would suggest the following pipeline to extract the files:

# you can also use pydub, torchaudio, sox or whatever
# we ended up using scipy for speed
# this example also includes hashing step which is not necessary
import librosa
import hashlib
import numpy as np
from pathlib import Path
from scipy.io import wavfile

def save_wav_diskdb(wav,
                    root_folder='../data/ru_open_stt/',
                    target_sr=16000):
    assert type(wav) == np.ndarray
    assert wav.dtype == np.dtype('int16')
    assert len(wav.shape)==1

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

    # f_path = Path(audio_path)
    f_hash = hashlib.sha1(wavb).hexdigest()

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

    store_path.parent.mkdir(parents=True,
                            exist_ok=True)

    wavfile.write(filename=str(store_path),
                  rate=target_sr,
                  data=wav)

    return str(store_path)

root_folder = '../data/'
# save to int16, mono, 16 kHz to save space
target_dtype = np.dtype('int16')
target_sr = 16000
# librosa reads mp3
wav, sr = librosa.load(source_mp3_path,
                       mono=True,
                       sr=target_sr)

# librosa converts to float32 by default
wav = (wav * 32767).astype(target_dtype) # cast to int

wav_path = save_wav_diskdb(wav,
                           root_folder=root_folder,
                           target_sr=target_sr)

from scipy.io import wavfile

sample_rate, sound = wavfile.read(path)

abs_max = np.abs(sound).max()
sound = sound.astype('float32')
if abs_max>0:
    sound *= 1/abs_max

We are not altruists, life just is not a zero sum game.

Consider the progress in computer vision, that was made possible by:

• Public datasets;
• Public pre-trained models;
• Open source frameworks;
• Open research;

TTS does not enjoy the same attention by ML community because it is data hungry and public datasets are lacking, especially for languages other than English. Ultimately it leads to worse-off situation for the general community.

• Blank files in Youtube dataset. Removed in mp3 archive. Meta-data not cleaned;
• Some files that have low values / crash with tochaudio;
• Looks like scipy does not always write meta-data when saving wavs (or you should save (N,1) shaped file) - this can be fixed as shown above;

Dual license, cc-by-nc and commercial usage available after agreement with dataset authors. Except for VoxForge, its license is GNU GPL 3.0. Except for Caito.de dataset, its licence is here.

Donate (each coffee pays for several full downloads) / use our DO referral link to help.