Compartilhar via


Conversão de fala em texto em russo

Uma coleção de amostras de fala de várias fontes de áudio. O conjunto de dados contém clipes de áudio curtos em russo.

Observação

A Microsoft fornece o Azure Open Datasets no estado em que se encontra. A Microsoft não oferece garantias nem coberturas, expressas ou implícitas, em relação ao uso dos conjuntos de dados. Até o limite permitido pela legislação local, a Microsoft se exime de toda a obrigação por danos ou perdas, inclusive diretos, consequentes, especiais, indiretos, acidentais ou punitivos, resultantes do uso dos conjuntos de dados.

Esse conjunto de dados é fornecido de acordo com os termos originais com que a Microsoft recebeu os dados de origem. O conjunto de dados pode incluir dados originados da Microsoft.

Esse conjunto de STT (conversão de fala em texto) em russo inclui:

  • aprox. 16 milhões enunciados
  • aprox. 20.000 horas
  • 2.3 TB (descompactados no formato .wav em int16), 356G em opus
  • Todos os arquivos foram transformados para opus, exceto os conjuntos de dados de validação

A principal finalidade do conjunto de dados é treinar modelos de conversão de fala em texto.

Composição do conjunto de dados

O tamanho do conjunto de dados é fornecido para arquivos .wav.

CONJUNTO DE DADOS ENUNCIADOS HORAS GB SEGUNDOS/CARACTERES COMMENT ANOTAÇÃO QUALIDADE/RUÍDO
radio_v4 (*) 7\.603.192 10.430 1\.195 5s/68 Opção Alinhar 95%/nítido
public_speech (*) 1\.700.060 2\.709 301 6s/79 Discurso público Alinhar 95%/nítido
audiobook_2 1\.149.404 1\.511 162 5s/56 Manuais Alinhar 95%/nítido
radio_2 651.645 1\.439 154 8s/110 Opção Alinhar 95%/nítido
public_youtube1120 1\.410.979 1.104 237 3s/34 Youtube Subtítulos 95% /~nítido
public_youtube700 759.483 701 75 3s/43 Youtube Subtítulos 95%/~nítido
tts_russian_addresses 1\.741.838 754 81 2s/20 Endereços Vozes TTS 4 100%/nítido
asr_public_phone_calls_2 603.797 601 66 4s/37 Chamadas telefônicas ASR 70%/com ruído
public_youtube1120_hq 369.245 291 31 3s/37 Matriz do YouTube Subtítulos 95%/~nítido
asr_public_phone_calls_1 233.868 211 23 3s/29 Chamadas telefônicas ASR 70%/com ruído
radio_v4_add (*) 92.679 157 18 6s/80 Opção Alinhar 95%/nítido
asr_public_stories_2 78.186 78 9 4s/43 Manuais ASR 80%/nítido
asr_public_stories_1 46.142 38 4 3s/30 Manuais ASR 80%/nítido
public_series_1 20.243 17 2 3s/38 Youtube Subtítulos 95%/~nítido
asr_calls_2_val 12.950 7,7 2 2s/34 Chamadas telefônicas Anotação manual 99%/nítido
public_lecture_1 6\.803 6 1 3s/47 Palestras Subtítulos 95%/nítido
buriy_audiobooks_2_val 7\.850 4,9 1 2s/31 Manuais Anotação manual 99%/nítido
public_youtube700_val 7\.311 4,5 1 2s/35 Youtube Anotação manual 99%/nítido

(*) Apenas uma amostra dos dados é fornecida com arquivos txt.

Metodologia da anotação

O conjunto de dados é compilado usando software livre. As sequências longas são divididas em partes de áudio usando detecção de atividades de voz e alinhamento. Alguns tipos de áudio são anotados automaticamente e verificados estatisticamente usando heurística.

Volumes de dados e frequência de atualização

O tamanho total do conjunto de dados é de 350 GB. O tamanho total do conjunto de dados com rótulos compartilhados publicamente é de 130 GB.

É improvável que o conjunto de dados em si seja atualizado para ser compatível com versões anteriores. Acompanhe o repositório original para ver os parâmetros de comparação e excluir arquivos.

Novos domínios e idiomas podem ser adicionados no futuro.

Normalização de áudio

Todos os arquivos são normalizados para facilitar e agilizar aumentos de runtime. O processo é o seguinte:

  • Convertidos em mono, se necessário;
  • Convertidos a uma taxa de amostragem de 16 kHz, se necessário;
  • Armazenados como inteiros de 16 bits;
  • Convertidos em OPUS;

Metodologia de BD no disco

Cada arquivo de áudio (wav, binário) tem hash. O hash é usado para criar uma hierarquia de pastas para obter uma operação fs ideal.

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

O conjunto de dados é fornecido de duas formas:

  • Arquivos disponíveis por meio do armazenamento de blobs do Azure e/ou links diretos;
  • Arquivos originais disponíveis por meio do armazenamento de blobs do Azure; Tudo está armazenado em 'https://azureopendatastorage.blob.core.windows.net/openstt/ '

Estrutura de pastas:

└── 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
CONJUNTO DE DADOS GB, WAV GB, ARQUIVO ARQUIVAR ORIGEM MANIFESTO
Treinar
Amostra de rádio e discurso público - 11,4 opus+txt - manifest
audiobook_2 162 25,8 opus+txt Internet + alinhamento manifest
radio_2 154 24,6 opus+txt Opção manifest
public_youtube1120 237 19,0 opus+txt Vídeos do YouTube manifest
asr_public_phone_calls_2 66 9,4 opus+txt Internet + ASR manifest
public_youtube1120_hq 31 4.9 opus+txt Vídeos do YouTube manifest
asr_public_stories_2 9 1.4 opus+txt Internet + alinhamento manifest
tts_russian_addresses_rhvoice_4voices 80,9 12,9 opus+txt TTS manifest
public_youtube700 75,0 12,2 opus+txt Vídeos do 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 Histórias públicas manifest
public_series_1 1,9 0.3 opus+txt Série pública manifest
public_lecture_1 0,7 0,1 opus+txt Internet + manual manifest
Val
asr_calls_2_val 2 0,8 wav+txt Internet manifest
buriy_audiobooks_2_val 1 0,5 wav+txt Livros + manual manifest
public_youtube700_val 2 0.13 wav+txt Vídeos do YouTube + manual manifest

Instruções de download

Download direto

Para obter instruções sobre como fazer o download do conjunto de dados diretamente, consulte a página de instruções de download do GitHub.

Informações adicionais

Para obter ajuda ou tirar dúvidas sobre os dados, contate os autores de dados em aveysov@gmail.com

Esta licença permite que os usuários distribuam, remixem, adaptem e compilem o material em qualquer meio ou formato, apenas para fins não comerciais e somente enquanto a atribuição for concedida ao criador. Ela inclui os seguintes elementos:

  • BY – o crédito deve ser concedido ao criador
  • NC – é permitido somente para uso não comercial do trabalho

CC-BY-NC e uso comercial disponíveis após o contrato com os autores do conjunto de dados.

Acesso de dados

Azure Notebooks

Funções/dependências auxiliares

compilação do libsndfile

Uma maneira eficiente de ler arquivos Opus em Python que não incorrem em sobrecarga significativa é usar o pysoundfile (um wrapper Python CFFI do libsoundfile).

O suporte a Opus foi implementado em upstream, mas não foi lançado adequadamente. Sendo assim, optamos por patches de build + monkey personalizados.

Geralmente é preciso executar isso em seu shell com acesso ao 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 .

Funções/dependências auxiliares

Instale as seguintes bibliotecas:

pandas
numpy
scipy
tqdm
soundfile
librosa

Os manifestos são arquivos CSV com as seguintes colunas:

  • Caminho para o áudio
  • Caminho para o arquivo de texto
  • Duração

Eles provaram ser o formato mais simples para acessar os dados.

Para facilitar o uso, todos os manifestos já foram colocados no raiz novamente. Todos os caminhos neles são relativos, você precisa fornecer um diretório raiz.

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

Executar com um conjunto de dados

Executar uma amostra de arquivos

A maioria dos navegadores de plataformas suporta a reprodução de áudios nativos. Portanto, podemos usar os players de áudio HTML5 para exibir nossos dados.

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)

Ler um arquivo

!ls ru_open_stt_opus/manifests/*.csv

Alguns exemplos mostram como ler melhor os arquivos WAV e Opus.

O SciPy é o mais rápido para WAV. O Pysoundfile é o melhor no geral para Opus.

%matplotlib inline

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

Ler um 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)

Ler 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)

Próximas etapas

Exiba o restante dos conjuntos de dados no catálogo do Open Datasets.