Update eduport_tts_mal.py

eduport_tts_mal.py

@@ -4,11 +4,13 @@ from torch.utils.data import Dataset, DataLoader
 from transformers import GPT2Tokenizer, GPT2Config, GPT2LMHeadModel
 from transformers import Wav2Vec2Processor, Wav2Vec2Model
 import torchaudio
+from torch.optim.lr_scheduler import CosineAnnealingLR
 from sklearn.model_selection import train_test_split
 from torchaudio.transforms import Resample
 from torch.amp import GradScaler, autocast
 from tqdm import tqdm
 from jiwer import wer
+from torchaudio.transforms import TimeStretch, PitchShift
 
 # Compute max audio length from the training dataset
 def compute_max_audio_length(audio_files, resampler, target_sampling_rate):
@@ -66,6 +68,22 @@ class SpeechDataset(Dataset):
         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
+
+class AugmentedSpeechDataset(SpeechDataset):
+    def __getitem__(self, idx):
+        input_values, input_ids = super().__getitem__(idx)
+        
+        # Random time stretching
+        if torch.rand(1).item() < 0.3:
+            time_stretch = TimeStretch(factor=torch.uniform(0.8, 1.2))
+            input_values = time_stretch(input_values)
+        
+        # Random pitch shift
+        if torch.rand(1).item() < 0.3:
+            pitch_shift = PitchShift(sample_rate=self.target_sampling_rate, n_steps=torch.randint(-2, 2, (1,)))
+            input_values = pitch_shift(input_values)
+        
+        return input_values, input_ids
         
 def collate_fn(batch):
     audio_inputs, text_inputs = zip(*batch)
@@ -103,7 +121,7 @@ print(max_audio_length)
 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)
+train_dataset = AugmentedSpeechDatasetSpeechDataset(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
@@ -147,6 +165,30 @@ class SpeechRecognitionModel(torch.nn.Module):
         
         return outputs
 
+def compute_wer(model, val_loader, device, tokenizer):
+    model.eval()
+    total_wer = 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)
+            
+            # Generate predictions
+            outputs = model.decoder.generate(
+                encoder_hidden_states=model.encoder(audio_input).last_hidden_state,
+                max_length=text_input.size(1)
+            )
+            
+            # Convert predictions and ground truth to text
+            predictions = tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            ground_truth = tokenizer.batch_decode(text_input, skip_special_tokens=True)
+            
+            # Compute WER
+            batch_wer = wer(ground_truth, predictions)
+            total_wer += batch_wer
+    
+    return total_wer / len(val_loader)
+
 # Training Loop with Improved Mixed Precision
 def train_model(num_epochs=10, accumulation_steps=16):
     # Prepare the models
@@ -169,7 +211,8 @@ def train_model(num_epochs=10, accumulation_steps=16):
 
     # Optimizer and learning rate scheduler
     optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
-    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
+    # scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
+    scheduler = CosineAnnealingLR(optimizer, T_max=num_epochs, eta_min=1e-6)
 
     # Gradient scaler for mixed precision training
     scaler = GradScaler()
@@ -193,7 +236,7 @@ def train_model(num_epochs=10, accumulation_steps=16):
                 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 = torch.nn.CrossEntropyLoss()(output.logits.view(-1, output.logits.size(-1)), text_input.view(-1), ignore_index = tokenizer.pad_token_id, label_smoothing=0.1)
 
             loss = loss / accumulation_steps
             # Scaled loss for mixed precision
@@ -209,7 +252,7 @@ def train_model(num_epochs=10, accumulation_steps=16):
         # Validation step
         model.eval()
         val_loss = 0
-        
+        wer = compute_wer(model, val_loader, device, tokenizer)
         val_progress = tqdm(val_loader, desc=f"Validation {epoch+1}", position=1, leave=False)
         
         with torch.no_grad(), autocast(dtype=torch.float16):