IndicVoices_bengali

This dataset has been created from ai4bharat/IndicVoices. Since directly trying to load the dataset for bengali was not working with IndicVoices due to errors in some files, this dataset addresses those files by removing them.

To use this dataset with lazyloading for training speech to text models, below is sample code with wav2vec2.

import pandas as pd
import torchaudio
from torch.utils.data import Dataset, DataLoader
from transformers import Wav2Vec2Processor, Wav2Vec2ForCTC,
import torch
import os
import numpy as np
from sklearn.model_selection import train_test_split


# === Load CSV ===
df = pd.read_csv("updated_train_data.csv")
train, test = train_test_split(df, test_size=0.3, shuffle=False)
val, test = train_test_split(test, test_size=0.5, shuffle=False)
print(df.columns)
print(df.head())


# === Custom Dataset ===
class ASRDataset(Dataset):
    def __init__(self, df, processor, sample_rate=16000):
        self.df = df
        self.processor = processor
        self.sample_rate = sample_rate

    def __len__(self):
        return len(self.df)

    def __getitem__(self, idx):
        row = self.df.iloc[idx]
        audio_path = row['fname']
        text = row['text']  # text = row['phonetic_text']  # For taking phonetic text

        waveform, sr = torchaudio.load(audio_path)
        if sr != self.sample_rate:
            waveform = torchaudio.transforms.Resample(sr, self.sample_rate)(waveform)
        waveform = waveform.squeeze()

        # Process audio
        input_values = self.processor(waveform, sampling_rate=self.sample_rate, return_attention_mask=False).input_values[0]

        # Process text → labels
        labels = self.processor.tokenizer(text, return_tensors="pt", padding=True).input_ids.squeeze(0).tolist()

        return {"input_values": input_values, "labels": labels}

# === Processor and Model ===
processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-base-960h")
model = Wav2Vec2ForCTC.from_pretrained(
    "facebook/wav2vec2-base-960h", 
    ctc_loss_reduction="mean", 
    pad_token_id=processor.tokenizer.pad_token_id
)
model.to("cuda" if torch.cuda.is_available() else "cpu")


# === Collate Function ===
def collate_fn(batch):
    input_values = [b["input_values"] for b in batch]
    labels = [b["labels"] for b in batch]
    
    # Pad inputs
    batch_inputs = processor.pad(
        {"input_values": input_values},
        padding=True,
        return_tensors="pt"
    )

    # Pad labels using tokenizer directly
    batch_labels = processor.tokenizer.pad(
        {"input_ids": labels},
        padding=True,
        return_tensors="pt"
    )

    batch_inputs["labels"] = batch_labels["input_ids"]
    return batch_inputs


# === DataLoader ===
train_dataset = ASRDataset(train, processor)
train_dataloader = DataLoader(train_dataset, batch_size=4, collate_fn=collate_fn, shuffle=True)

val_dataset = ASRDataset(val, processor)
val_dataloader = DataLoader(val_dataset, batch_size=4, collate_fn=collate_fn, shuffle=True)

test_dataset = ASRDataset(test, processor)
test_dataloader = DataLoader(test_dataset, batch_size=4, collate_fn=collate_fn, shuffle=True)

In case you find some errors in this repo feel free to reach out to subrotosarkar32@gmail.com for correction