Update app.py

app.py

@@ -1,13 +1,10 @@
 import os
 from groq import Groq
 import gradio as gr 
-from transformers import pipeline
 import pytesseract
 from sentence_transformers import SentenceTransformer, util
 from PIL import Image
 from typing import List
-import requests
-
 import torch
 from transformers import BertTokenizer, BertModel
 import torch.nn.functional as F
@@ -15,57 +12,16 @@ import torch.nn.functional as F
 # Load pre-trained BERT model and tokenizer
 tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
 model = BertModel.from_pretrained('bert-base-uncased')
-
+sentence_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
 
 # Initialize Groq client
 client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
 
-# System prompt for Groq
-system_prompt = {
-    "role": "system",
-    "content": "You are a useful assistant. You reply with efficient answers."
-}
-
-# Function to interact with Groq for generating response
-async def chat_groq(message, history):
-    messages = [system_prompt]
-
-    for msg in history:
-        messages.append({"role": "user", "content": str(msg[0])})
-        messages.append({"role": "assistant", "content": str(msg[1])})
-
-    messages.append({"role": "user", "content": str(message)})
-
-    response_content = ''
-    
-    stream = client.chat.completions.create(
-        model="llama3-70b-8192",
-        messages=messages,
-        max_tokens=1024,
-        temperature=1.3,
-        stream=True
-    )
-
-    for chunk in stream:
-        content = chunk.choices[0].delta.content
-        if content:
-            response_content += chunk.choices[0].delta.content
-        yield response_content
-
-# Extract text from an image using Tesseract
-def extract_text_from_image(filepath: str, languages: List[str]):
-    image = Image.open(filepath)
-    lang_str = '+'.join(languages)  # Join languages for Tesseract
-    return pytesseract.image_to_string(image=image, lang=lang_str)
-
-
-
 # Function to get BERT embeddings
 def get_bert_embedding(text):
     inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True)
     with torch.no_grad():
         outputs = model(**inputs)
-    # Get the embeddings from the last hidden state
     embeddings = outputs.last_hidden_state.mean(dim=1)
     return embeddings
 
@@ -74,65 +30,49 @@ def calculate_cosine_similarity(embedding1, embedding2):
     similarity = F.cosine_similarity(embedding1, embedding2)
     return similarity.item()
 
+# Function to calculate sentence embedding similarity
+def calculate_sentence_similarity(text1, text2):
+    embedding1 = sentence_model.encode(text1, convert_to_tensor=True)
+    embedding2 = sentence_model.encode(text2, convert_to_tensor=True)
+    return util.pytorch_cos_sim(embedding1, embedding2).item()
+
 # Function to compare logic of student and teacher answers
 def compare_answers(student_answer, teacher_answer):
-    student_embedding = get_bert_embedding(student_answer)
-    teacher_embedding = get_bert_embedding(teacher_answer)
-    similarity_score = calculate_cosine_similarity(student_embedding, teacher_embedding)
-    return similarity_score
-
-
-
-
-# Assign badges based on the grade
-def assign_badge(grade):
-    if grade == 5:
-        return "Gold Badge 🌟"
-    elif grade == 4:
-        return "Silver Badge 🥈"
-    elif grade == 3:
-        return "Bronze Badge 🥉"
-    else:
-        return "Keep Improving Badge 💪"
-
-
-# Categorize feedback into clarity, completeness, and accuracy
-def detailed_feedback(similarity_score):
-    if similarity_score >= 0.9:
-        return {"Clarity": "Excellent", "Completeness": "Complete", "Accuracy": "Accurate"}
-    elif similarity_score >= 0.8:
-        return {"Clarity": "Good", "Completeness": "Almost Complete", "Accuracy": "Mostly Accurate"}
-    elif similarity_score >= 0.7:
-        return {"Clarity": "Fair", "Completeness": "Partial", "Accuracy": "Some Errors"}
-    else:
-        return {"Clarity": "Needs Improvement", "Completeness": "Incomplete", "Accuracy": "Inaccurate"}
-
-# Assign grades based on similarity score
-def get_grade(similarity_score):
-    if similarity_score >= 0.9:
-        return 5
-    elif similarity_score >= 0.8:
-        return 4
-    elif similarity_score >= 0.7:
-        return 3
-    elif similarity_score >= 0.6:
-        return 2
-    else:
-        return 1
-
-
+    bert_similarity = calculate_cosine_similarity(get_bert_embedding(student_answer), get_bert_embedding(teacher_answer))
+    sentence_similarity = calculate_sentence_similarity(student_answer, teacher_answer)
+    # Combine scores with weights to emphasize one method over another if needed
+    final_similarity = (0.5 * bert_similarity + 0.5 * sentence_similarity)
+    return final_similarity
+
+# Function to extract keywords from the model answer (simple keyword extraction)
+def extract_keywords(text):
+    # Split text into words and count them
+    return set(text.lower().split())
+
+# Adjust grading based on key terms present in student answer
+def check_keywords(student_answer, model_answer):
+    student_keywords = extract_keywords(student_answer)
+    teacher_keywords = extract_keywords(model_answer)
+    keyword_overlap = len(student_keywords.intersection(teacher_keywords))
+    return keyword_overlap / len(teacher_keywords)  # Ratio of matching keywords
 
 # Function to evaluate student's answer by comparing it to a model answer
 def evaluate_answer(image, languages, model_answer):
     student_answer = extract_text_from_image(image, languages)
-    similarity_score = compare_answers(student_answer, model_answer)
-    grade = get_grade(similarity_score)
+    semantic_similarity = compare_answers(student_answer, model_answer)
+    keyword_similarity = check_keywords(student_answer, model_answer)
+    
+    # Combine semantic similarity with keyword presence check
+    combined_similarity = (semantic_similarity + keyword_similarity) / 2
+    grade = get_grade(combined_similarity)
     feedback = f"Student's answer: {student_answer}\nTeacher's answer: {model_answer}"
-    # visual_feedback = generate_sequence_feedback(student_answer, model_answer)
     badge = assign_badge(grade)
-    detailed_feedback_msg = detailed_feedback(similarity_score)
+    detailed_feedback_msg = detailed_feedback(combined_similarity)
     prompt = f"The student got grade: {grade} when the student's answer is: {student_answer} and the teacher's answer is: {model_answer}. Justify the grade given to the student."
-    return grade, similarity_score * 100, feedback, badge, detailed_feedback_msg, prompt
+    return grade, combined_similarity * 100, feedback, badge, detailed_feedback_msg, prompt
+
+# The rest of your existing code...
+
 
 # Main interface function for Gradio
 async def gradio_interface(image, languages: List[str], model_answer="The process of photosynthesis helps plants produce glucose using sunlight.", prompt="", history=[]):