Update eduport_tts_mal.py

eduport_tts_mal.py

@@ -113,6 +113,7 @@ decoder_config = GPT2Config(vocab_size=len(tokenizer))
 decoder_config.add_cross_attention=True
 decoder = GPT2LMHeadModel(config=decoder_config)
 
+# Model Architecture with Improved FP16 Support
 class SpeechRecognitionModel(torch.nn.Module):
     def __init__(self, encoder, decoder):
         super().__init__()
@@ -120,57 +121,93 @@ class SpeechRecognitionModel(torch.nn.Module):
         self.decoder = decoder
 
     def forward(self, audio_input, text_input):
+        # Extract encoder hidden states
         encoder_output = self.encoder(audio_input).last_hidden_state
-        decoder_output = self.decoder(text_input, encoder_hidden_states=encoder_output)
-        return decoder_output
-
-# Instantiate the model
-model = SpeechRecognitionModel(encoder, decoder)
+        
+        # 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
 
-# Optimizer and scheduler
-optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
-scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
+# Training Loop with Improved Mixed Precision
+def train_model(num_epochs=10):
+    # Prepare the models
+    # Use float32 for most of the model, let autocast handle precision
+    encoder = Wav2Vec2Model.from_pretrained('facebook/wav2vec2-base-960h')
+    
+    # Modify the decoder configuration
+    decoder_config = GPT2Config(
+        vocab_size=len(tokenizer), 
+        add_cross_attention=True
+    )
+    decoder = GPT2LMHeadModel(config=decoder_config)
+
+    # Initialize the model
+    model = SpeechRecognitionModel(encoder, decoder)
+
+    # Move to GPU 
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model = model.to(device)
+
+    # Optimizer and learning rate scheduler
+    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
+
+    # Gradient scaler for mixed precision training
+    scaler = GradScaler()
+
+    # Training loop
+    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 device
+            audio_input = audio_input.squeeze(1).to(device)
+            text_input = text_input.to(device)
 
-# Training Loop
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-model.to(device)
+            # Use autocast for mixed precision training
+            with autocast(dtype=torch.float16):
+                # Forward pass
+                output = model(audio_input, text_input)
 
-num_epochs = 10
+                # Compute loss
+                loss = torch.nn.CrossEntropyLoss()(output.logits.view(-1, output.logits.size(-1)), text_input.view(-1))
 
-for epoch in range(num_epochs):
-    model.train()
-    train_loss = 0
-    for audio_input, text_input in train_loader:
-        optimizer.zero_grad()
+            # Scaled loss for mixed precision
+            scaler.scale(loss).backward()
+            scaler.step(optimizer)
+            scaler.update()
 
-        # Move tensors to the appropriate device
-        audio_input = audio_input.squeeze(1).to(device)
-        text_input = text_input.to(device)
+            train_loss += loss.item()
 
-        # 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()
+        # Validation step
+        model.eval()
+        val_loss = 0
+        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_loss += loss.item()
 
-    # Update scheduler
-    scheduler.step(val_loss)
+        # Update scheduler
+        scheduler.step(val_loss)
 
-    print(f'Epoch {epoch}: Train Loss: {train_loss / len(train_loader)}, Val Loss: {val_loss / len(val_loader)}')
+        print(f'Epoch {epoch}: Train Loss: {train_loss / len(train_loader)}, Val Loss: {val_loss / len(val_loader)}')
 
-# Inference (use the same process as the training loop to handle inference)
+# Run the training
+train_model()