Update app.py

app.py

@@ -1,9 +1,9 @@
 import streamlit as st
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
-import torch
+from googletrans import Translator
 from langdetect import detect
 import time
 import warnings
+import os
 
 # Suppress warnings
 warnings.filterwarnings("ignore")
@@ -16,36 +16,28 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Load models (with caching to avoid reloading)
+
+# Initialize Google Translator
+translator = Translator()
+
+# Load GUVI dataset
 @st.cache_resource
-def load_models():
-    # Translation models
-    en_to_hi = pipeline("translation", model="Helsinki-NLP/opus-mt-en-hi")
-    hi_to_en = pipeline("translation", model="Helsinki-NLP/opus-mt-hi-en")
-    
-    en_to_ta = pipeline("translation", model="Helsinki-NLP/opus-mt-en-ta")
-    ta_to_en = pipeline("translation", model="Helsinki-NLP/opus-mt-ta-en")
-    
-    # For other languages, we'll use a multilingual model
-    multilingual_translator = pipeline("translation", model="facebook/mbart-large-50-many-to-many-mmt")
-    
-    # Load GUVI-specific model (fine-tuned GPT)
-    guvi_tokenizer = AutoTokenizer.from_pretrained("gpt2")
-    guvi_model = AutoModelForSeq2SeqLM.from_pretrained("gpt2")
-    
-    return {
-        "en_to_hi": en_to_hi,
-        "hi_to_en": hi_to_en,
-        "en_to_ta": en_to_ta,
-        "ta_to_en": ta_to_en,
-        "multilingual": multilingual_translator,
-        "guvi_tokenizer": guvi_tokenizer,
-        "guvi_model": guvi_model
-    }
+def load_guvi_dataset():
+    qa_pairs = {}
+    try:
+        with open("GUVI dataset.txt", "r", encoding="utf-8") as file:
+            lines = file.readlines()
+            for i in range(0, len(lines), 2):
+                if i+1 < len(lines):
+                    question = lines[i].strip()
+                    answer = lines[i+1].strip()
+                    qa_pairs[question.lower()] = answer
+    except FileNotFoundError:
+        st.error("GUVI dataset (guvi.txt) not found. Using GPT-only responses.")
+    return qa_pairs
 
-# Initialize models
-with st.spinner("Loading models... This may take a few minutes."):
-    models = load_models()
+# Initialize dataset
+qa_pairs = load_guvi_dataset()
 
 # Language mapping
 language_map = {
@@ -66,32 +58,30 @@ def detect_language(text):
     except:
         return "en"
 
-# Function to translate text
-def translate_text(text, source_lang, target_lang):
+# Function to translate text using Google Translator
+def translate_text(text, target_lang, source_lang='auto'):
     if source_lang == target_lang:
         return text
     
-    # Handle specific language pairs with dedicated models
-    if source_lang == "en" and target_lang == "hi":
-        return models["en_to_hi"](text)[0]['translation_text']
-    elif source_lang == "hi" and target_lang == "en":
-        return models["hi_to_en"](text)[0]['translation_text']
-    elif source_lang == "en" and target_lang == "ta":
-        return models["en_to_ta"](text)[0]['translation_text']
-    elif source_lang == "ta" and target_lang == "en":
-        return models["ta_to_en"](text)[0]['translation_text']
-    else:
-        # Use multilingual model for other languages
-        return models["multilingual"](text, src_lang=source_lang, tgt_lang=target_lang)[0]['translation_text']
+    try:
+        translation = translator.translate(text, src=source_lang, dest=target_lang)
+        return translation.text
+    except Exception as e:
+        st.warning(f"Translation error: {e}. Returning original text.")
+        return text
 
-# Function to generate GUVI-specific response
-def generate_guvi_response(prompt):
-    # Tokenize the input
-    inputs = models["guvi_tokenizer"](prompt, return_tensors="pt", max_length=512, truncation=True)
+# Function to generate response using GPT or GUVI dataset
+def generate_response(prompt):
+    # First check if the question exists in our GUVI dataset
+    lower_prompt = prompt.lower()
+    if lower_prompt in qa_pairs:
+        return qa_pairs[lower_prompt]
+    
+    # If not found in dataset, use Hugging Face model
+    inputs = models["chat_tokenizer"](prompt, return_tensors="pt", max_length=512, truncation=True)
     
-    # Generate response
     with torch.no_grad():
-        outputs = models["guvi_model"].generate(
+        outputs = models["chat_model"].generate(
             **inputs,
             max_length=200,
             num_beams=5,
@@ -99,10 +89,8 @@ def generate_guvi_response(prompt):
             temperature=0.7
         )
     
-    # Decode the output
-    response = models["guvi_tokenizer"].decode(outputs[0], skip_special_tokens=True)
-    
-    return response
+    return models["chat_tokenizer"].decode(outputs[0], skip_special_tokens=True)
+
 
 # Streamlit UI
 def main():
@@ -164,8 +152,8 @@ def main():
     st.sidebar.markdown("### About")
     st.sidebar.markdown("""
     This chatbot is powered by:
-    - Hugging Face Transformers
-    - Streamlit
+    - OpenAI GPT
+    - Google Translator
     - GUVI's custom knowledge base
     
     Developed for GUVI's multilingual learners.
@@ -197,18 +185,18 @@ def main():
         with st.spinner("Thinking..."):
             # Translate to English if needed
             if input_lang != "en":
-                translated_prompt = translate_text(prompt, input_lang, "en")
+                translated_prompt = translate_text(prompt, "en", input_lang)
             else:
                 translated_prompt = prompt
             
-            # Generate response from GUVI model
-            guvi_response = generate_guvi_response(translated_prompt)
+            # Generate response
+            response = generate_response(translated_prompt)
             
             # Translate back to user's language if needed
             if target_lang != "en":
-                final_response = translate_text(guvi_response, "en", target_lang)
+                final_response = translate_text(response, target_lang, "en")
             else:
-                final_response = guvi_response
+                final_response = response
             
             # Add a small delay for natural conversation flow
             time.sleep(0.5)