Update app.py

app.py

@@ -9,9 +9,9 @@ import torch
 from transformers import BertTokenizer, BertModel
 import torch.nn.functional as F
 
-# Load pre-trained BERT model and tokenizer
+# Load pre-trained models
 tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
-model = BertModel.from_pretrained('bert-base-uncased')
+bert_model = BertModel.from_pretrained('bert-base-uncased')
 sentence_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
 
 # Initialize Groq client
@@ -23,14 +23,11 @@ system_prompt = {
     "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 = ''
@@ -49,13 +46,11 @@ async def chat_groq(message, history):
             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
+    lang_str = '+'.join(languages)
     return pytesseract.image_to_string(image=image, lang=lang_str)
 
-# Assign badges based on the grade
 def assign_badge(grade):
     if grade == 5:
         return "Gold Badge 🌟"
@@ -66,7 +61,6 @@ def assign_badge(grade):
     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"}
@@ -77,7 +71,6 @@ def detailed_feedback(similarity_score):
     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
@@ -90,59 +83,50 @@ def get_grade(similarity_score):
     else:
         return 1
 
-# 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)
+        outputs = bert_model(**inputs)
     embeddings = outputs.last_hidden_state.mean(dim=1)
     return embeddings
 
-# Function to calculate cosine similarity
 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):
     bert_similarity = calculate_cosine_similarity(get_bert_embedding(student_answer), get_bert_embedding(teacher_answer))
-    
-    # Emphasize the importance of BERT similarity
     sentence_similarity = calculate_sentence_similarity(student_answer, teacher_answer)
-    
+
     # Use a higher weight for BERT similarity
-    final_similarity = (0.8 * bert_similarity + 0.2 * sentence_similarity)
+    final_similarity = (0.75 * bert_similarity + 0.25 * sentence_similarity)
     return final_similarity
 
-# Function to extract keywords from the model answer
 def extract_keywords(text):
     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) if len(teacher_keywords) > 0 else 1)  # Ratio of matching keywords
+    return keyword_overlap / (len(teacher_keywords) if len(teacher_keywords) > 0 else 1)
 
-# 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)
     
-    # Calculate semantic similarity primarily with BERT
+    # Calculate semantic similarity
     semantic_similarity = compare_answers(student_answer, model_answer)
     
-    # Include keyword similarity
+    # Calculate keyword similarity
     keyword_similarity = check_keywords(student_answer, model_answer)
     
-    # Combine semantic similarity with keyword presence check, emphasizing semantic similarity
-    combined_similarity = (semantic_similarity + (0.5 * keyword_similarity)) / 1.5
+    # Adjust the weight of keyword similarity
+    combined_similarity = (0.9 * semantic_similarity + 0.1 * keyword_similarity)
     grade = get_grade(combined_similarity)
     feedback = f"Student's answer: {student_answer}\nTeacher's answer: {model_answer}"
     badge = assign_badge(grade)
@@ -150,18 +134,15 @@ def evaluate_answer(image, languages, model_answer):
     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, combined_similarity * 100, feedback, badge, detailed_feedback_msg, prompt
 
-# 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=[]):
     grade, similarity_score, feedback, badge, detailed_feedback_msg, prompt = evaluate_answer(image, languages, model_answer)
     response = ""
     async for result in chat_groq(prompt, history):
-        response = result  # Get the Groq response
+        response = result
     return grade, similarity_score, feedback, badge, detailed_feedback_msg, response
 
-# Get available Tesseract languages
 language_choices = pytesseract.get_languages()
 
-# Define Gradio interface
 interface = gr.Interface(
     fn=gradio_interface,
     inputs=[
@@ -174,7 +155,6 @@ interface = gr.Interface(
         gr.Text(label="Grade"), 
         gr.Number(label="Similarity Score (%)"), 
         gr.Text(label="Feedback"), 
-        # gr.HTML(label="Visual Feedback"), 
         gr.Text(label="Badge"), 
         gr.JSON(label="Detailed Feedback"), 
         gr.Text(label="Generated Response")