fixed TTS class

app.py

@@ -45,13 +45,14 @@ print(f"--- Initializing on device: {DEVICE} ---") # This will run when the Spac
 # --- (Start of your model definitions - make sure this is complete from your previous code) ---
 class Hyperparams:
   seed = 42
+  # We won't use these dataset paths, but keep them for hp object integrity
   csv_path = "path/to/metadata.csv"
   wav_path = "path/to/wavs"
   symbols = [
-    'EOS', ' ', '!', ',', '-', '.', ';', '?', 'a', 'b', 'c', 'd', 'e', 'f',
-    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-    't', 'u', 'v', 'w', 'x', 'y', 'z', 'à', 'â', 'è', 'é', 'ê', 'ü',
-    '’', '“', '”'
+    'EOS', ' ', '!', ',', '-', '.', ';', '?', 'a', 'b', 'c', 'd', 'e', 'f', 
+    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 
+    't', 'u', 'v', 'w', 'x', 'y', 'z', 'à', 'â', 'è', 'é', 'ê', 'ü', 
+    '’', '“', '”' 
   ]
   sr = 22050
   n_fft = 2048
@@ -61,9 +62,9 @@ class Hyperparams:
   mel_freq = 128
   max_mel_time = 1024
   power = 2.0
-  text_num_embeddings = 2*len(symbols)
+  text_num_embeddings = 2*len(symbols)  
   embedding_size = 256
-  encoder_embedding_size = 512
+  encoder_embedding_size = 512 
   dim_feedforward = 1024
   postnet_embedding_size = 1024
   encoder_kernel_size = 3
@@ -78,10 +79,10 @@ class Hyperparams:
 
 hp = Hyperparams()
 
+# Text to Sequence
 symbol_to_id = {s: i for i, s in enumerate(hp.symbols)}
 def text_to_seq(text):
   text = text.lower()
-  text = unidecode(text)
   seq = []
   for s in text:
     _id = symbol_to_id.get(s, None)
@@ -90,8 +91,10 @@ def text_to_seq(text):
   seq.append(symbol_to_id["EOS"])
   return torch.IntTensor(seq)
 
+# Audio Processing
 spec_transform = torchaudio.transforms.Spectrogram(n_fft=hp.n_fft, win_length=hp.win_length, hop_length=hp.hop_length, power=hp.power)
 mel_scale_transform = torchaudio.transforms.MelScale(n_mels=hp.mel_freq, sample_rate=hp.sr, n_stft=hp.n_stft)
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 mel_inverse_transform = torchaudio.transforms.InverseMelScale(n_mels=hp.mel_freq, sample_rate=hp.sr, n_stft=hp.n_stft).to(DEVICE)
 griffnlim_transform = torchaudio.transforms.GriffinLim(n_fft=hp.n_fft, win_length=hp.win_length, hop_length=hp.hop_length).to(DEVICE)
 
@@ -102,7 +105,7 @@ def pow_to_db_mel_spec(mel_spec):
 
 def db_to_power_mel_spec(mel_spec):
   mel_spec = mel_spec*hp.scale_db
-  mel_spec = torchaudio.functional.DB_to_amplitude(mel_spec, ref=hp.ampl_ref, power=hp.ampl_power)
+  mel_spec = torchaudio.functional.DB_to_amplitude(mel_spec, ref=hp.ampl_ref, power=hp.ampl_power)  
   return mel_spec
 
 def inverse_mel_spec_to_wav(mel_spec):
@@ -115,8 +118,9 @@ def mask_from_seq_lengths(sequence_lengths: torch.Tensor, max_length: int) -> to
     ones = sequence_lengths.new_ones(sequence_lengths.size(0), max_length)
     range_tensor = ones.cumsum(dim=1)
     return sequence_lengths.unsqueeze(1) >= range_tensor
-
-class EncoderBlock(nn.Module): # Your EncoderBlock definition
+    
+# --- TransformerTTS Model Architecture (Copied from notebook)
+class EncoderBlock(nn.Module):
     def __init__(self):
         super(EncoderBlock, self).__init__()
         self.norm_1 = nn.LayerNorm(normalized_shape=hp.embedding_size)
@@ -131,8 +135,8 @@ class EncoderBlock(nn.Module): # Your EncoderBlock definition
         x_out = self.norm_1(x)
         x_out, _ = self.attn(query=x_out, key=x_out, value=x_out, attn_mask=attn_mask, key_padding_mask=key_padding_mask)
         x_out = self.dropout_1(x_out)
-        x = x + x_out
-        x_out = self.norm_2(x)
+        x = x + x_out    
+        x_out = self.norm_2(x) 
         x_out = self.linear_1(x_out)
         x_out = F.relu(x_out)
         x_out = self.dropout_2(x_out)
@@ -141,14 +145,14 @@ class EncoderBlock(nn.Module): # Your EncoderBlock definition
         x = x + x_out
         return x
 
-class DecoderBlock(nn.Module): # Your DecoderBlock definition
+class DecoderBlock(nn.Module):
     def __init__(self):
         super(DecoderBlock, self).__init__()
         self.norm_1 = nn.LayerNorm(normalized_shape=hp.embedding_size)
         self.self_attn = torch.nn.MultiheadAttention(embed_dim=hp.embedding_size, num_heads=4, dropout=0.1, batch_first=True)
         self.dropout_1 = torch.nn.Dropout(0.1)
         self.norm_2 = nn.LayerNorm(normalized_shape=hp.embedding_size)
-        self.attn = torch.nn.MultiheadAttention(embed_dim=hp.embedding_size, num_heads=4, dropout=0.1, batch_first=True)
+        self.attn = torch.nn.MultiheadAttention(embed_dim=hp.embedding_size, num_heads=4, dropout=0.1, batch_first=True)    
         self.dropout_2 = torch.nn.Dropout(0.1)
         self.norm_3 = nn.LayerNorm(normalized_shape=hp.embedding_size)
         self.linear_1 = nn.Linear(hp.embedding_size, hp.dim_feedforward)
@@ -170,7 +174,7 @@ class DecoderBlock(nn.Module): # Your DecoderBlock definition
         x = self.norm_3(x + x_out)
         return x
 
-class EncoderPreNet(nn.Module): # Your EncoderPreNet definition
+class EncoderPreNet(nn.Module):
     def __init__(self):
         super(EncoderPreNet, self).__init__()
         self.embedding = nn.Embedding(num_embeddings=hp.text_num_embeddings, embedding_dim=hp.encoder_embedding_size)
@@ -184,22 +188,28 @@ class EncoderPreNet(nn.Module): # Your EncoderPreNet definition
         self.dropout_2 = torch.nn.Dropout(0.5)
         self.conv_3 = nn.Conv1d(hp.encoder_embedding_size, hp.encoder_embedding_size, kernel_size=hp.encoder_kernel_size, stride=1, padding=int((hp.encoder_kernel_size - 1) / 2), dilation=1)
         self.bn_3 = nn.BatchNorm1d(hp.encoder_embedding_size)
-        self.dropout_3 = torch.nn.Dropout(0.5)
+        self.dropout_3 = torch.nn.Dropout(0.5)    
     def forward(self, text):
         x = self.embedding(text)
         x = self.linear_1(x)
         x = x.transpose(2, 1)
         x = self.conv_1(x)
-        x = self.bn_1(x); x = F.relu(x); x = self.dropout_1(x)
+        x = self.bn_1(x)
+        x = F.relu(x)
+        x = self.dropout_1(x)
         x = self.conv_2(x)
-        x = self.bn_2(x); x = F.relu(x); x = self.dropout_2(x)
+        x = self.bn_2(x)
+        x = F.relu(x)
+        x = self.dropout_2(x)
         x = self.conv_3(x)
-        x = self.bn_3(x); x = F.relu(x); x = self.dropout_3(x)
+        x = self.bn_3(x)    
+        x = F.relu(x)
+        x = self.dropout_3(x)
         x = x.transpose(1, 2)
         x = self.linear_2(x)
         return x
 
-class PostNet(nn.Module): # Your PostNet definition
+class PostNet(nn.Module):
     def __init__(self):
         super(PostNet, self).__init__()
         self.conv_1 = nn.Conv1d(hp.mel_freq, hp.postnet_embedding_size, kernel_size=hp.postnet_kernel_size, stride=1, padding=int((hp.postnet_kernel_size - 1) / 2), dilation=1)
@@ -221,18 +231,23 @@ class PostNet(nn.Module): # Your PostNet definition
         self.bn_6 = nn.BatchNorm1d(hp.mel_freq)
         self.dropout_6 = torch.nn.Dropout(0.5)
     def forward(self, x):
-        x_orig = x # Store original for residual connection if postnet predicts residual
         x = x.transpose(2, 1)
-        x = self.conv_1(x); x = self.bn_1(x); x = torch.tanh(x); x = self.dropout_1(x)
-        x = self.conv_2(x); x = self.bn_2(x); x = torch.tanh(x); x = self.dropout_2(x)
-        x = self.conv_3(x); x = self.bn_3(x); x = torch.tanh(x); x = self.dropout_3(x)
-        x = self.conv_4(x); x = self.bn_4(x); x = torch.tanh(x); x = self.dropout_4(x)
-        x = self.conv_5(x); x = self.bn_5(x); x = torch.tanh(x); x = self.dropout_5(x)
-        x = self.conv_6(x); x = self.bn_6(x); x = self.dropout_6(x) # No Tanh on last layer for mel usually
+        x = self.conv_1(x)
+        x = self.bn_1(x); x = torch.tanh(x); x = self.dropout_1(x)
+        x = self.conv_2(x)
+        x = self.bn_2(x); x = torch.tanh(x); x = self.dropout_2(x)
+        x = self.conv_3(x)
+        x = self.bn_3(x); x = torch.tanh(x); x = self.dropout_3(x)
+        x = self.conv_4(x)
+        x = self.bn_4(x); x = torch.tanh(x); x = self.dropout_4(x)
+        x = self.conv_5(x)
+        x = self.bn_5(x); x = torch.tanh(x); x = self.dropout_5(x)
+        x = self.conv_6(x)
+        x = self.bn_6(x); x = self.dropout_6(x)
         x = x.transpose(1, 2)
-        return x # This is the residual, should be added to original mel_linear
+        return x
 
-class DecoderPreNet(nn.Module): # Your DecoderPreNet definition
+class DecoderPreNet(nn.Module):
     def __init__(self):
         super(DecoderPreNet, self).__init__()
         self.linear_1 = nn.Linear(hp.mel_freq, hp.embedding_size)
@@ -240,13 +255,13 @@ class DecoderPreNet(nn.Module): # Your DecoderPreNet definition
     def forward(self, x):
         x = self.linear_1(x)
         x = F.relu(x)
-        x = F.dropout(x, p=0.5, training=self.training)
+        x = F.dropout(x, p=0.5, training=True)
         x = self.linear_2(x)
-        x = F.relu(x)
-        x = F.dropout(x, p=0.5, training=self.training)
-        return x
+        x = F.relu(x)    
+        x = F.dropout(x, p=0.5, training=True)
+        return x    
 
-class TransformerTTS(nn.Module): # Your TransformerTTS definition
+class TransformerTTS(nn.Module):
     def __init__(self, device=DEVICE):
         super(TransformerTTS, self).__init__()
         self.encoder_prenet = EncoderPreNet()
@@ -259,132 +274,56 @@ class TransformerTTS(nn.Module): # Your TransformerTTS definition
         self.decoder_block_1 = DecoderBlock()
         self.decoder_block_2 = DecoderBlock()
         self.decoder_block_3 = DecoderBlock()
-        self.linear_1 = nn.Linear(hp.embedding_size, hp.mel_freq)
-        self.linear_2 = nn.Linear(hp.embedding_size, 1) # Stop token
+        self.linear_1 = nn.Linear(hp.embedding_size, hp.mel_freq) 
+        self.linear_2 = nn.Linear(hp.embedding_size, 1)
         self.norm_memory = nn.LayerNorm(normalized_shape=hp.embedding_size)
-        self.device = device
-
-    def forward(self, text, text_len, mel, mel_len): # For training/teacher-forcing
-        # ... (Your detailed forward pass for training, with all masks)
+    def forward(self, text, text_len, mel, mel_len):  
         N = text.shape[0]; S = text.shape[1]; TIME = mel.shape[1]
-        current_device = text.device
-
-        src_key_padding_mask = torch.zeros((N, S), device=current_device, dtype=torch.bool).masked_fill(~mask_from_seq_lengths(text_len, max_length=S), True)
-        src_mask = None # Typically encoder self-attention doesn't use a causal mask
-
-        tgt_key_padding_mask = torch.zeros((N, TIME), device=current_device, dtype=torch.bool).masked_fill(~mask_from_seq_lengths(mel_len, max_length=TIME), True)
-        tgt_mask = torch.zeros((TIME, TIME), device=current_device).masked_fill(torch.triu(torch.full((TIME, TIME), True, device=current_device, dtype=torch.bool), diagonal=1), float("-inf"))
-        memory_mask = None # Cross-attention mask, typically not needed unless specific structure
-
-        text_x = self.encoder_prenet(text)
-        pos_codes = self.pos_encoding(torch.arange(hp.max_mel_time, device=current_device))
-        text_s_dim = text_x.shape[1]
-        text_x = text_x + pos_codes[:text_s_dim]
-
-        text_x = self.encoder_block_1(text_x, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)
-        text_x = self.encoder_block_2(text_x, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)
-        text_x = self.encoder_block_3(text_x, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)
-        memory = self.norm_memory(text_x)
-
-        mel_x = self.decoder_prenet(mel)
-        mel_time_dim = mel_x.shape[1]
-        mel_x = mel_x + pos_codes[:mel_time_dim]
-
-        mel_x = self.decoder_block_1(x=mel_x, memory=memory, x_attn_mask=tgt_mask, x_key_padding_mask=tgt_key_padding_mask, memory_attn_mask=memory_mask, memory_key_padding_mask=src_key_padding_mask)
-        mel_x = self.decoder_block_2(x=mel_x, memory=memory, x_attn_mask=tgt_mask, x_key_padding_mask=tgt_key_padding_mask, memory_attn_mask=memory_mask, memory_key_padding_mask=src_key_padding_mask)
-        mel_x = self.decoder_block_3(x=mel_x, memory=memory, x_attn_mask=tgt_mask, x_key_padding_mask=tgt_key_padding_mask, memory_attn_mask=memory_mask, memory_key_padding_mask=src_key_padding_mask)
-
+        self.src_key_padding_mask = torch.zeros((N, S), device=text.device).masked_fill(~mask_from_seq_lengths(text_len, max_length=S), float("-inf"))
+        self.src_mask = torch.zeros((S, S), device=text.device).masked_fill(torch.triu(torch.full((S, S), True, dtype=torch.bool), diagonal=1).to(text.device), float("-inf"))
+        self.tgt_key_padding_mask = torch.zeros((N, TIME), device=mel.device).masked_fill(~mask_from_seq_lengths(mel_len, max_length=TIME), float("-inf"))
+        self.tgt_mask = torch.zeros((TIME, TIME), device=mel.device).masked_fill(torch.triu(torch.full((TIME, TIME), True, device=mel.device, dtype=torch.bool), diagonal=1), float("-inf"))
+        self.memory_mask = torch.zeros((TIME, S), device=mel.device).masked_fill(torch.triu(torch.full((TIME, S), True, device=mel.device, dtype=torch.bool), diagonal=1), float("-inf"))    
+        text_x = self.encoder_prenet(text) 
+        pos_codes = self.pos_encoding(torch.arange(hp.max_mel_time).to(mel.device))
+        S = text_x.shape[1]; text_x = text_x + pos_codes[:S]
+        text_x = self.encoder_block_1(text_x, attn_mask = self.src_mask, key_padding_mask = self.src_key_padding_mask)
+        text_x = self.encoder_block_2(text_x, attn_mask = self.src_mask, key_padding_mask = self.src_key_padding_mask)    
+        text_x = self.encoder_block_3(text_x, attn_mask = self.src_mask, key_padding_mask = self.src_key_padding_mask)
+        text_x = self.norm_memory(text_x)
+        mel_x = self.decoder_prenet(mel); mel_x = mel_x + pos_codes[:TIME]
+        mel_x = self.decoder_block_1(x=mel_x, memory=text_x, x_attn_mask=self.tgt_mask, x_key_padding_mask=self.tgt_key_padding_mask, memory_attn_mask=self.memory_mask, memory_key_padding_mask=self.src_key_padding_mask)
+        mel_x = self.decoder_block_2(x=mel_x, memory=text_x, x_attn_mask=self.tgt_mask, x_key_padding_mask=self.tgt_key_padding_mask, memory_attn_mask=self.memory_mask, memory_key_padding_mask=self.src_key_padding_mask)
+        mel_x = self.decoder_block_3(x=mel_x, memory=text_x, x_attn_mask=self.tgt_mask, x_key_padding_mask=self.tgt_key_padding_mask, memory_attn_mask=self.memory_mask, memory_key_padding_mask=self.src_key_padding_mask)
         mel_linear = self.linear_1(mel_x)
-        mel_postnet_residual = self.postnet(mel_linear) # Postnet predicts residual
-        mel_postnet = mel_linear + mel_postnet_residual
-
-        stop_token = self.linear_2(mel_x) # Sigmoid applied later
-
-        # Masking for training outputs
-        bool_mel_mask = tgt_key_padding_mask.unsqueeze(-1).repeat(1, 1, hp.mel_freq)
-        mel_linear = mel_linear.masked_fill(bool_mel_mask, 0.0)
-        mel_postnet = mel_postnet.masked_fill(bool_mel_mask, 0.0)
-        # Ensure stop_token is [N, TIME]
-        stop_token = stop_token.masked_fill(tgt_key_padding_mask.unsqueeze(-1) if stop_token.dim() == 3 else tgt_key_padding_mask, 1e3)
-        if stop_token.dim() == 3 and stop_token.shape[2] == 1:
-            stop_token = stop_token.squeeze(-1)
-
-
-        return mel_postnet, mel_linear, stop_token
-
+        mel_postnet = self.postnet(mel_linear)
+        mel_postnet = mel_linear + mel_postnet
+        stop_token = self.linear_2(mel_x)
+        bool_mel_mask = self.tgt_key_padding_mask.ne(0).unsqueeze(-1).repeat(1, 1, hp.mel_freq)
+        mel_linear = mel_linear.masked_fill(bool_mel_mask, 0)
+        mel_postnet = mel_postnet.masked_fill(bool_mel_mask, 0)
+        stop_token = stop_token.masked_fill(bool_mel_mask[:, :, 0].unsqueeze(-1), 1e3).squeeze(2)
+        return mel_postnet, mel_linear, stop_token 
 
     @torch.no_grad()
-    def inference(self, text, max_length=800, stop_token_threshold=0.5): # text: [1, seq_len]
-        self.eval()
-        N = text.shape[0] # Should be 1
-        current_device = text.device
-        text_lengths = torch.tensor([text.shape[1]], device=current_device)
-
-        # Encoder pass (once)
-        src_key_padding_mask_inf = torch.zeros((N, text.shape[1]), device=current_device, dtype=torch.bool) # All False initially
-        # No, src_key_padding_mask should be based on actual text length, even if N=1, S=text.shape[1]
-        # For inference with single item, it's often all False (no padding in input text usually)
-        # However, to be consistent with how `mask_from_seq_lengths` works:
-        src_key_padding_mask_inf = ~mask_from_seq_lengths(text_lengths, text.shape[1])
-
-
-        encoder_output = self.encoder_prenet(text)
-        pos_codes = self.pos_encoding(torch.arange(hp.max_mel_time, device=current_device))
-        text_s_dim = encoder_output.shape[1]
-        encoder_output = encoder_output + pos_codes[:text_s_dim]
-
-        encoder_output = self.encoder_block_1(encoder_output, key_padding_mask=src_key_padding_mask_inf)
-        encoder_output = self.encoder_block_2(encoder_output, key_padding_mask=src_key_padding_mask_inf)
-        encoder_output = self.encoder_block_3(encoder_output, key_padding_mask=src_key_padding_mask_inf)
-        memory = self.norm_memory(encoder_output)
-
-        # Decoder pass (iterative)
-        mel_input = torch.zeros((N, 1, hp.mel_freq), device=current_device) # SOS frame
-        generated_mel_frames = []
-
-        for i in range(max_length):
-            mel_lengths_inf = torch.tensor([mel_input.shape[1]], device=current_device)
-            # For decoder self-attention, causal mask is needed
-            tgt_mask_inf = torch.zeros((mel_input.shape[1], mel_input.shape[1]), device=current_device).masked_fill(
-                torch.triu(torch.full((mel_input.shape[1], mel_input.shape[1]), True, device=current_device, dtype=torch.bool), diagonal=1), float("-inf")
-            )
-            # Decoder input padding mask (all False as we build it frame by frame, no padding yet)
-            tgt_key_padding_mask_inf = torch.zeros((N, mel_input.shape[1]), device=current_device, dtype=torch.bool)
-
-
-            mel_x = self.decoder_prenet(mel_input)
-            mel_time_dim = mel_input.shape[1]
-            mel_x = mel_x + pos_codes[:mel_time_dim] # Positional encoding for current mel sequence
-
-            mel_x = self.decoder_block_1(x=mel_x, memory=memory, x_attn_mask=tgt_mask_inf, x_key_padding_mask=tgt_key_padding_mask_inf, memory_key_padding_mask=src_key_padding_mask_inf)
-            mel_x = self.decoder_block_2(x=mel_x, memory=memory, x_attn_mask=tgt_mask_inf, x_key_padding_mask=tgt_key_padding_mask_inf, memory_key_padding_mask=src_key_padding_mask_inf)
-            mel_x = self.decoder_block_3(x=mel_x, memory=memory, x_attn_mask=tgt_mask_inf, x_key_padding_mask=tgt_key_padding_mask_inf, memory_key_padding_mask=src_key_padding_mask_inf)
-
-            mel_linear_step = self.linear_1(mel_x[:, -1:, :]) # Predict only for the last frame
-            mel_postnet_residual_step = self.postnet(mel_linear_step)
-            current_mel_frame = mel_linear_step + mel_postnet_residual_step
-
-            generated_mel_frames.append(current_mel_frame)
-            mel_input = torch.cat([mel_input, current_mel_frame], dim=1) # Append to input for next step
-
-            # Stop token prediction (based on the last decoder output before linear to mel)
-            stop_token_logit = self.linear_2(mel_x[:, -1:, :]) # Stop token from last frame's decoder hidden state
-            stop_token_prob = torch.sigmoid(stop_token_logit.squeeze())
-
-            if stop_token_prob > stop_token_threshold:
-                # print(f"Stop token threshold reached at step {i+1}")
-                break
-            if mel_input.shape[1] > hp.max_mel_time -1: # Safety break based on max_mel_time
-                # print(f"Max mel time {hp.max_mel_time} almost reached.")
+    def inference(self, text, max_length=800, stop_token_threshold=0.5, with_tqdm=True):
+        self.eval(); self.train(False)
+        text_lengths = torch.tensor(text.shape[1]).unsqueeze(0).to(DEVICE)
+        N = 1
+        SOS = torch.zeros((N, 1, hp.mel_freq), device=DEVICE)
+        mel_padded = SOS
+        mel_lengths = torch.tensor(1).unsqueeze(0).to(DEVICE)
+        stop_token_outputs = torch.FloatTensor([]).to(text.device)
+        iters = range(max_length)
+        for _ in iters:
+            mel_postnet, mel_linear, stop_token = self(text, text_lengths, mel_padded, mel_lengths)
+            mel_padded = torch.cat([mel_padded, mel_postnet[:, -1:, :]], dim=1)
+            if torch.sigmoid(stop_token[:, -1]) > stop_token_threshold:      
                 break
-
-
-        if not generated_mel_frames:
-            print("Warning: TTS inference produced no mel frames.")
-            return torch.zeros((N, 0, hp.mel_freq), device=current_device) # Return empty tensor
-
-        final_mel_output = torch.cat(generated_mel_frames, dim=1)
-        return final_mel_output # Removed stop_token_outputs as it's not used by caller
+            else:
+                stop_token_outputs = torch.cat([stop_token_outputs, stop_token[:, -1:]], dim=1)
+                mel_lengths = torch.tensor(mel_padded.shape[1]).unsqueeze(0).to(DEVICE)
+        return mel_postnet, stop_token_outputs
 # --- (End of your model definitions) ---
 
 # --- Part 2: Model Loading ---
@@ -395,6 +334,7 @@ MARIAN_HUB_ID    = "MoHamdyy/marian-ar-en-translation"
 
 
 
+
 # Wrap model loading in a function to clearly see when it happens or to potentially delay it.
 # For Spaces, global loading is fine and preferred as it happens once.
 print("--- Starting Model Loading ---")