Upload eduport_tts_mal.py with huggingface_hub

eduport_tts_mal.py

@@ -7,6 +7,8 @@ import torchaudio
 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
 
 # Compute max audio length from the training dataset
 def compute_max_audio_length(audio_files, resampler, target_sampling_rate):
@@ -120,6 +122,9 @@ class SpeechRecognitionModel(torch.nn.Module):
         super().__init__()
         self.encoder = encoder
         self.decoder = decoder
+        
+        self.encoder.gradient_checkpointing_enable()
+        self.decoder.gradient_checkpointing_enable()
 
     def forward(self, audio_input, text_input):
         # Extract encoder hidden states
@@ -136,13 +141,14 @@ class SpeechRecognitionModel(torch.nn.Module):
         outputs = self.decoder(
             input_ids=text_input,
             encoder_hidden_states=encoder_output,
-            encoder_attention_mask=encoder_attention_mask
+            encoder_attention_mask=encoder_attention_mask,
+            use_cache=False
         )
         
         return outputs
 
 # Training Loop with Improved Mixed Precision
-def train_model(num_epochs=10):
+def train_model(num_epochs=10, accumulation_steps=16):
     # Prepare the models
     # Use float32 for most of the model, let autocast handle precision
     encoder = Wav2Vec2Model.from_pretrained('facebook/wav2vec2-base-960h')
@@ -169,40 +175,51 @@ def train_model(num_epochs=10):
     scaler = GradScaler()
 
     # Training loop
-    for epoch in range(num_epochs):
+    for epoch in tqdm(range(num_epochs), desc="Epochs", position=0):
         model.train()
         train_loss = 0
-        for audio_input, text_input in train_loader:
-            optimizer.zero_grad()
+        
+        train_progress = tqdm(train_loader, desc=f"Epoch {epoch+1}", position=1, leave=False)
+        
+        for batch_idx, (audio_input, text_input) in enumerate(train_progress):
 
             # Move tensors to device
             audio_input = audio_input.squeeze(1).to(device)
             text_input = text_input.to(device)
 
             # Use autocast for mixed precision training
-            with autocast(dtype=torch.float16):
+            with autocast(dtype=torch.float16, device_type='cuda'):
                 # 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 = loss / accumulation_steps
             # Scaled loss for mixed precision
             scaler.scale(loss).backward()
-            scaler.step(optimizer)
-            scaler.update()
+            if (batch_idx + 1) % accumulation_steps == 0:
+                scaler.step(optimizer)
+                scaler.update()
+                optimizer.zero_grad()
 
+            train_progress.set_postfix({'loss': loss.item()})
             train_loss += loss.item()
 
         # Validation step
         model.eval()
         val_loss = 0
+        
+        val_progress = tqdm(val_loader, desc=f"Validation {epoch+1}", position=1, leave=False)
+        
         with torch.no_grad(), autocast(dtype=torch.float16):
             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_progress.set_postfix({'loss': loss.item()})
                 val_loss += loss.item()
 
         # Update scheduler