Update app.py

app.py

@@ -8,7 +8,7 @@ from huggingface_hub import hf_hub_download
 # Configuration constants
 MODEL_REPO = "Gajendra5490/Scrached_Trained_Model"
 CURRENT_USER = "gajendra82"
-CURRENT_UTC = "2025-05-06 15:15:08"
+CURRENT_UTC = "2025-05-06 15:31:28"
 
 def setup_logging():
     logging.basicConfig(
@@ -22,6 +22,74 @@ def setup_logging():
 
 logger = setup_logging()
 
+class EnhancedTokenizer:
+    def __init__(self, vocab):
+        self.vocab = vocab
+        self.special_tokens = {
+            "<user>": len(vocab),
+            "<assistant>": len(vocab) + 1,
+            "<sep>": len(vocab) + 2,
+            "<eos>": len(vocab) + 3
+        }
+        
+    def encode(self, text):
+        tokens = text.split()
+        return [self.vocab.get(token, 0) if token not in self.special_tokens 
+                else self.special_tokens[token] for token in tokens]
+        
+    def decode(self, ids):
+        reverse_vocab = {v: k for k, v in self.vocab.items()}
+        reverse_special = {v: k for k, v in self.special_tokens.items()}
+        return " ".join(reverse_vocab.get(id, reverse_special.get(id, "<unk>")) 
+                       for id in ids)
+
+class ImprovedTransformer(torch.nn.Module):
+    def __init__(self, vocab_size, d_model=512, nhead=8, 
+                 num_encoder_layers=6, num_decoder_layers=6,
+                 dim_feedforward=2048, dropout=0.1, max_seq_length=128):
+        super().__init__()
+        
+        self.d_model = d_model
+        self.embedding = torch.nn.Embedding(vocab_size, d_model)
+        self.pos_encoder = torch.nn.Embedding(max_seq_length, d_model)
+        
+        encoder_layer = torch.nn.TransformerEncoderLayer(
+            d_model=d_model,
+            nhead=nhead,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout,
+            batch_first=True
+        )
+        decoder_layer = torch.nn.TransformerDecoderLayer(
+            d_model=d_model,
+            nhead=nhead,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout,
+            batch_first=True
+        )
+        
+        self.transformer_encoder = torch.nn.TransformerEncoder(
+            encoder_layer, 
+            num_encoder_layers
+        )
+        self.transformer_decoder = torch.nn.TransformerDecoder(
+            decoder_layer, 
+            num_decoder_layers
+        )
+        
+        self.output = torch.nn.Linear(d_model, vocab_size)
+        
+    def forward(self, src, tgt):
+        src_pos = torch.arange(0, src.size(1)).unsqueeze(0).to(src.device)
+        tgt_pos = torch.arange(0, tgt.size(1)).unsqueeze(0).to(tgt.device)
+        
+        src = self.embedding(src) + self.pos_encoder(src_pos)
+        tgt = self.embedding(tgt) + self.pos_encoder(tgt_pos)
+        
+        memory = self.transformer_encoder(src)
+        output = self.transformer_decoder(tgt, memory)
+        return self.output(output)
+
 class ModelInference:
     def __init__(self):
         self.logger = logging.getLogger(__name__)
@@ -31,20 +99,22 @@ class ModelInference:
 
     def load_model(self):
         try:
-            # Download model and tokenizer from your Hugging Face repository
-            self.logger.info(f"Downloading model from {MODEL_REPO}")
+            # Download model and tokenizer
+            self.logger.info(f"Downloading from {MODEL_REPO}")
             
             model_path = hf_hub_download(
                 repo_id=MODEL_REPO,
-                filename="model.pt"
+                filename="model.pt",
+                token=True  # Will use token if logged in
             )
             
             tokenizer_path = hf_hub_download(
                 repo_id=MODEL_REPO,
-                filename="tokenizer.json"
+                filename="tokenizer.json",
+                token=True
             )
             
-            # Load model
+            # Load model data
             self.logger.info("Loading model...")
             model_data = torch.load(
                 model_path,
@@ -58,11 +128,11 @@ class ModelInference:
                 tokenizer_data = json.load(f)
             
             # Initialize model
-            from model import ImprovedTransformer
             model_config = model_data['model_config']
+            vocab_size = len(tokenizer_data['vocab']) + 4  # Add special tokens
             
             self.model = ImprovedTransformer(
-                vocab_size=len(tokenizer_data['vocab']),
+                vocab_size=vocab_size,
                 d_model=model_config.get('d_model', 512),
                 nhead=model_config.get('nhead', 8),
                 num_encoder_layers=model_config.get('num_encoder_layers', 6),
@@ -76,13 +146,12 @@ class ModelInference:
             self.model.eval()
             
             # Initialize tokenizer
-            from tokenizer import EnhancedTokenizer
             self.tokenizer = EnhancedTokenizer(tokenizer_data['vocab'])
             
             self.logger.info("Model and tokenizer loaded successfully")
             
         except Exception as e:
-            self.logger.error(f"Error loading model: {e}")
+            self.logger.error(f"Error loading model: {str(e)}")
             raise
 
     @torch.no_grad()
@@ -120,26 +189,28 @@ class ModelInference:
             return answer
             
         except Exception as e:
-            self.logger.error(f"Error generating answer: {e}")
-            return f"Error: {str(e)}"
+            self.logger.error(f"Error generating answer: {str(e)}")
+            return f"Error generating answer: {str(e)}"
 
-# Initialize model
+# Initialize model globally
 try:
     print("Initializing model...")
     model = ModelInference()
     print("Model initialized successfully")
 except Exception as e:
-    print(f"Error initializing model: {e}")
+    print(f"Error initializing model: {str(e)}")
     model = None
 
 def process_input(input_text):
     """Process input through Gradio"""
+    global model
     try:
         if model is None:
-            return "Error: Model not initialized properly"
+            # Try to initialize model again
+            model = ModelInference()
         return model.generate_answer(input_text)
     except Exception as e:
-        logger.error(f"Error processing input: {e}")
+        logger.error(f"Error processing input: {str(e)}")
         return f"Error: {str(e)}"
 
 # Create Gradio interface
@@ -163,7 +234,6 @@ interface = gr.Interface(
     Enter your question and click submit to get a response.
     """,
     theme=gr.themes.Soft(),
-    allow_flagging="never",
     examples=[
         ["What is this about?"],
         ["Can you explain the topic?"],