Una guida completa ai dataset audio
Guida ai dataset audio
Introduzione
🤗 Datasets è una libreria open source per il download e la preparazione di dataset provenienti da tutti i domini. La sua API minimalista consente agli utenti di scaricare e preparare dataset con una sola riga di codice Python, con una serie di funzioni che consentono un efficiente pre-processing. Il numero di dataset disponibili è senza pari, con tutti i dataset di machine learning più popolari disponibili per il download.
Ma non solo, 🤗 Datasets è dotato di diverse funzionalità specifiche per l’audio che facilitano il lavoro con dataset audio sia per i ricercatori che per i professionisti. In questo articolo, mostreremo queste funzionalità, dimostrando perché 🤗 Datasets è il punto di riferimento per il download e la preparazione di dataset audio.
Contenuti
- Il Hub
- Caricare un Dataset Audio
- Semplice da Caricare, Semplice da Processare
- Modalità Streaming: La Soluzione Perfetta
- Un Tour dei Dataset Audio su Hub
- Osservazioni Finali
Il Hub
Il Hugging Face Hub è una piattaforma per l’hosting di modelli, dataset e demo, tutti open source e disponibili pubblicamente. È sede di una crescente collezione di dataset audio che spaziano in vari domini, task e lingue. Attraverso integrazioni strette con 🤗 Datasets, tutti i dataset su Hub possono essere scaricati con una sola riga di codice.
- Parliamo di pregiudizi nell’apprendimento automatico! Newsletter sull’etica e la società #2
- Schede dei modelli
- Segmentazione delle immagini senza etichette con CLIPSeg
Andiamo al Hub e filtriamo i dataset per task:
- Dataset Riconoscimento Vocale su Hub
- Dataset Classificazione Audio su Hub
Al momento della scrittura, ci sono 77 dataset di riconoscimento vocale e 28 dataset di classificazione audio su Hub, con questi numeri in costante aumento. Puoi selezionare uno qualsiasi di questi dataset in base alle tue esigenze. Diamo un’occhiata al primo risultato di riconoscimento vocale. Cliccando su common_voice compare la scheda del dataset:
Qui possiamo trovare informazioni aggiuntive sul dataset, vedere su quali modelli è stato addestrato e, cosa più interessante, ascoltare campioni audio effettivi. L’anteprima del dataset viene mostrata nel centro della scheda del dataset. Ci mostra i primi 100 campioni per ogni sottoinsieme e divisione. Inoltre, carica i campioni audio pronti per essere ascoltati in tempo reale. Se facciamo clic sul pulsante di riproduzione del primo campione, possiamo ascoltare l’audio e vedere il testo corrispondente.
L’anteprima del dataset è un modo brillante per sperimentare i dataset audio prima di impegnarsi nell’uso di essi. Puoi selezionare qualsiasi dataset su Hub, scorrere i campioni e ascoltare l’audio per i diversi sottoinsiemi e divisioni, valutando se è il dataset giusto per le tue esigenze. Una volta selezionato un dataset, è banale caricare i dati in modo da poter iniziare a usarli.
Caricare un Dataset Audio
Una delle caratteristiche distintive chiave di 🤗 Datasets è la capacità di scaricare e preparare un dataset con una sola riga di codice Python. Questo è reso possibile attraverso la funzione load_dataset. Convenzionalmente, il caricamento di un dataset comporta: i) il download dei dati grezzi, ii) l’estrazione dal formato compresso e iii) la preparazione dei singoli campioni e divisioni. Utilizzando load_dataset, tutto il lavoro pesante viene svolto internamente.
Prendiamo ad esempio il caricamento del dataset GigaSpeech da Speech Colab. GigaSpeech è un dataset di riconoscimento vocale relativamente recente per il benchmarking dei sistemi di riconoscimento vocale accademici ed è uno dei tanti dataset audio disponibili su Hugging Face Hub.
Per caricare il dataset GigaSpeech, basta prendere l’identificatore del dataset su Hub ( speechcolab/gigaspeech ) e specificarlo alla funzione load_dataset. GigaSpeech è disponibile in cinque configurazioni di dimensioni crescenti, che vanno da xs (10 ore) a xl (10.000 ore). Per scopi didattici, caricheremo la configurazione più piccola. L’identificatore del dataset e la configurazione desiderata sono tutto ciò di cui abbiamo bisogno per scaricare il dataset:
from datasets import load_dataset
gigaspeech = load_dataset("speechcolab/gigaspeech", "xs")
print(gigaspeech)Output di stampa:
DatasetDict({
train: Dataset({
features: ['segment_id', 'speaker', 'text', 'audio', 'begin_time', 'end_time', 'audio_id', 'title', 'url', 'source', 'category', 'original_full_path'],
num_rows: 9389
})
validation: Dataset({
features: ['segment_id', 'speaker', 'text', 'audio', 'begin_time', 'end_time', 'audio_id', 'title', 'url', 'source', 'category', 'original_full_path'],
num_rows: 6750
})
test: Dataset({
features: ['segment_id', 'speaker', 'text', 'audio', 'begin_time', 'end_time', 'audio_id', 'title', 'url', 'source', 'category', 'original_full_path'],
num_rows: 25619
})
})E così, abbiamo il dataset GigaSpeech pronto! Non esiste un modo più semplice per caricare un dataset audio. Possiamo vedere che abbiamo i set di addestramento, validazione e test pre-partizionati, con le relative informazioni per ciascuno.
L’oggetto gigaspeech restituito dalla funzione load_dataset è un DatasetDict. Possiamo trattarlo in modo simile a un dizionario Python normale. Per ottenere il set di addestramento, passiamo la chiave corrispondente al dizionario gigaspeech:
print(gigaspeech["train"])Output di stampa:
Dataset({
features: ['segment_id', 'speaker', 'text', 'audio', 'begin_time', 'end_time', 'audio_id', 'title', 'url', 'source', 'category', 'original_full_path'],
num_rows: 9389
})Questo restituisce un oggetto Dataset, che contiene i dati per il set di addestramento. Possiamo andare un livello più in profondità e ottenere il primo elemento del set. Anche in questo caso, è possibile utilizzare l’indicizzazione standard di Python:
print(gigaspeech["train"][0])Output di stampa:
{'segment_id': 'YOU0000000315_S0000660',
'speaker': 'N/A',
'text': "AS THEY'RE LEAVING <COMMA> CAN KASH PULL ZAHRA ASIDE REALLY QUICKLY <QUESTIONMARK>",
'audio': {'path': '/home/sanchit_huggingface_co/.cache/huggingface/datasets/downloads/extracted/7f8541f130925e9b2af7d37256f2f61f9d6ff21bf4a94f7c1a3803ec648d7d79/xs_chunks_0000/YOU0000000315_S0000660.wav',
'array': array([0.0005188 , 0.00085449, 0.00012207, ..., 0.00125122, 0.00076294,
0.00036621], dtype=float32),
'sampling_rate': 16000
},
'begin_time': 2941.889892578125,
'end_time': 2945.070068359375,
'audio_id': 'YOU0000000315',
'title': 'Return to Vasselheim | Critical Role: VOX MACHINA | Episode 43',
'url': 'https://www.youtube.com/watch?v=zr2n1fLVasU',
'source': 2,
'category': 24,
'original_full_path': 'audio/youtube/P0004/YOU0000000315.opus',
}Possiamo vedere che ci sono diverse caratteristiche restituite dal set di addestramento, tra cui segment_id, speaker, text, audio e altro ancora. Per il riconoscimento del parlato, ci interesseranno le colonne text e audio.
Utilizzando il metodo remove_columns di 🤗 Datasets, possiamo rimuovere le caratteristiche del dataset non necessarie per il riconoscimento del parlato:
COLUMNS_TO_KEEP = ["text", "audio"]
all_columns = gigaspeech["train"].column_names
columns_to_remove = set(all_columns) - set(COLUMNS_TO_KEEP)
gigaspeech = gigaspeech.remove_columns(columns_to_remove)Controlliamo che abbiamo mantenuto con successo le colonne text e audio:
print(gigaspeech["train"][0])Output della stampa:
{'text': "AS THEY'RE LEAVING <COMMA> CAN KASH PULL ZAHRA ASIDE REALLY QUICKLY <QUESTIONMARK>",
'audio': {'path': '/home/sanchit_huggingface_co/.cache/huggingface/datasets/downloads/extracted/7f8541f130925e9b2af7d37256f2f61f9d6ff21bf4a94f7c1a3803ec648d7d79/xs_chunks_0000/YOU0000000315_S0000660.wav',
'array': array([0.0005188 , 0.00085449, 0.00012207, ..., 0.00125122, 0.00076294,
0.00036621], dtype=float32),
'sampling_rate': 16000}}Ottimo! Possiamo vedere che abbiamo ottenuto le due colonne richieste text e audio. Il text è una stringa con la trascrizione di esempio e il audio è un array monodimensionale di valori di ampiezza a una frequenza di campionamento di 16KHz. Abbiamo caricato il nostro dataset!
Facile da Caricare, Facile da Elaborare
Caricare un dataset con 🤗 Datasets è solo metà del divertimento. Possiamo ora utilizzare la suite di strumenti disponibili per pre-elaborare efficientemente i nostri dati, pronti per l’addestramento o l’inferenza del modello. In questa sezione, eseguiremo tre fasi di pre-elaborazione dei dati:
- Ricampionaggio dei Dati Audio
- Funzione di Pre-elaborazione
- Funzione di Filtraggio
1. Ricampionaggio dei Dati Audio
La funzione load_dataset prepara i campioni audio con la frequenza di campionamento con cui sono stati pubblicati. Questa non è sempre la frequenza di campionamento prevista dal nostro modello. In questo caso, dobbiamo ricampionare l’audio alla frequenza di campionamento corretta.
Possiamo impostare gli input audio alla frequenza di campionamento desiderata utilizzando il metodo cast_column di 🤗 Datasets. Questa operazione non modifica l’audio direttamente, ma segnala a datasets di ricampionare i campioni audio al volo durante il caricamento. Il seguente blocco di codice imposterà la frequenza di campionamento a 8kHz:
from datasets import Audio
gigaspeech = gigaspeech.cast_column("audio", Audio(sampling_rate=8000))Ricaricando il primo campione audio nel dataset GigaSpeech, lo ricampioneremo alla frequenza di campionamento desiderata:
print(gigaspeech["train"][0])Output della stampa:
{'text': "AS THEY'RE LEAVING <COMMA> CAN KASH PULL ZAHRA ASIDE REALLY QUICKLY <QUESTIONMARK>",
'audio': {'path': '/home/sanchit_huggingface_co/.cache/huggingface/datasets/downloads/extracted/7f8541f130925e9b2af7d37256f2f61f9d6ff21bf4a94f7c1a3803ec648d7d79/xs_chunks_0000/YOU0000000315_S0000660.wav',
'array': array([ 0.00046338, 0.00034808, -0.00086153, ..., 0.00099299,
0.00083484, 0.00080221], dtype=float32),
'sampling_rate': 8000}
}Possiamo vedere che la frequenza di campionamento è stata ridotta a 8kHz. I valori dell’array sono anche diversi, poiché ora abbiamo approssimativamente un valore di ampiezza per ogni due che avevamo prima. Impostiamo nuovamente la frequenza di campionamento del dataset a 16kHz, la frequenza di campionamento prevista dalla maggior parte dei modelli di riconoscimento vocale:
gigaspeech = gigaspeech.cast_column("audio", Audio(sampling_rate=16000))
print(gigaspeech["train"][0])Stampa Output:
{'text': "MENTRE ESCE <VIRGOLA> KASH PUÒ TIRARE ZAHRA DA PARTE MOLTO VELOCEMENTE <PUNTO INTERROGATIVO>",
'audio': {'path': '/home/sanchit_huggingface_co/.cache/huggingface/datasets/downloads/extracted/7f8541f130925e9b2af7d37256f2f61f9d6ff21bf4a94f7c1a3803ec648d7d79/xs_chunks_0000/YOU0000000315_S0000660.wav',
'array': array([0.0005188 , 0.00085449, 0.00012207, ..., 0.00125122, 0.00076294,
0.00036621], dtype=float32),
'sampling_rate': 16000}
}Semplice! cast_column fornisce un meccanismo diretto per il campionamento di dataset audio quando richiesto.
2. Funzione di Pre-elaborazione
Uno degli aspetti più sfidanti nel lavorare con dataset audio è la preparazione dei dati nel giusto formato per il nostro modello. Utilizzando il metodo map di 🤗 Datasets, possiamo scrivere una funzione per la pre-elaborazione di un singolo campione del dataset, e poi applicarla a ogni campione senza alcuna modifica del codice.
Per prima cosa, carichiamo un oggetto processore da 🤗 Transformers. Questo processore pre-elabora l’audio in input e tokenizza il testo target in etichette. La classe AutoProcessor viene utilizzata per caricare un processore da un checkpoint di modello specifico. Nell’esempio, carichiamo il processore dal checkpoint OpenAI’s Whisper VoAGI.en, ma puoi cambiarlo con qualsiasi identificatore di modello sull’Hugging Face Hub:
from transformers import AutoProcessor
processor = AutoProcessor.from_pretrained("openai/whisper-VoAGI.en")Perfetto! Ora possiamo scrivere una funzione che prende un singolo campione di addestramento e lo passa attraverso il processore per prepararlo per il nostro modello. Calcoleremo anche la lunghezza di input di ogni campione audio, informazione che ci servirà per la prossima fase di preparazione dei dati:
def prepara_dataset(batch):
audio = batch["audio"]
batch = processore(audio["array"], sampling_rate=audio["sampling_rate"], text=batch["text"])
batch["input_length"] = len(audio["array"]) / audio["sampling_rate"]
return batchPossiamo applicare la funzione di preparazione dei dati a tutti i nostri esempi di addestramento utilizzando il metodo map di 🤗 Datasets. Qui, rimuoviamo anche le colonne text e audio, poiché abbiamo pre-elaborato l’audio in input e tokenizzato il testo in etichette:
gigaspeech = gigaspeech.map(prepara_dataset, remove_columns=gigaspeech["train"].column_names)3. Funzione di Filtraggio
Prima dell’addestramento, potremmo avere una euristica per filtrare i nostri dati di addestramento. Ad esempio, potremmo voler filtrare i campioni audio più lunghi di 30 secondi per evitare di troncare i campioni audio o rischiare errori di memoria insufficiente. Possiamo fare questo nello stesso modo in cui abbiamo preparato i dati per il nostro modello nel passaggio precedente.
Iniziamo scrivendo una funzione che indica quali campioni mantenere e quali scartare. Questa funzione, is_audio_length_in_range, restituisce un valore booleano: i campioni più corti di 30 secondi restituiscono True, mentre quelli più lunghi restituiscono False.
DURATA_MAX_IN_SECONDI = 30.0
def is_audio_length_in_range(input_length):
return input_length < DURATA_MAX_IN_SECONDIPossiamo applicare questa funzione di filtraggio a tutti i nostri esempi di addestramento utilizzando il metodo filter di 🤗 Datasets, mantenendo tutti i campioni più corti di 30 secondi (True) e scartando quelli più lunghi (False):
gigaspeech["train"] = gigaspeech["train"].filter(is_audio_length_in_range, input_columns=["input_length"])E con questo, abbiamo completamente preparato il dataset GigaSpeech per il nostro modello! In totale, questo processo richiede 13 righe di codice Python, partendo dal caricamento del dataset fino all’ultimo passaggio di filtraggio.
Mantenendo il notebook il più generale possibile, abbiamo eseguito solo i passaggi fondamentali di preparazione dei dati. Tuttavia, non ci sono restrizioni alle funzioni che puoi applicare al tuo dataset audio. Puoi estendere la funzione prepare_dataset per eseguire operazioni molto più complesse, come l’aumento dei dati, la rilevazione dell’attività vocale o la riduzione del rumore. Con 🤗 Datasets, se puoi scriverlo in una funzione Python, puoi applicarlo al tuo dataset!
Modalità di streaming: la soluzione ideale
Una delle sfide più grandi con i dataset audio è la loro dimensione considerevole. La configurazione xs di GigaSpeech conteneva solo 10 ore di dati di addestramento, ma ha raggiunto oltre 13 GB di spazio di archiviazione per il download e la preparazione. Quindi, cosa succede quando vogliamo allenarci su una divisione più grande? La configurazione completa xl contiene 10.000 ore di dati di addestramento, richiedendo oltre 1 TB di spazio di archiviazione. Per la maggior parte dei ricercatori del parlato, ciò supera ampiamente le specifiche di un tipico disco rigido. Dobbiamo acquistare spazio di archiviazione addizionale? O c’è un modo per allenarci su questi dataset senza vincoli di spazio su disco ?
🤗 Datasets ci consentono di fare proprio questo. È reso possibile attraverso l’uso della modalità di streaming, rappresentata graficamente nella Figura 1. Lo streaming ci consente di caricare i dati progressivamente mentre iteriamo sul dataset. Invece di scaricare l’intero dataset in una volta, carichiamo il dataset campione per campione. Iteriamo sul dataset, caricando e preparando campioni al volo quando sono necessari. In questo modo, carichiamo solo i campioni che stiamo utilizzando e non quelli che non stiamo utilizzando! Una volta terminato con un campione, continuiamo ad iterare sul dataset e caricare il successivo.
Questo è analogo al download di una serie TV rispetto allo streaming. Quando scarichiamo una serie TV, scarichiamo l’intero video offline e lo salviamo sul nostro disco. Dobbiamo aspettare che l’intero video venga scaricato prima di poterlo guardare e richiede tanto spazio su disco quanto la dimensione del file video. Confronta questo con lo streaming di una serie TV. Qui, non scarichiamo alcuna parte del video su disco, ma iteriamo sul file video remoto e carichiamo ogni parte in tempo reale come richiesto. Non dobbiamo attendere che il video completo venga caricato in memoria prima di poter iniziare a guardarlo, possiamo iniziare non appena la prima parte del video è pronta! Questo è lo stesso principio di streaming che applichiamo al caricamento dei dataset.
La modalità di streaming ha tre vantaggi principali rispetto al download dell’intero dataset in una volta:
- Spazio su disco: i campioni vengono caricati in memoria uno alla volta mentre iteriamo sul dataset. Poiché i dati non vengono scaricati localmente, non ci sono requisiti di spazio su disco, quindi è possibile utilizzare dataset di dimensioni arbitrarie.
- Tempo di download e elaborazione: i dataset audio sono di grandi dimensioni e richiedono una quantità significativa di tempo per il download e l’elaborazione. Con lo streaming, il caricamento e l’elaborazione vengono eseguiti al volo, il che significa che è possibile iniziare a utilizzare il dataset non appena il primo campione è pronto.
- Semplice sperimentazione: è possibile sperimentare su un piccolo numero di campioni per verificare che lo script funzioni senza dover scaricare l’intero dataset.
C’è una limitazione alla modalità di streaming. Quando si scarica un dataset, sia i dati grezzi che i dati elaborati vengono salvati localmente su disco. Se vogliamo riutilizzare questo dataset, possiamo caricare direttamente i dati elaborati da disco, saltando le fasi di download e elaborazione. Di conseguenza, dobbiamo eseguire le operazioni di download ed elaborazione solo una volta, dopodiché possiamo riutilizzare i dati preparati. Con la modalità di streaming, i dati non vengono scaricati su disco. Pertanto, né i dati scaricati né i dati pre-elaborati vengono memorizzati nella cache. Se vogliamo riutilizzare il dataset, è necessario ripetere le fasi di streaming, con i file audio caricati e elaborati al volo. Per questo motivo, si consiglia di scaricare i dataset che si prevede di utilizzare più volte.
Come puoi abilitare la modalità di streaming? Facile! Basta impostare streaming=True quando carichi il tuo dataset. Il resto sarà gestito per te:
gigaspeech = load_dataset("speechcolab/gigaspeech", "xs", streaming=True)Tutti i passaggi finora coperti in questo tutorial possono essere applicati anche al dataset in streaming senza alcuna modifica del codice. L’unica differenza è che non è più possibile accedere ai singoli campioni utilizzando l’indicizzazione in Python (ad esempio gigaspeech["train"][sample_idx]). Invece, è necessario iterare sul dataset, ad esempio usando un ciclo for.
La modalità di streaming può portare la tua ricerca al livello successivo: non solo i dataset più grandi sono accessibili, ma puoi facilmente valutare i sistemi su più dataset contemporaneamente senza preoccuparti dello spazio su disco. Rispetto alla valutazione su un singolo dataset, la valutazione su più dataset fornisce una misura migliore delle capacità di generalizzazione di un sistema di riconoscimento del parlato (c.f. End-to-end Speech Benchmark – ESB). Il Google Colab allegato fornisce un esempio per valutare il modello Whisper su otto dataset di riconoscimento del parlato in inglese in uno script utilizzando la modalità di streaming.
Un tour dei dataset audio su The Hub
Questa sezione serve come guida di riferimento per i dataset di riconoscimento del parlato, traduzione del parlato e classificazione audio più popolari su Hugging Face Hub. Possiamo applicare tutto ciò che abbiamo coperto per il dataset GigaSpeech a uno qualsiasi dei dataset su The Hub. Tutto quello che dobbiamo fare è cambiare l’identificatore del dataset nella funzione load_dataset. È così semplice!
- Riconoscimento del parlato in inglese
- Riconoscimento del parlato multilingue
- Traduzione del parlato
- Classificazione audio
Riconoscimento del parlato in inglese
Il riconoscimento del parlato, o speech-to-text, è il compito di mappare dal parlato al testo scritto, dove sia il parlato che il testo sono nella stessa lingua. Forniamo un riassunto dei dataset di riconoscimento del parlato in inglese più popolari su The Hub:
Fai riferimento al Google Colab per una guida sulla valutazione di un sistema su tutti e otto i dataset di riconoscimento del parlato in inglese in uno script.
Le seguenti descrizioni dei dataset sono in gran parte tratte dal paper di riferimento dell’ESB Benchmark.
LibriSpeech ASR
LibriSpeech è un dataset di grandi dimensioni standard per la valutazione dei sistemi ASR. È composto da circa 1.000 ore di audiolibri narrati raccolti dal progetto LibriVox. LibriSpeech è stato fondamentale nel facilitare ai ricercatori l’utilizzo di un ampio corpus di dati di trascrizione del parlato preesistenti. È diventato uno dei dataset più popolari per il benchmarking dei sistemi accademici di riconoscimento del parlato.
librispeech = load_dataset("librispeech_asr", "all")Common Voice
Common Voice è una serie di dataset di parlato con licenza aperta raccolti tramite contributo del pubblico, dove gli speaker registrano testi da Wikipedia in varie lingue. Poiché chiunque può contribuire alle registrazioni, c’è una significativa variazione sia nella qualità audio che negli speaker. Le condizioni audio sono sfidanti, con artefatti di registrazione, parlato con accento, esitazioni e presenza di parole straniere. Le trascrizioni sono sia maiuscole che punteggiate. Il sottoinsieme in inglese della versione 11.0 contiene circa 2.300 ore di dati convalidati. L’uso del dataset richiede l’accettazione dei termini di utilizzo di Common Voice, che possono essere trovati su Hugging Face Hub: mozilla-foundation/common_voice_11_0. Una volta accettati i termini di utilizzo, ti verrà concesso l’accesso al dataset. Dovrai quindi fornire un token di autenticazione da Hub quando carichi il dataset.
common_voice = load_dataset("mozilla-foundation/common_voice_11", "en", use_auth_token=True)VoxPopuli
VoxPopuli è un corpus di parlato multilingue su larga scala composto da dati provenienti dalle registrazioni degli eventi del Parlamento Europeo dal 2009 al 2020. Di conseguenza, occupa il dominio unico dell’oratoria, del discorso politico, in gran parte proveniente da speaker non nativi. Il sottoinsieme in inglese contiene circa 550 ore di parlato etichettato.
voxpopuli = load_dataset("facebook/voxpopuli", "en")TED-LIUM
TED-LIUM è un dataset basato su video di conferenze TED Talk in lingua inglese. Lo stile di parlato è quello di conferenze educative oratorie. Le conferenze trascritte coprono una serie di argomenti culturali, politici e accademici diversi, con conseguente vocabolario tecnico. L’edizione Release 3 (la più recente) del dataset contiene circa 450 ore di dati di addestramento. I dati di validazione e di test sono tratti dal set legacy, coerenti con le versioni precedenti.
tedlium = caricare_dataset("LIUM/tedlium", "release3")GigaSpeech
GigaSpeech è un corpus di riconoscimento del parlato in inglese multi-dominio, curato da audiolibri, podcast e YouTube. Copre sia il parlato narrato che spontaneo su una varietà di argomenti, come arte, scienza e sport. Contiene divisioni di allenamento che vanno da 10 ore a 10.000 ore e divisioni di validazione e test standardizzate.
gigaspeech = caricare_dataset("speechcolab/gigaspeech", "xs", use_auth_token=True)SPGISpeech
SPGISpeech è un corpus di riconoscimento del parlato in inglese composto da telefonate sulle performance aziendali che sono state trascritte manualmente da S&P Global, Inc. Le trascrizioni sono completamente formattate secondo una guida stilistica professionale per il parlato e il discorso spontaneo. Contiene divisioni di allenamento che vanno da 200 ore a 5.000 ore, con divisioni di validazione e test canoniche.
spgispeech = caricare_dataset("kensho/spgispeech", "s", use_auth_token=True)Earnings-22
Earnings-22 è un corpus di 119 ore di telefonate sulle performance aziendali in lingua inglese raccolte da aziende globali. Il dataset è stato sviluppato con l’obiettivo di aggregare un’ampia gamma di speaker e accenti che coprono una vasta gamma di argomenti finanziari reali. Vi è una grande diversità negli speaker e negli accenti, con speaker provenienti da sette diverse regioni linguistiche. Earnings-22 è stato pubblicato principalmente come dataset solo per il test. L’Hub contiene una versione del dataset suddivisa in divisioni di allenamento-validazione-test.
earnings22 = caricare_dataset("revdotcom/earnings22")AMI
AMI comprende 100 ore di registrazioni di riunioni catturate utilizzando diversi flussi di registrazione. Il corpus contiene trascrizioni ortografiche annotate manualmente delle riunioni allineate a livello di parola. I singoli campioni del dataset AMI contengono file audio molto grandi (tra 10 e 60 minuti), che vengono segmentati in lunghezze adatte per l’allenamento della maggior parte dei sistemi di riconoscimento del parlato. AMI contiene due divisioni: IHM e SDM. IHM (microfono individuale per cuffia) contiene il parlato più vicino, mentre SDM (microfono singolo a distanza) contiene il parlato più lontano.
ami = caricare_dataset("edinburghcstr/ami", "ihm")Riconoscimento del parlato multilingue
Il riconoscimento del parlato multilingue si riferisce al riconoscimento del parlato (da parlato a testo) per tutte le lingue tranne l’inglese.
Multilingual LibriSpeech
Multilingual LibriSpeech è l’equivalente multilingue del corpus ASR LibriSpeech. Comprende un ampio corpus di audiolibri letti tratti dal progetto LibriVox, rendendolo un dataset adatto per la ricerca accademica. Contiene dati suddivisi in otto lingue ad alta risorsa: inglese, tedesco, olandese, spagnolo, francese, italiano, portoghese e polacco.
Common Voice
Common Voice è una serie di dataset di parlato con licenza aperta raccolti dalla folla, in cui gli speaker registrano testi da Wikipedia in varie lingue. Poiché chiunque può contribuire alle registrazioni, vi è una significativa variazione sia nella qualità audio che negli speaker. Le condizioni audio sono sfidanti, con artefatti di registrazione, parlato con accento, esitazioni e presenza di parole straniere. Le trascrizioni sono sia con maiuscole che con punteggiatura. A partire dalla versione 11, sono disponibili oltre 100 lingue, sia a bassa che ad alta risorsa.
VoxPopuli
VoxPopuli è un corpus di parlato multilingue su larga scala composto da dati provenienti dalle registrazioni degli eventi del Parlamento europeo dal 2009 al 2020. Di conseguenza, occupa il dominio unico dell’oratoria, del discorso politico, in gran parte proveniente da speaker non nativi. Contiene dati audio-trascrizione etichettati per 15 lingue europee.
FLEURS
FLEURS (Few-shot Learning Evaluation of Universal Representations of Speech) è un dataset per valutare i sistemi di riconoscimento del parlato in 102 lingue, incluse molte classificate come ‘a bassa risorsa’. I dati sono tratti dal dataset FLoRes-101, un corpus di traduzione automatica con 3001 traduzioni di frasi dall’inglese a 101 altre lingue. Gli speaker nativi registrano le trascrizioni delle frasi nella propria lingua madre. I dati audio registrati sono abbinati alle trascrizioni delle frasi per ottenere il riconoscimento del parlato multilingue in tutte le 101 lingue. I set di allenamento contengono circa 10 ore di dati audio-trascrizione supervisionati per lingua.
Traduzione Vocale
La traduzione vocale è il compito di mappare il discorso parlato in testo scritto, dove il discorso e il testo sono in lingue diverse (ad esempio, discorso in inglese a testo in francese).
CoVoST 2
CoVoST 2 è un corpus di traduzione vocale multilingue su larga scala che copre traduzioni da 21 lingue in inglese e da inglese in 15 lingue. Il dataset è creato utilizzando il database di voci di Mozilla, Common Voice, basato sulla partecipazione della comunità. Nel corpus sono rappresentate 2.900 ore di parlato.
FLEURS
FLEURS (Few-shot Learning Evaluation of Universal Representations of Speech) è un dataset per valutare i sistemi di riconoscimento vocale in 102 lingue, inclusi molti classificati come “a bassa risorsa”. I dati sono derivati dal dataset FLoRes-101, un corpus di traduzione automatica con 3001 traduzioni di frasi dall’inglese in altre 101 lingue. Sono registrati madrelingua che narrano le trascrizioni delle frasi nelle loro lingue native. Un corpus parallelo n-n-n di traduzione vocale viene costruito accoppiando i dati audio registrati alle trascrizioni delle frasi per ciascuna delle 101 lingue. I set di addestramento contengono circa 10 ore di dati di audio-trascrizione supervisionati per ogni combinazione di lingua sorgente e lingua di destinazione.
Classificazione Audio
La classificazione audio è il compito di mappare un input audio grezzo in un’etichetta di classe di output. Le applicazioni pratiche della classificazione audio includono la rilevazione di parole chiave, l’intento del parlante e l’identificazione della lingua.
SpeechCommands
SpeechCommands è un dataset composto da file audio di un secondo, ognuno contenente una singola parola parlata in inglese o rumore di fondo. Le parole sono tratte da un piccolo insieme di comandi e sono pronunciate da diversi parlanti. Il dataset è progettato per aiutare ad addestrare e valutare i sistemi di rilevamento di parole chiave su dispositivi.
Parole Parlate Multilingue
Parole Parlate Multilingue è un corpus su larga scala di campioni audio di un secondo, ognuno contenente una singola parola parlata. Il dataset è composto da 50 lingue e più di 340.000 parole chiave, per un totale di 23,4 milioni di esempi di parole parlate di un secondo o oltre 6.000 ore di audio. I dati audio-trascrizione sono tratti dal progetto Mozilla Common Voice. Per ogni enunciato viene generato un timestamp a livello di parola e utilizzato per estrarre parole parlate individuali e le relative trascrizioni, formando così un nuovo corpus di singole parole parlate. L’uso previsto del dataset è la ricerca accademica e le applicazioni commerciali nella rilevazione di parole chiave multilingue e nella ricerca di termini parlati.
FLEURS
FLEURS (Few-shot Learning Evaluation of Universal Representations of Speech) è un dataset per valutare i sistemi di riconoscimento vocale in 102 lingue, inclusi molti classificati come “a bassa risorsa”. I dati sono derivati dal dataset FLoRes-101, un corpus di traduzione automatica con 3001 traduzioni di frasi dall’inglese in altre 101 lingue. Sono registrati madrelingua che narrano le trascrizioni delle frasi nelle loro lingue native. I dati audio registrati vengono accoppiati a un’etichetta per la lingua in cui sono pronunciati. Il dataset può essere utilizzato come dataset di classificazione audio per l’identificazione della lingua: i sistemi vengono addestrati a prevedere la lingua di ciascun enunciato nel corpus.
Considerazioni Finali
In questo post del blog, abbiamo esplorato l’Hugging Face Hub e sperimentato l’Anteprima del Dataset, un modo efficace per ascoltare i dataset audio prima di scaricarli. Abbiamo caricato un dataset audio con una sola riga di codice Python e abbiamo eseguito una serie di passaggi di pre-elaborazione generica per prepararlo per un modello di apprendimento automatico. In totale, ciò ha richiesto solo 13 righe di codice, affidandosi a semplici funzioni Python per eseguire le operazioni necessarie. Abbiamo introdotto la modalità di streaming, un metodo per caricare e preparare campioni di dati audio al volo. Abbiamo concluso riassumendo i dataset più popolari di riconoscimento vocale, traduzione vocale e classificazione audio sull’Hu.
Dopo aver letto questo blog, speriamo che siate d’accordo che 🤗 Datasets è il posto numero uno per scaricare e preparare dataset audio. 🤗 Datasets è reso possibile grazie al lavoro della comunità. Se desiderate contribuire con un dataset, consultate la Guida per l’Aggiunta di un Nuovo Dataset.
Grazie alle seguenti persone che hanno contribuito all’articolo del blog: Vaibhav Srivastav, Polina Kazakova, Patrick von Platen, Omar Sanseviero e Quentin Lhoest.
