ACRIMA/extract_unique_questions.py

import json
import os
import random
from typing import List, Dict

def get_random_image_path(answer: str) -> str:
    """
    Get a random image path based on the answer type.
    
    Args:
        answer (str): The answer to determine which folder to select from
        
    Returns:
        str: Random image path from the appropriate folder
    """
    if answer == "Fundus imaging":
        # Randomly choose between Glaucoma and Non Glaucoma folders
        folder = random.choice(["Glaucoma", "Non Glaucoma"])
        folder_path = "ACRIMA/train/" + folder
    elif answer == "It's normal, glaucoma negative":
        folder_path = "ACRIMA/train/Non Glaucoma"
    elif answer == "Glaucoma positive.":
        folder_path = "ACRIMA/train/Glaucoma"
    else:
        raise ValueError(f"Unknown answer type: {answer}")
    
    # Get all image files from the selected folder
    image_files = [f for f in os.listdir(folder_path) if f.endswith(('.png', '.jpg', '.jpeg'))]
    if not image_files:
        raise ValueError(f"No images found in {folder_path}")
    
    # Select a random image
    random_image = random.choice(image_files)
    return f"{folder_path}/{random_image}"

def extract_unique_questions(json_data: List[Dict]) -> Dict[str, Dict]:
    """
    Extract unique questions from the JSON data where questions with different answers are considered different.
    Saves the complete original question item for each unique question.
    
    Args:
        json_data (List[Dict]): List of dictionaries containing question data
        
    Returns:
        Dict[str, Dict]: Dictionary mapping unique questions to their complete original items
    """
    unique_questions = {}
    
    for item in json_data:
        question = item['question']
        answer = item['gt_answer']
        
        # Create a key that combines question and answer to ensure uniqueness
        key = f"{question}|{answer}"
        
        if key not in unique_questions:
            # Create a copy of the item to avoid modifying the original
            new_item = item.copy()
            # Replace the image path with a random one based on the answer
            new_item['image_path'] = get_random_image_path(answer)
            unique_questions[key] = new_item
    
    return unique_questions

def extend_to_100_questions(unique_questions: Dict[str, Dict]) -> List[Dict]:
    """
    Extend the number of questions to 100 by randomly duplicating existing questions.
    
    Args:
        unique_questions (Dict[str, Dict]): Dictionary of unique questions
        
    Returns:
        List[Dict]: List of 100 questions
    """
    questions_list = list(unique_questions.values())
    current_count = len(questions_list)
    
    # If we already have more than 100 questions, just return the first 100
    if current_count >= 100:
        return questions_list[:100]
    
    # Calculate how many more questions we need
    needed = 100 - current_count
    
    # Randomly select questions to duplicate
    for _ in range(needed):
        # Select a random question
        random_question = random.choice(questions_list)
        # Create a copy of the question
        new_question = random_question.copy()
        # Generate a new random image path based on the answer
        new_question['image_path'] = get_random_image_path(new_question['gt_answer'])
        # Add to the list
        questions_list.append(new_question)
    
    return questions_list

def refill_question_ids(questions: List[Dict]) -> List[Dict]:
    """
    Refill question_ids with sequential IDs.
    
    Args:
        questions (List[Dict]): List of questions
        
    Returns:
        List[Dict]: List of questions with sequential IDs
    """
    for i, question in enumerate(questions):
        # Format the ID with leading zeros to maintain 4 digits
        question['question_id'] = f"ACRIMA_{i:04d}"
    return questions

def main():
    # Set random seed for reproducibility
    random.seed(42)
    
    # Read the JSON file
    with open('Original_open/ACRIMA.json', 'r') as f:
        data = json.load(f)
    
    # Extract unique questions
    unique_questions = extract_unique_questions(data)
    
    unique_answers = set(item['gt_answer'] for item in data)
    print("\nUnique answers in the original file:")
    for answer in sorted(unique_answers):
        print(f"- {answer}")
    print(f"\nTotal number of unique answers: {len(unique_answers)}")
    
    # Extend to 100 questions
    extended_questions = extend_to_100_questions(unique_questions)
    
    # Refill question IDs sequentially
    final_questions = refill_question_ids(extended_questions)
    
    # Print the results
    print(f"Original number of unique questions: {len(unique_questions)}")
    print(f"Extended to {len(final_questions)} questions")
    
    # Save the extended questions to a new JSON file
    with open('ACRIMA/unique_questions.json', 'w') as f:
        json.dump(final_questions, f, indent=4)
    print("\nExtended questions have been saved to 'ACRIMA/unique_questions.json'")

if __name__ == "__main__":
    main()