Upload eduport_tts_mal.py with huggingface_hub

eduport_tts_mal.py

@@ -14,8 +14,7 @@ def compute_max_audio_length(audio_files, resampler, target_sampling_rate):
         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
+        max_length = max(max_length, waveform.size(1))  # Max length based on time dimension
     return max_length
 
 class SpeechDataset(Dataset):
@@ -35,45 +34,47 @@ class SpeechDataset(Dataset):
     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)
+            # Create a zero tensor with the same batch size (1) and the padding length along dimension 1
+            padding = torch.zeros(1, padding_length)
+            input_values = torch.cat([input_values, padding], 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
@@ -108,11 +109,8 @@ val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False, collate_fn=col
 
 # 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_config = GPT2Config(vocab_size=len(tokenizer))
+decoder_config.add_cross_attention=True
 decoder = GPT2LMHeadModel(config=decoder_config)
 
 class SpeechRecognitionModel(torch.nn.Module):
@@ -122,24 +120,9 @@ 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
-        
-        # 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
+        decoder_output = self.decoder(text_input, encoder_hidden_states=encoder_output)
+        return decoder_output
 
 # Instantiate the model
 model = SpeechRecognitionModel(encoder, decoder)
@@ -166,7 +149,7 @@ for epoch in range(num_epochs):
 
         # 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()
@@ -188,4 +171,6 @@ for epoch in range(num_epochs):
     # 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)