Create eduport_tts_mal.py

eduport_tts_mal.py

@@ -0,0 +1,191 @@
+import os
+import torch
+from torch.utils.data import Dataset, DataLoader
+from transformers import GPT2Tokenizer, GPT2Config, GPT2LMHeadModel
+from transformers import Wav2Vec2Processor, Wav2Vec2Model
+import torchaudio
+from sklearn.model_selection import train_test_split
+from torchaudio.transforms import Resample
+
+# Compute max audio length from the training dataset
+def compute_max_audio_length(audio_files, resampler, target_sampling_rate):
+    max_length = 0
+    for audio_path in audio_files:
+        waveform, sample_rate = torchaudio.load(audio_path)
+        if sample_rate != target_sampling_rate:
+            waveform = resampler(waveform)
+        # max_length = max(max_length, waveform.size(1))  # Max length based on time dimension
+        max_length = 1176240
+    return max_length
+
+class SpeechDataset(Dataset):
+    def __init__(self, audio_files, transcript_files, tokenizer, processor, max_length=512, target_sampling_rate=16000, max_audio_length=None):
+        self.audio_files = audio_files
+        self.transcript_files = transcript_files
+        self.tokenizer = tokenizer
+        self.processor = processor
+        self.max_length = max_length
+        self.target_sampling_rate = target_sampling_rate
+        self.max_audio_length = max_audio_length  # Max length of audio
+        self.resampler = Resample(new_freq=self.target_sampling_rate)
+
+    def __len__(self):
+        return len(self.audio_files)
+
+    def __getitem__(self, idx):
+        audio_path = self.audio_files[idx]
+        transcript_path = self.transcript_files[idx]
+
+        # Load and process the audio
+        waveform, sample_rate = torchaudio.load(audio_path)
+
+        # If the audio sample rate is not 16kHz, resample it
+        if sample_rate != self.target_sampling_rate:
+            waveform = self.resampler(waveform)
+
+        # Pass the waveform to the Wav2Vec2 processor
+        input_values = self.processor(waveform, sampling_rate=self.target_sampling_rate, return_tensors="pt").input_values.squeeze(0)
+
+        # Pad or truncate the audio to ensure fixed length (the longest audio length)
+        if input_values.size(0) < self.max_audio_length:
+            padding_length = self.max_audio_length - input_values.size(0)
+            # Pad along the time dimension (dim=1)
+            input_values = torch.cat([input_values, torch.zeros(1, padding_length)], dim=1)
+        else:
+            input_values = input_values[:, :self.max_audio_length]  # Truncate to max_audio_length
+
+        # Load and process the transcript
+        with open(transcript_path, 'r') as file:
+            transcript = file.read().strip()
+
+        # Encode the transcript using the GPT2 tokenizer
+        input_ids = self.tokenizer.encode(transcript, truncation=True, padding='longest', max_length=self.max_length, return_tensors="pt").squeeze(0)
+
+        return input_values, input_ids
+
+def collate_fn(batch):
+    audio_inputs, text_inputs = zip(*batch)
+
+    # Pad audio inputs to the maximum length in the batch
+    max_audio_len = max([audio.size(1) for audio in audio_inputs])
+    audio_inputs_padded = torch.stack([torch.cat([audio, torch.zeros(1, max_audio_len - audio.size(1))], dim=1) if audio.size(1) < max_audio_len else audio[:, :max_audio_len] for audio in audio_inputs])
+
+    # Pad text inputs to the longest transcript length
+    max_text_len = max([text.size(0) for text in text_inputs])
+    text_inputs_padded = torch.stack([torch.cat([text, torch.tensor([0] * (max_text_len - text.size(0)))], dim=0) if text.size(0) < max_text_len else text[:max_text_len] for text in text_inputs])
+
+    return audio_inputs_padded, text_inputs_padded
+
+# Tokenizer and processor
+tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
+processor = Wav2Vec2Processor.from_pretrained('facebook/wav2vec2-base-960h')
+
+tokenizer.pad_token = tokenizer.eos_token
+
+# Data preparation
+wav_folder = './wav'
+transcript_folder = './transcription'
+
+# Load audio files and transcripts
+audio_files = [os.path.join(wav_folder, f) for f in os.listdir(wav_folder)]
+transcript_files = [os.path.join(transcript_folder, f.replace('.wav', '.txt')) for f in os.listdir(wav_folder)]
+
+# Now compute the max audio length
+resampler = Resample(new_freq=16000)  # Assuming resampling to 16kHz
+max_audio_length = compute_max_audio_length(audio_files, resampler, target_sampling_rate=16000)
+print(max_audio_length)
+
+# Split the dataset into train, val, and test
+train_audios, val_audios, train_transcripts, val_transcripts = train_test_split(audio_files, transcript_files, test_size=0.05, random_state=42)
+
+# Define your dataset and dataloaders
+train_dataset = SpeechDataset(train_audios, train_transcripts, tokenizer, processor, max_audio_length=max_audio_length)
+val_dataset = SpeechDataset(val_audios, val_transcripts, tokenizer, processor, max_audio_length=max_audio_length)
+
+# Update your DataLoader to use the custom collate_fn
+train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True, collate_fn=collate_fn)
+val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False, collate_fn=collate_fn)
+
+# Model Architecture
+encoder = Wav2Vec2Model.from_pretrained('facebook/wav2vec2-base-960h')
+# Modify the decoder configuration
+decoder_config = GPT2Config(
+    vocab_size=len(tokenizer), 
+    add_cross_attention=True  # Add this line to enable cross-attention
+)
+decoder = GPT2LMHeadModel(config=decoder_config)
+
+class SpeechRecognitionModel(torch.nn.Module):
+    def __init__(self, encoder, decoder):
+        super().__init__()
+        self.encoder = encoder
+        self.decoder = decoder
+
+    def forward(self, audio_input, text_input):
+        # Extract encoder hidden states
+        encoder_output = self.encoder(audio_input).last_hidden_state
+        
+        # Create an attention mask for the encoder output
+        encoder_attention_mask = torch.ones(
+            encoder_output.shape[:2], 
+            dtype=torch.long, 
+            device=encoder_output.device
+        )
+
+        # Forward pass through the decoder with cross-attention
+        outputs = self.decoder(
+            input_ids=text_input,
+            encoder_hidden_states=encoder_output,
+            encoder_attention_mask=encoder_attention_mask
+        )
+        
+        return outputs
+
+# Instantiate the model
+model = SpeechRecognitionModel(encoder, decoder)
+
+# Optimizer and scheduler
+optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
+scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
+
+# Training Loop
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model.to(device)
+
+num_epochs = 10
+
+for epoch in range(num_epochs):
+    model.train()
+    train_loss = 0
+    for audio_input, text_input in train_loader:
+        optimizer.zero_grad()
+
+        # Move tensors to the appropriate device
+        audio_input = audio_input.squeeze(1).to(device)
+        text_input = text_input.to(device)
+
+        # Forward pass
+        output = model(audio_input, text_input)
+
+        # Compute loss
+        loss = torch.nn.CrossEntropyLoss()(output.logits.view(-1, output.logits.size(-1)), text_input.view(-1))
+        loss.backward()
+        optimizer.step()
+
+        train_loss += loss.item()
+
+    # Validation step
+    model.eval()
+    val_loss = 0
+    with torch.no_grad():
+        for audio_input, text_input in val_loader:
+            audio_input = audio_input.to(device)
+            text_input = text_input.to(device)
+            output = model(audio_input, text_input)
+            loss = torch.nn.CrossEntropyLoss()(output.logits.view(-1, output.logits.size(-1)), text_input.view(-1))
+            val_loss += loss.item()
+
+    # Update scheduler
+    scheduler.step(val_loss)
+
+    print(f'Epoch {epoch}: Train Loss: {train_loss / len(train_loader)}, Val Loss: {val_loss / len(val_loader)}')