updated distractor generator

app/distractor_generator.py

@@ -1,272 +1,68 @@
-'''
-import google.generativeai as genai
-from .config import GOOGLE_API_KEY, GEMINI_MODEL_NAME, DISTRACTOR_BATCH_SIZE, MAX_PARALLEL_DISTRACTOR_BATCHES
-from .utils import get_logger, parse_json_from_response
-import json
-import random
-import asyncio
-import time
-
-logger = get_logger(__name__)
-
-genai.configure(api_key=GOOGLE_API_KEY)
-
-async def generate_distractors(qa_pairs):
-    logger.info(f"Generating distractors for {len(qa_pairs)} QA pairs.")
-    
-    if not qa_pairs:
-        logger.warning("No QA pairs provided to generate distractors.")
-        return []
-        
-    try:
-        model = genai.GenerativeModel(GEMINI_MODEL_NAME)
-        
-        example_input = [{
-            "question": "What is the primary goal of the A* search algorithm?",
-            "correct_answer": "To find the shortest path between a start and end node",
-            "context": "The A* search algorithm is widely used in pathfinding and graph traversal to find the shortest path between a start and end node."
-        }]
-        example_output = [{
-            "question": "What is the primary goal of the A* search algorithm?",
-            "correct_answer": "To find the shortest path between a start and end node",
-            "distractors": [
-                "To find the longest path in a graph",
-                "To visit every node in a graph"
-            ]
-        }]
-
-        # Optimize batch size based on number of QA pairs
-        if len(qa_pairs) <= 5:
-            BATCH_SIZE = 2
-        elif len(qa_pairs) <= 10:
-            BATCH_SIZE = 3
-        else:
-            BATCH_SIZE = DISTRACTOR_BATCH_SIZE
-            
-        batches = []
-        all_distractors_data = []
-        
-        # Create batches of questions
-        for i in range(0, len(qa_pairs), BATCH_SIZE):
-            batches.append(qa_pairs[i:i + BATCH_SIZE])
-        
-        logger.info(f"Processing distractor generation in {len(batches)} parallel batches")
-        
-        # Define an async function to process a single batch
-        async def process_batch(batch_index, batch_data):
-            start_time = time.time()
-            batch_id = f"batch-{batch_index+1}"
-            logger.info(f"Starting distractor generation for {batch_id} with {len(batch_data)} questions")
-            
-            prompt = f"""Generate three plausible but incorrect distractors for each of the following question-answer pairs.
-The distractors must be conceptually related to the correct answer but clearly wrong. They should be of the same entity type as the correct answer. For example, if the answer is a specific algorithm, the distractors should be other algorithm names.
-
-Return the output as a single, valid JSON array of objects. Do NOT include any text or markdown formatting outside of the JSON array. Each object must have three keys: "question", "correct_answer", and "distractors" (a list of 3 strings).
-
-EXAMPLE INPUT:
-{json.dumps(example_input, indent=2)}
-
-EXAMPLE OUTPUT:
-{json.dumps(example_output, indent=2)}
-
-ACTUAL INPUT:
-{json.dumps(batch_data, indent=2)}
-"""
-            try:
-                response = await model.generate_content_async(prompt)
-                distractors_data = await parse_json_from_response(response.text, logger)
-                processing_time = time.time() - start_time
-                logger.info(f"Completed distractor generation for {batch_id} in {processing_time:.2f}s")
-                return distractors_data or []
-            except Exception as e:
-                logger.error(f"Error processing distractor batch {batch_id}: {e}", exc_info=True)
-                return []
-        
-        # Process all batches in parallel, but limit concurrency to avoid overloading
-        semaphore = asyncio.Semaphore(MAX_PARALLEL_DISTRACTOR_BATCHES)
-        
-        async def process_with_semaphore(idx, batch):
-            async with semaphore:
-                return await process_batch(idx, batch)
-        
-        batch_results = await asyncio.gather(*[process_with_semaphore(i, batches[i]) for i in range(len(batches))], return_exceptions=True)
-        
-        # Combine results
-        for result in batch_results:
-            if isinstance(result, Exception):
-                logger.error(f"Exception during distractor generation: {result}", exc_info=True)
-                continue
-            all_distractors_data.extend(result)
-
-        if not all_distractors_data:
-            raise ValueError("Failed to parse any JSON from Gemini responses.")
-
-        distractor_map = {item['question']: item['distractors'] for item in all_distractors_data if 'question' in item and 'distractors' in item}
-        
-        all_correct_answers = [qa['correct_answer'] for qa in qa_pairs]
-        final_qa_with_distractors = []
-
-        for qa in qa_pairs:
-            question = qa['question']
-            correct_answer = qa['correct_answer']
-            # Preserve the original topic information
-            topic = qa.get('topic', 'Unknown')
-            
-            distractors = distractor_map.get(question, [])
-            
-            distractors = list(set(d for d in distractors if d.lower() != correct_answer.lower()))
-            
-            if len(distractors) < 3:
-                logger.warning(f"Not enough unique distractors for question: '{question}'. Using fallback.")
-                potential_fallback_distractors = [ans for ans in all_correct_answers if ans.lower() != correct_answer.lower()]
-                random.shuffle(potential_fallback_distractors)
-                
-                needed = 3 - len(distractors)
-                distractors.extend(potential_fallback_distractors[:needed])
-
-            # Keep the topic when adding distractors - preserve both topic fields
-            qa['distractors'] = distractors[:3]
-            
-            # Ensure topic is preserved
-            topic = qa.get('topic', 'Unknown')
-            qa['topic'] = topic  # Keep the original topic
-            
-            # Log topic information for debugging
-            logger.debug(f"Preserving topic '{topic}' for question: '{question[:30]}...'")
-            
-            final_qa_with_distractors.append(qa)
-
-        logger.info("Successfully generated and processed distractors.")
-        return final_qa_with_distractors
-        
-    except Exception as e:
-        logger.error(f"Error generating distractors: {e}", exc_info=True)
-        return [dict(qa, distractors=[]) for qa in qa_pairs]
-'''
-# --- Local GloVe+KNN distractor generation implementation with FlashText filtering ---
 import os
 import random
+import nltk
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.util import ngrams
 from .utils import get_logger
 
-logger = get_logger(__name__)
-
-try:
-    import gensim
-    from gensim.models import KeyedVectors
-except ImportError:
-    gensim = None
-    KeyedVectors = None
-    logger.warning("gensim is not installed. Please install it with 'pip install gensim' and download GloVe vectors.")
-
+# Download NLTK data if not already present
 try:
-    from flashtext import KeywordProcessor
-except ImportError:
-    KeywordProcessor = None
-    logger.warning("flashtext is not installed. Please install it with 'pip install flashtext'.")
+    nltk.data.find('tokenizers/punkt')
+except nltk.downloader.DownloadError:
+    nltk.download('punkt')
 
-# Construct a robust, absolute path to the GloVe model
-# This path navigates up from the script's location (/app/app) to the parent (/app) and then into the models directory
-GLOVE_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'models', 'glove.6B.100d.txt'))
-_glove_model = None
-
-def load_glove_model():
-    """Loads the GloVe model from the specified path."""
-    global _glove_model
-    if _glove_model is None:
-        if not gensim or not KeyedVectors:
-            raise ImportError("gensim is not installed. Please install it with 'pip install gensim'.")
-        if not os.path.exists(GLOVE_PATH):
-            # This check is important for debugging within the container
-            raise FileNotFoundError(f"GloVe file not found at {GLOVE_PATH}. Ensure it was downloaded and extracted during the Docker build.")
-        logger.info(f"Loading GloVe vectors from {GLOVE_PATH}...")
-        _glove_model = KeyedVectors.load_word2vec_format(GLOVE_PATH, no_header=True)
-        logger.info("GloVe vectors loaded successfully.")
-    return _glove_model
+logger = get_logger(__name__)
 
-# Get KNN-based distractors from GloVe
-def get_knn_distractors(answer, topn=10):
+def generate_distractors_from_context(correct_answer, context, num_distractors=3):
     """
-    Gets KNN-based distractors from the loaded GloVe model.
-    This version is improved to handle multi-word answers by focusing on the last word.
+    Generates phrase-based distractors from the given context.
     """
-    model = load_glove_model()
-    answer_lower = answer.lower()
-    
-    # Try to find synonyms for the last word of the answer phrase
-    last_word = answer_lower.split()[-1]
-    if last_word in model:
-        distractors = [w for w, _ in model.most_similar(last_word, topn=topn + 10) if w.isalpha() and w not in answer_lower.split()]
-        if len(distractors) >= topn:
-            return distractors[:topn]
-
-    # Fallback to using the whole answer phrase if the last-word approach fails
-    if answer_lower in model:
-        distractors = [w for w, _ in model.most_similar(answer_lower, topn=topn + 5) if w.isalpha() and w != answer_lower]
-        return distractors[:topn]
-        
-    return []
+    if not context:
+        return []
 
-# Use FlashText to filter out distractors that are too similar to the answer or question
-def filter_distractors_with_flashtext(distractors, answer, question):
-    """
-    Filters distractors to remove any that contain the correct answer.
-    The filtering of question words has been removed to be less aggressive.
-    """
-    if not KeywordProcessor:
-        return [d for d in distractors if d.lower() != answer.lower() and d.lower() not in question.lower()]
-    kp = KeywordProcessor(case_sensitive=False)
-    kp.add_keyword(answer)
-    # The aggressive filtering of question words has been removed to improve the number of distractors found.
-    # for word in question.split():
-    #     kp.add_keyword(word)
-    filtered = [d for d in distractors if not kp.extract_keywords(d)]
-    return filtered
+    # Tokenize the context into sentences and the answer into words
+    sentences = sent_tokenize(context)
+    answer_words = word_tokenize(correct_answer.lower())
+    n = len(answer_words)
+
+    distractors = []
+    for sentence in sentences:
+        if correct_answer.lower() not in sentence.lower():
+            words = word_tokenize(sentence.lower())
+            # Generate n-grams of the same length as the answer
+            for ngram in ngrams(words, n):
+                distractor_phrase = " ".join(ngram)
+                # Avoid adding duplicates
+                if distractor_phrase not in distractors:
+                    distractors.append(distractor_phrase)
+    
+    # Return a random sample of the generated distractors
+    random.shuffle(distractors)
+    return distractors[:num_distractors]
 
 async def generate_distractors(qa_pairs):
     """
-    Generates distractors for MCQ pipeline using local GloVe embeddings and FlashText filtering.
-    Returns a list of QA dicts with a 'distractors' key (list of 3 strings).
+    Generates distractors for MCQ pipeline using a context-aware approach only.
     """
-    logger.info(f"Generating distractors for {len(qa_pairs)} QA pairs (local GloVe + FlashText mode).")
+    logger.info(f"Generating distractors for {len(qa_pairs)} QA pairs with context-aware strategy.")
     if not qa_pairs:
-        logger.warning("No QA pairs provided to generate distractors.")
         return []
-    try:
-        all_correct_answers = [qa['correct_answer'] for qa in qa_pairs]
-        final_qa_with_distractors = []
-        for qa in qa_pairs:
-            question = qa['question']
-            correct_answer = qa['correct_answer']
-            topic = qa.get('topic', 'Unknown')
-            # Fetch more candidates from GloVe to improve the chances of finding good distractors
-            distractors = get_knn_distractors(correct_answer, topn=30)
-            # Filter with FlashText for quality
-            distractors = filter_distractors_with_flashtext(distractors, correct_answer, question)
-            # Remove duplicates and the correct answer
-            distractors = list(dict.fromkeys([d for d in distractors if d.lower() != correct_answer.lower()]))
-            # Fallback: use other correct answers from the same topic as distractors
-            if len(distractors) < 3:
-                logger.warning(f"Not enough unique distractors for question: '{question}'. Using fallback from same topic.")
-                potential_fallback_distractors = [
-                    qa_other['correct_answer'] 
-                    for qa_other in qa_pairs 
-                    if qa_other['topic'] == topic and qa_other['correct_answer'].lower() != correct_answer.lower()
-                ]
-                if not potential_fallback_distractors:
-                    # If no other answers from the same topic, use any other answer
-                    logger.warning(f"No other answers in topic '{topic}'. Using fallback from all topics.")
-                    potential_fallback_distractors = [ans for ans in all_correct_answers if ans.lower() != correct_answer.lower()]
 
-                random.shuffle(potential_fallback_distractors)
-                
-                needed = 3 - len(distractors)
-                distractors.extend(potential_fallback_distractors[:needed])
-            qa['distractors'] = distractors[:3]
-            qa['topic'] = topic
-            logger.debug(f"Preserving topic '{topic}' for question: '{question[:30]}...'")
-            final_qa_with_distractors.append(qa)
-        logger.info("Successfully generated and processed distractors (local mode, MCQ pipeline ready).")
-        return final_qa_with_distractors
-    except Exception as e:
-        logger.error(f"Error generating distractors: {e}", exc_info=True)
-        return [dict(qa, distractors=[]) for qa in qa_pairs]
+    final_qa_with_distractors = []
+
+    for qa in qa_pairs:
+        correct_answer = qa['correct_answer']
+        context = qa.get('context', '')
+
+        # Generate distractors from context
+        distractors = generate_distractors_from_context(correct_answer, context, num_distractors=3)
+
+        # If not enough distractors are found, the list will be shorter than 3
+        if len(distractors) < 3:
+            logger.warning(f"Could not generate 3 distractors for '{correct_answer}'. Only found {len(distractors)}.")
+
+        qa['distractors'] = distractors
+        final_qa_with_distractors.append(qa)
+
+    logger.info("Successfully generated and processed distractors.")
+    return final_qa_with_distractors

requirements.txt

@@ -13,4 +13,5 @@ tqdm==4.67.1
 gunicorn==23.0.0
 pydantic-settings==2.3.4
 gensim
-huggingface_hub==0.34.0
+huggingface_hub==0.34.0
+nltk