Update app.py

app.py

@@ -1,16 +1,21 @@
+# Import Libraries
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForSeq2SeqLM
+from sentence_transformers import SentenceTransformer
 import torch
 import torch.nn.functional as F
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForSeq2SeqLM
-from sentence_transformers import SentenceTransformer
-import gradio as gr
-
-# Load models
+import faiss
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from google.colab import files
+# Load Models
 lang_detect_model = AutoModelForSequenceClassification.from_pretrained("papluca/xlm-roberta-base-language-detection")
 lang_detect_tokenizer = AutoTokenizer.from_pretrained("papluca/xlm-roberta-base-language-detection")
 trans_model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-200-distilled-600M")
 trans_tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
+embed_model = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
 
-# Language maps
+# Language Code Mappings
 id2lang = lang_detect_model.config.id2label
 
 nllb_langs = {
@@ -26,7 +31,14 @@ xlm_to_nllb = {
     "sa": "san_Deva"
 }
 
-# Detection
+# Get input directly
+input_text = input("✍️ Enter your text here for translation:\n").strip()
+
+if not input_text:
+    print("🚫 No input text provided. Exiting.")
+    raise SystemExit
+
+# Language detection
 def detect_language(text):
     inputs = lang_detect_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
     with torch.no_grad():
@@ -35,30 +47,169 @@ def detect_language(text):
         pred = torch.argmax(probs, dim=1).item()
     return id2lang[pred]
 
+if input_text.strip():
+    detected_lang = detect_language(input_text)
+    print(f"\n🔍 Detected Language Code: {detected_lang}")
+else:
+    print("🚫 Empty input text. Exiting.")
+    raise SystemExit
+
+# Choose target language
+print("\n🌐 Available Output Languages:")
+for code, lang in nllb_langs.items():
+    print(f"{code} → {lang}")
+
+target_code = input("\n🔤 Enter target language code (e.g., eng_Latn): ").strip()
+if target_code not in nllb_langs:
+    print("❌ Invalid code. Defaulting to English (eng_Latn).")
+    target_code = "eng_Latn"
+
 # Translation
-def translate_text(input_text, target_code):
-    detected = detect_language(input_text)
-    src_nllb = xlm_to_nllb.get(detected, "eng_Latn")
-    trans_tokenizer.src_lang = src_nllb
-    encoded = trans_tokenizer(input_text, return_tensors="pt", truncation=True, padding=True)
+def translate(text, src_code, tgt_code):
+    trans_tokenizer.src_lang = src_code
+    encoded = trans_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
     try:
-        lang_id = trans_tokenizer.convert_tokens_to_ids([target_code])[0]
-        generated = trans_model.generate(**encoded, forced_bos_token_id=lang_id)
-        result = trans_tokenizer.decode(generated[0], skip_special_tokens=True)
-        return f"Detected: {detected}\n\nTranslated:\n{result}"
+        target_lang_id = trans_tokenizer.convert_tokens_to_ids([tgt_code])[0]
+        generated = trans_model.generate(**encoded, forced_bos_token_id=target_lang_id)
+        return trans_tokenizer.decode(generated[0], skip_special_tokens=True)
     except:
-        return "Translation failed."
+        print("❌ Translation failed.")
+        return ""
+
+src_nllb = xlm_to_nllb.get(detected_lang, "eng_Latn")
+print(f"\n📜 Text to Translate:\n{input_text}\n")
+print(f"🌍 Source Language: {src_nllb} → Target Language: {target_code}")
+
+translated_text = translate(input_text, src_nllb, target_code)
+# Output translated text
+if translated_text.strip():
+    print("\n✅ Translation Complete!\n")
+    print("🔸 Translated Text:\n")
+    print(translated_text)
+
+    with open("translated_output.txt", "w", encoding="utf-8") as f:
+        f.write(translated_text)
+    files.download("translated_output.txt")
+else:
+    print("❌ No translated text produced.")
+    raise SystemExit
+#Create Corpus and FAISS Index
+corpus = [
+    "धर्म एव हतो हन्ति धर्मो रक्षति रक्षितः",
+    "Dharma when destroyed, destroys; when protected, protects.",
+    "The moon affects tides and mood, according to Jyotisha",
+    "One should eat according to the season – Rituacharya",
+    "Balance of Tridosha is health – Ayurveda principle",
+    "Ethics in Mahabharata reflect situational dharma",
+    "Meditation improves memory and mental clarity",
+    "Jyotisha links planetary motion with life patterns"
+]
+
+corpus_embeddings = embed_model.encode(corpus, convert_to_numpy=True)
+dimension = corpus_embeddings.shape[1]
+index = faiss.IndexFlatL2(dimension)
+index.add(corpus_embeddings)
+
+
+# Semantic Search Function
+def search_semantic(query, top_k=3):
+    query_embedding = embed_model.encode([query])
+    distances, indices = index.search(query_embedding, top_k)
+    return [(corpus[i], float(distances[0][idx])) for idx, i in enumerate(indices[0])]
+
+# Perform Semantic Search
+print("\n🔎 Searching for similar Sanskrit knowledge...")
+results = search_semantic(translated_text)
+
+print("\n🔍 Top Semantic Matches:")
+for i, (text, score) in enumerate(results, 1):
+    print(f"\n{i}. {text}\n   Similarity Score: {score:.4f}")
+
+# Visualize Semantic Scores
+labels = [f"{i+1}. Match {i+1}" for i in range(len(results))]
+scores = [score for _, score in results]
 
-# Gradio UI
-demo = gr.Interface(
-    fn=translate_text,
+plt.figure(figsize=(10, 6))
+bars = plt.barh(labels, scores, color="skyblue")
+
+plt.xlabel("Similarity Score", fontsize=12)
+plt.title("Top Semantic Matches", fontsize=14)
+plt.gca().invert_yaxis()
+
+for bar in bars:
+    plt.text(bar.get_width() + 0.5, bar.get_y() + 0.25, f"{bar.get_width():.2f}", fontsize=10)
+
+plt.tight_layout()
+plt.savefig("semantic_similarity_plot.png")
+plt.show()
+
+files.download("semantic_similarity_plot.png")
+
+# BLEU Score Evaluation
+from sacrebleu import corpus_bleu
+
+reference = input("📘 Enter correct human translation (for BLEU evaluation): ").strip()
+if reference:
+    bleu = corpus_bleu([translated_text], [[reference]])
+    print(f"\n📏 BLEU Score: {bleu.score:.2f}")
+else:
+    print("ℹ️ BLEU evaluation skipped (no reference entered).")
+
+# ✅ Gradio App Interface
+import gradio as gr
+import matplotlib.pyplot as plt
+from sacrebleu import corpus_bleu
+
+def full_pipeline(user_input_text, target_lang_code, human_ref=""):
+    if not user_input_text.strip():
+        return "⚠️ Empty input", "", [], "", ""
+
+    detected_lang = detect_language(user_input_text)
+    src_nllb = xlm_to_nllb.get(detected_lang, "eng_Latn")
+
+    translated = translate(user_input_text, src_nllb, target_lang_code)
+    if not translated:
+        return detected_lang, "❌ Translation failed", [], "", ""
+
+    sem_results = search_semantic(translated)
+    result_list = [f"{i+1}. {txt} (Score: {score:.2f})" for i, (txt, score) in enumerate(sem_results)]
+
+    labels = [f"{i+1}" for i in range(len(sem_results))]
+    scores = [score for _, score in sem_results]
+    plt.figure(figsize=(6, 4))
+    bars = plt.barh(labels, scores, color="lightgreen")
+    plt.xlabel("Similarity Score")
+    plt.title("Top Semantic Matches")
+    plt.gca().invert_yaxis()
+    for bar in bars:
+        plt.text(bar.get_width() + 0.01, bar.get_y() + 0.1, f"{bar.get_width():.2f}", fontsize=8)
+    plt.tight_layout()
+    plot_path = "/tmp/sem_plot.png"
+    plt.savefig(plot_path)
+    plt.close()
+
+    bleu_score = ""
+    if human_ref.strip():
+        bleu = corpus_bleu([translated], [[human_ref]])
+        bleu_score = f"{bleu.score:.2f}"
+
+    return detected_lang, translated, result_list, plot_path, bleu_score
+
+# 🚀 Launch Gradio Interface
+gr.Interface(
+    fn=full_pipeline,
     inputs=[
-        gr.Textbox(label="Input Text", lines=6),
-        gr.Dropdown(choices=list(nllb_langs.keys()), label="Target Language")
+        gr.Textbox(label="Input Text", lines=4, placeholder="Enter text to translate..."),
+        gr.Dropdown(label="Target Language", choices=list(nllb_langs.keys()), value="eng_Latn"),
+        gr.Textbox(label="(Optional) Human Reference Translation", lines=2, placeholder="Paste human translation here (for BLEU)...")
     ],
-    outputs="text",
-    title="Multilingual Text Translator 🌍",
-    description="Enter your text and select a target language to translate."
-)
-
-demo.launch()
+    outputs=[
+        gr.Textbox(label="Detected Language"),
+        gr.Textbox(label="Translated Text"),
+        gr.Textbox(label="Top Semantic Matches"),
+        gr.Image(label="Semantic Similarity Plot"),
+        gr.Textbox(label="BLEU Score")
+    ],
+    title="🌍 Multilingual Translator + Semantic Search",
+    description="Detects language → Translates → Finds related Sanskrit concepts → BLEU optional."
+).launch(debug=True)