README.md

---
language:
- de
task_categories:
- automatic-speech-recognition
pretty_name: ASR-German-Mixed
dataset_info:
  features:
  - name: audio
    dtype:
      audio:
        sampling_rate: 16000
  - name: transkription
    dtype: string
  - name: source
    dtype: string
  splits:
  - name: train
    num_bytes: 136251633720.53415
    num_examples: 970064
  - name: test
    num_bytes: 1395290962.647844
    num_examples: 9799
  download_size: 135597067232
  dataset_size: 137646924683.182
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
  - split: test
    path: data/test-*
---

# Dataset Beschreibung

## Allgemeine Informationen
Dieser Datensatz ist eine Kombination aus drei verschiedenen Quellen für die deutsche Sprache: Commonvoice 17.0 und Multilingual librispeech. Die Daten wurden gefiltert, normalisiert und grammatikalisch korrigiert.
Die drei Datensätze wurden erneut transkribiert und mit den entsprechenden Audio-Daten abgeglichen, um genaue Transkriptionen zu erhalten. Anschließend wurde ein Abgleich mit den Originaltranskripten durchgeführt, um fehlerhafte Transkriptionen zu korrigieren oder zu entfernen, sofern dies möglich war.
Für diese Aufgabe wurde das primeline whisper large v3 Modell genutzt.

### Commonvoice 19.0
Common Voice ist ein öffentlich verfügbarer Sprachdatensatz, der durch Stimmen freiwilliger Mitwirkender auf der ganzen Welt erstellt wird. Der Datensatz enthält Aufnahmen von Sätzen in verschiedenen Sprachen, einschließlich Deutsch.

### Multilingual librispeech
Der Multilingual LibriSpeech (MLS) Datensatz ist ein umfangreicher mehrsprachiger Korpus, der sich für die Sprachforschung eignet. Der Datensatz basiert auf vorgelesenen Hörbüchern von LibriVox und enthält auch deutschsprachige Aufnahmen.

## Datenverarbeitungsschritte
Um einen qualitativ hochwertigen deutschen Sprachdatensatz zu erstellen, wurden folgende Schritte durchgeführt:

1. Filterung: Es wurden nur die deutschen Sätze aus den jeweiligen Quelldatensätzen extrahiert.
2. Normalisierung: Die Texte wurden auf eine einheitliche Form gebracht, um Inkonsistenzen zu beseitigen.
3. Grammatikkorrektur: Fehlerhafte Grammatik wurde korrigiert, um die Qualität der Sätze zu verbessern.

## Verwendungszweck
Dieser kombinierte deutsche Sprachdatensatz kann für verschiedene Zwecke verwendet werden:

- ASR (Automatic Speech Recognition) Modelltraining 
- NLP (Natural Language Processing) Forschung 
- Text-to-Speech Anwendungen 

Bitte beachten Sie jedoch bei der Verwendung dieses Datensatzes die Lizenzbedingungen der einzelnen Quellen sowie etwaige Einschränkungen oder Richtlinien bezüglich des Datenschutzes oder Urheberrechts.




Evaluation results:

| Modell | Word error rate |
| ----- | -----  |
| openai/whisper-large-v3-turbo | 14.14% |
| openai/whisper-large-v3 | 13.79% |
| primeline/whisper-large-v3-german | 10.54% |
| nyrahealth/CrisperWhisper | 8.519036731165182 |
| primeline/whisper-large-v3-turbo-german | 4.77% |

openai/whisper-large-v3-turbo


Evaluation script

```python
import datasets
from transformers import (
    AutoConfig,
    AutoModelForSpeechSeq2Seq,
    AutoProcessor,
)
from jiwer import wer, cer, wer_standardize_contiguous
from tqdm.auto import tqdm
import torch

BASE_MODEL = "Model Path"
DATASET_NAME = "asr-german-mixed"
batch_size=4

cv_data = (
    datasets.load_from_disk(DATASET_NAME)
    .cast_column(
        "audio",
        datasets.Audio(sampling_rate=16000, decode=True),
    )
    .with_format("torch")
)


def get_model(model_name: str):
    kwargs = {}
    processor = AutoProcessor.from_pretrained(
        model_name,
        legacy=False,
        trust_remote_code=True,
    )

    kwargs["attn_implementation"] = "sdpa"

    model = AutoModelForSpeechSeq2Seq.from_pretrained(
        model_name,
        **kwargs,
    )

    model = model.to(torch.bfloat16).cuda()
    
    return model, processor


model, processor = get_model(model_name=BASE_MODEL)
model.generation_config.do_sample=False
model.generation_config.num_beams=1

references = []
predictions = []
test_data = cv_data["test"]

for i in tqdm(range(0, len(test_data), batch_size)):
    batch = test_data[i:i + batch_size]

    audios = []
    input_features = []
    for x in batch["audio"]:
        # Extract the audio features from the audio
        extracted = processor(
            audio=x["array"],
            sampling_rate=16000,
            return_tensors="pt",
            return_attention_mask = True,
        )

        # check if feature extractor return input_features or input_values
        ft = (
            "input_values"
            if hasattr(extracted, "input_values")
            else "input_features"
        )

        # append to input_features
        input_features.append(
            {
                ft: getattr(
                    extracted,
                    ft,
                )[0],
                "attention_mask": extracted.attention_mask
            }
        )
        
        
    batch_pad = processor.feature_extractor.pad(
        input_features,
        padding="longest",
        return_tensors="pt",
    )
    
    with torch.no_grad():
        generated_ids = model.generate(input_features=batch_pad.input_features.to(torch.bfloat16).cuda(), attention_mask = batch_pad.attention_mask.to(torch.bfloat16).cuda(), max_new_tokens=384, language='de')
    
    transcriptions = processor.batch_decode(generated_ids, skip_special_tokens=True)
    references.extend(batch["transkription"])
    predictions.extend(transcriptions)

print("*"*20)
print("WER: ", wer(references, predictions, reference_transform=wer_standardize_contiguous, hypothesis_transform=wer_standardize_contiguous)*100)
print("*"*20)
```