* Add README.

Training details to be added later. I performed it incrementally due to
the difficulty in manipulating the dataset, and don't have a
self-contained script right now.

The evaluation script, however, is correct as far as I can tell, and
represents the pre-processing steps that I followed.

Note that the `wer` metric produces a memory error when used on large
datasets. I created a version that accumulates the base measures and
then computes the result, instead of doing it on all samples at once.

README.md

@@ -0,0 +1,190 @@
+---
+language: es
+datasets:
+- common_voice
+metrics:
+- wer
+tags:
+- audio
+- automatic-speech-recognition
+- speech
+- xlsr-fine-tuning-week
+license: apache-2.0
+model-index:
+- name: XLSR Wav2Vec2 Large 53 Spanish by pcuenq 
+  results:
+  - task: 
+      name: Speech Recognition
+      type: automatic-speech-recognition
+    dataset:
+      name: Common Voice es
+      type: common_voice
+      args: es
+    metrics:
+       - name: Test WER
+         type: wer
+         value: 13.47
+---
+
+# Wav2Vec2-Large-XLSR-53-Spanish
+
+Fine-tuned [facebook/wav2vec2-large-xlsr-53](https://huggingface.co/facebook/wav2vec2-large-xlsr-53) on Spanish using the [Common Voice](https://huggingface.co/datasets/common_voice) dataset{s}.
+When using this model, make sure that your speech input is sampled at 16kHz.
+
+## Usage
+
+The model can be used directly (without a language model) as follows:
+
+```python
+import torch
+import torchaudio
+from datasets import load_dataset
+from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor
+
+test_dataset = load_dataset("common_voice", "es", split="test[:2%]")
+
+processor = Wav2Vec2Processor.from_pretrained("pcuenq/wav2vec2-large-xlsr-53-es")
+model = Wav2Vec2ForCTC.from_pretrained("pcuenq/wav2vec2-large-xlsr-53-es")
+
+resampler = torchaudio.transforms.Resample(48_000, 16_000)
+
+# Preprocessing the datasets.
+# We need to read the audio files as arrays
+def speech_file_to_array_fn(batch):
+	speech_array, sampling_rate = torchaudio.load(batch["path"])
+	batch["speech"] = resampler(speech_array).squeeze().numpy()
+	return batch
+
+test_dataset = test_dataset.map(speech_file_to_array_fn)
+inputs = processor(test_dataset["speech"][:2], sampling_rate=16_000, return_tensors="pt", padding=True)
+
+with torch.no_grad():
+	logits = model(inputs.input_values, attention_mask=inputs.attention_mask).logits
+
+predicted_ids = torch.argmax(logits, dim=-1)
+
+print("Prediction:", processor.batch_decode(predicted_ids))
+print("Reference:", test_dataset["sentence"][:2])
+```
+
+
+## Evaluation
+
+The model can be evaluated as follows on the Spanish test data of Common Voice.
+
+```python
+import torch
+import torchaudio
+from datasets import load_dataset, load_metric
+from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor
+import re
+
+test_dataset = load_dataset("common_voice", "es", split="test")
+wer = load_metric("wer")
+
+processor = Wav2Vec2Processor.from_pretrained("pcuenq/wav2vec2-large-xlsr-53-es")
+model = Wav2Vec2ForCTC.from_pretrained("pcuenq/wav2vec2-large-xlsr-53-es")
+model.to("cuda")
+
+## Text pre-processing
+
+chars_to_ignore_regex = '[\,\¿\?\.\¡\!\-\;\:\"\“\%\‘\”\\…\’\ː\'\‹\›\`\´\®\—\→]'
+chars_to_ignore_pattern = re.compile(chars_to_ignore_regex)
+
+def remove_special_characters(batch):
+    batch["sentence"] = chars_to_ignore_pattern.sub('', batch["sentence"]).lower() + " "
+    return batch
+
+def replace_diacritics(batch):
+    sentence = batch["sentence"]
+    sentence = re.sub('ì', 'í', sentence)
+    sentence = re.sub('ù', 'ú', sentence)
+    sentence = re.sub('ò', 'ó', sentence)
+    sentence = re.sub('à', 'á', sentence)
+    batch["sentence"] = sentence
+    return batch
+
+def replace_additional(batch):
+    sentence = batch["sentence"]
+    sentence = re.sub('ã', 'a', sentence)   # Portuguese, as in São Paulo
+    sentence = re.sub('ō', 'o', sentence)   # Japanese
+    sentence = re.sub('ê', 'e', sentence)   # Português
+    batch["sentence"] = sentence
+    return batch
+
+## Audio pre-processing
+
+# I tried to perform the resampling using a `torchaudio` `Resampler` transform,
+# but found that the process deadlocked when using multiple processes.
+# Perhaps my torchaudio is using the wrong sox library under the hood, I'm not sure.
+# Fortunately, `librosa` seems to work fine, so that's what I'll use for now.
+
+import librosa
+def speech_file_to_array_fn(batch):
+    speech_array, _ = torchaudio.load(batch["path"])
+    batch["speech"] = librosa.resample(speech_array.squeeze().numpy(), 48_000, 16_000)
+    return batch
+
+# One-pass mapping function
+
+# Text transformation and audio resampling
+def cv_prepare(batch):
+    batch = remove_special_characters(batch)
+    batch = replace_diacritics(batch)
+    batch = replace_additional(batch)
+    batch = speech_file_to_array_fn(batch)
+    return batch
+
+# Number of CPUs or None
+num_proc = 16
+
+test_dataset = test_dataset.map(cv_prepare, remove_columns=['path'], num_proc=num_proc)
+
+def evaluate(batch):
+    inputs = processor(batch["speech"], sampling_rate=16_000, return_tensors="pt", padding=True)
+
+    with torch.no_grad():
+        logits = model(inputs.input_values.to("cuda"), attention_mask=inputs.attention_mask.to("cuda")).logits
+
+    pred_ids = torch.argmax(logits, dim=-1)
+    batch["pred_strings"] = processor.batch_decode(pred_ids)
+    return batch
+
+result = test_dataset.map(evaluate, batched=True, batch_size=8)
+
+# WER Metric computation
+# `wer.compute` crashes in my computer with more than ~10000 samples.
+# Until I confirm in a different one, I created a "chunked" version of the computation.
+# It gives the same results as `wer.compute` for smaller datasets.
+
+import jiwer
+
+def chunked_wer(targets, predictions, chunk_size=None):                                          
+    if chunk_size is None: return jiwer.wer(targets, predictions)                                
+    start = 0                                                                                    
+    end = chunk_size                                                                             
+    H, S, D, I = 0, 0, 0, 0                                                                      
+    while start < len(targets):                                                                  
+        chunk_metrics = jiwer.compute_measures(targets[start:end], predictions[start:end])       
+        H = H + chunk_metrics["hits"]                                                            
+        S = S + chunk_metrics["substitutions"]                                                   
+        D = D + chunk_metrics["deletions"]                                                       
+        I = I + chunk_metrics["insertions"]                                                      
+        start += chunk_size                                                                      
+        end += chunk_size                                                                        
+    return float(S + D + I) / float(H + S + D)
+
+print("WER: {:2f}".format(100 * chunked_wer(result["sentence"], result["pred_strings"], chunk_size=4000)))
+#print("WER: {:2f}".format(100 * wer.compute(predictions=result["pred_strings"], references=result["sentence"])))
+
+```
+
+**Test Result**: 13.47 %
+
+
+## Training
+
+The Common Voice `train` and `validation` datasets were used for training.
+
+Training details TBD (I did it incrementally, don't have a self-contained script right now).
+