Update app.py

app.py

@@ -1,25 +1,12 @@
 import gradio as gr
 import numpy as np
 import faiss
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM
 from sentence_transformers import SentenceTransformer
 
 # -------------------------------
-# Load models
+# Embedding model
 # -------------------------------
-LM_MODEL_NAME = "distilgpt2"
 EMBED_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-
-tokenizer = AutoTokenizer.from_pretrained(LM_MODEL_NAME)
-model = AutoModelForCausalLM.from_pretrained(LM_MODEL_NAME)
-tokenizer.pad_token = tokenizer.eos_token
-model.config.pad_token_id = tokenizer.eos_token_id
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model.to(device)
-model.eval()
-
 embed_model = SentenceTransformer(EMBED_MODEL_NAME)
 
 # -------------------------------
@@ -65,7 +52,7 @@ examples = [
     {
         "question": "What is dynamic programming?",
         "answer": "Dynamic programming is a problem-solving technique that breaks a problem into overlapping subproblems, stores the results of smaller subproblems, and reuses them to avoid repeated work."
-    },
+    }
 ]
 
 texts = [f"Question: {ex['question']}\nAnswer: {ex['answer']}" for ex in examples]
@@ -76,79 +63,38 @@ texts = [f"Question: {ex['question']}\nAnswer: {ex['answer']}" for ex in example
 embeddings = embed_model.encode(texts, convert_to_numpy=True, normalize_embeddings=True)
 dimension = embeddings.shape[1]
 
-# Use inner product on normalized embeddings ~ cosine similarity
+# Inner product on normalized vectors ~= cosine similarity
 index = faiss.IndexFlatIP(dimension)
 index.add(np.array(embeddings, dtype=np.float32))
 
 # -------------------------------
 # Retrieval threshold
 # -------------------------------
-# Higher = stricter. You can tune between 0.35 and 0.60
 SIMILARITY_THRESHOLD = 0.45
 
-
 # -------------------------------
-# Helpers
+# Helper functions
 # -------------------------------
-def retrieve_context(question: str, k: int = 3):
+def retrieve_best_match(question: str):
     question_embedding = embed_model.encode(
         [question],
         convert_to_numpy=True,
         normalize_embeddings=True
     )
 
-    scores, indices = index.search(np.array(question_embedding, dtype=np.float32), k)
-
-    retrieved = []
-    for score, idx in zip(scores[0], indices[0]):
-        idx = int(idx)
-        retrieved.append({
-            "score": float(score),
-            "question": examples[idx]["question"],
-            "answer": examples[idx]["answer"],
-            "text": texts[idx]
-        })
-
-    return retrieved
-
-
-def clean_answer(text: str) -> str:
-    if "Answer:" in text:
-        text = text.split("Answer:")[-1].strip()
+    scores, indices = index.search(np.array(question_embedding, dtype=np.float32), 1)
 
-    lines = [line.strip() for line in text.splitlines() if line.strip()]
-    cleaned_lines = []
-    seen_lines = set()
+    best_score = float(scores[0][0])
+    best_idx = int(indices[0][0])
 
-    for line in lines:
-        norm = line.lower()
-        if norm not in seen_lines:
-            seen_lines.add(norm)
-            cleaned_lines.append(line)
-
-    text = " ".join(cleaned_lines)
-
-    sentences = [s.strip() for s in text.split(".") if s.strip()]
-    unique_sentences = []
-    seen_sentences = set()
-
-    for s in sentences:
-        norm = s.lower()
-        if norm not in seen_sentences:
-            seen_sentences.add(norm)
-            unique_sentences.append(s)
-
-    if unique_sentences:
-        text = ". ".join(unique_sentences) + "."
-
-    return text.strip()
+    return best_score, examples[best_idx]
 
 
 def fallback_message() -> str:
     return (
         "I do not have enough reliable information in my current knowledge base to answer that question well. "
-        "Please ask about basic computer science topics like recursion, stacks, queues, arrays, linked lists, "
-        "binary search, Big O notation, processes, threads, or hash tables."
+        "Please ask about topics like recursion, stacks, queues, arrays, linked lists, binary search, Big O notation, "
+        "processes, threads, hash tables, or dynamic programming."
     )
 
 
@@ -157,59 +103,12 @@ def cs_tutor_app(question: str) -> str:
     if not question:
         return "Please enter a computer science question."
 
-    retrieved = retrieve_context(question, k=3)
-    best_score = retrieved[0]["score"]
+    best_score, best_match = retrieve_best_match(question)
 
-    # If best match is too weak, do not hallucinate
     if best_score < SIMILARITY_THRESHOLD:
         return fallback_message()
 
-    context = "\n\n".join(
-        [f"Question: {item['question']}\nAnswer: {item['answer']}" for item in retrieved]
-    )
-
-    prompt = f"""You are a helpful computer science tutor.
-
-Use the examples below to answer the user's question clearly and simply.
-Write a short beginner-friendly answer in 2 to 4 sentences.
-Do not repeat yourself.
-Do not include unrelated information.
-Only answer if the examples are relevant.
-
-Examples:
-{context}
-
-Question: {question}
-
-Answer:"""
-
-    inputs = tokenizer(
-        prompt,
-        return_tensors="pt",
-        truncation=True,
-        max_length=1024
-    ).to(device)
-
-    with torch.no_grad():
-        output = model.generate(
-            **inputs,
-            max_new_tokens=80,
-            do_sample=True,
-            temperature=0.7,
-            top_p=0.9,
-            repetition_penalty=1.2,
-            no_repeat_ngram_size=3,
-            pad_token_id=tokenizer.eos_token_id,
-            eos_token_id=tokenizer.eos_token_id
-        )
-
-    response = tokenizer.decode(output[0], skip_special_tokens=True)
-    response = clean_answer(response)
-
-    if len(response) < 20:
-        return fallback_message()
-
-    return response
+    return best_match["answer"]
 
 
 # -------------------------------
@@ -234,4 +133,3 @@ demo = gr.Interface(
 )
 
 demo.launch()
-