Update app.py

app.py

@@ -6,6 +6,10 @@ import torch.nn as nn
 import math
 import gradio as gr
 
+# Suppress torchtext deprecation warnings
+import torchtext
+torchtext.disable_torchtext_deprecation_warning()
+
 # Define the CSS styles
 css_styles = '''
 @import url('https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;600;700;800&display=swap');
@@ -84,10 +88,14 @@ class PositionalEncoding(nn.Module):
         self.dropout = nn.Dropout(p=dropout)
 
         pe = torch.zeros(max_len, d_model)
-        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
-        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        position = torch.arange(0, max_len, dtype=torch.float32).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float32) * (-math.log(10000.0) / d_model))
         pe[:, 0::2] = torch.sin(position * div_term)
-        pe[:, 1::2] = torch.cos(position * div_term)
+        if d_model % 2 == 1:
+            # For odd d_model, handle the last column
+            pe[:, 1::2] = torch.cos(position * div_term[:-1])
+        else:
+            pe[:, 1::2] = torch.cos(position * div_term)
         pe = pe.unsqueeze(1)
         self.register_buffer('pe', pe)
 
@@ -119,7 +127,10 @@ class TransformerModel(nn.Module):
         tgt = self.tgt_embedding(tgt) * math.sqrt(self.d_model)
         src = self.pos_encoder(src)
         tgt = self.pos_encoder(tgt)
-        memory = self.transformer(src, tgt, src_mask, tgt_mask, None, src_padding_mask, tgt_padding_mask, memory_key_padding_mask)
+        memory = self.transformer(
+            src, tgt, src_mask, tgt_mask, None,
+            src_padding_mask, tgt_padding_mask, memory_key_padding_mask
+        )
         output = self.fc_out(memory)
         return output
 
@@ -133,15 +144,21 @@ def translate(model, src_sentence, src_vocab, tgt_vocab, device, max_len=50):
     src_mask = torch.zeros((src_tensor.size(0), src_tensor.size(0)), device=device).type(torch.bool)
 
     with torch.no_grad():
-        memory = model.transformer.encoder(model.pos_encoder(model.src_embedding(src_tensor) * math.sqrt(model.d_model)), src_mask)
+        memory = model.transformer.encoder(
+            model.pos_encoder(model.src_embedding(src_tensor) * math.sqrt(model.d_model)),
+            src_mask
+        )
 
     ys = torch.ones(1, 1).fill_(tgt_vocab["<bos>"]).type(torch.long).to(device)
-    for i in range(max_len-1):
+    for _ in range(max_len-1):
         tgt_mask = nn.Transformer.generate_square_subsequent_mask(ys.size(0)).to(device)
 
         with torch.no_grad():
-            out = model.transformer.decoder(model.pos_encoder(model.tgt_embedding(ys) * math.sqrt(model.d_model)),
-                                            memory, tgt_mask)
+            out = model.transformer.decoder(
+                model.pos_encoder(model.tgt_embedding(ys) * math.sqrt(model.d_model)),
+                memory,
+                tgt_mask
+            )
             out = model.fc_out(out)
 
         prob = out[-1].detach()
@@ -153,7 +170,11 @@ def translate(model, src_sentence, src_vocab, tgt_vocab, device, max_len=50):
             break
 
     ys = ys.flatten()
-    translated_tokens = [tgt_vocab.get_itos()[token] for token in ys if token not in [tgt_vocab["<bos>"], tgt_vocab["<eos>"], tgt_vocab["<pad>"]]]
+    translated_tokens = [
+        tgt_vocab.get_itos()[token]
+        for token in ys
+        if token not in [tgt_vocab["<bos>"], tgt_vocab["<eos>"], tgt_vocab["<pad>"]]
+    ]
     return " ".join(translated_tokens)
 
 # Load the model and dataset
@@ -162,7 +183,7 @@ def load_model_and_data():
     print(f"Using device: {device}")
 
     # Load the dataset (for vocabulary)
-    file_path = 'newcode15M.txt'  # Replace with the path to your dataset file
+    file_path = 'path_to_your_dataset.txt'  # Replace with the path to your dataset file
     dataset = TranslationDataset(file_path)
 
     # Model hyperparameters (make sure these match your trained model)
@@ -176,10 +197,13 @@ def load_model_and_data():
     DROPOUT = 0.2
 
     # Initialize the model
-    model = TransformerModel(SRC_VOCAB_SIZE, TGT_VOCAB_SIZE, D_MODEL, NHEAD, NUM_ENCODER_LAYERS, NUM_DECODER_LAYERS, DIM_FEEDFORWARD, DROPOUT).to(device)
+    model = TransformerModel(
+        SRC_VOCAB_SIZE, TGT_VOCAB_SIZE, D_MODEL, NHEAD,
+        NUM_ENCODER_LAYERS, NUM_DECODER_LAYERS, DIM_FEEDFORWARD, DROPOUT
+    ).to(device)
 
     # Load the trained model
-    model.load_state_dict(torch.load('AllOneLM.pth', map_location=device))
+    model.load_state_dict(torch.load('path_to_your_model.pth', map_location=device))
     model.eval()
 
     return model, dataset.src_vocab, dataset.tgt_vocab, device
@@ -195,8 +219,8 @@ def translate_sentence(src_sentence):
 # Create Gradio interface
 iface = gr.Interface(
     fn=translate_sentence,
-    inputs=gr.inputs.Textbox(label="Enter a sentence:", lines=2, placeholder="Type here..."),
-    outputs=gr.outputs.Textbox(label="Translated:"),
+    inputs=gr.Textbox(label="Enter a sentence:", lines=2, placeholder="Type here..."),
+    outputs=gr.Textbox(label="Translated:"),
     title="Translation Talking Script",
     description="Enter a sentence to translate.",
     css=css_styles