Разработка AI-системы автоматической генерации тестов и экзаменационных заданий

Разработка системы AI-автогенерации тестов и экзаменов

AI-генерация тестовых заданий создаёт уникальные вопросы по учебному материалу, разного уровня сложности (таксономия Блума), с нескольких вариантах исполнения — исключает списывание при массовом тестировании.

Многоуровневая генерация вопросов

from openai import AsyncOpenAI
from enum import Enum
import json

client = AsyncOpenAI()

class BloomLevel(Enum):
    REMEMBER = "remember"       # запомнить факты
    UNDERSTAND = "understand"   # объяснить концепции
    APPLY = "apply"            # применить в новой ситуации
    ANALYZE = "analyze"        # разложить на части
    EVALUATE = "evaluate"      # оценить критически
    CREATE = "create"          # создать новое

BLOOM_PROMPTS = {
    BloomLevel.REMEMBER: "Создай вопрос на запоминание фактов, дат, определений",
    BloomLevel.UNDERSTAND: "Создай вопрос на понимание: объяснение, перефразирование, примеры",
    BloomLevel.APPLY: "Создай практическую задачу: применение знаний в новой ситуации",
    BloomLevel.ANALYZE: "Создай вопрос на анализ: сравнение, выявление причин, структурирование",
    BloomLevel.EVALUATE: "Создай вопрос на оценку: обоснование суждения, критика подхода",
    BloomLevel.CREATE: "Создай задание на синтез: разработка решения, создание продукта",
}

async def generate_question(
    topic: str,
    source_text: str,
    question_type: str,  # multiple_choice, true_false, open_answer, case_study
    bloom_level: BloomLevel = BloomLevel.UNDERSTAND,
    difficulty: str = "medium"
) -> dict:
    response = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": f"""Создай тестовый вопрос.
            Тип: {question_type}.
            Уровень таксономии Блума: {bloom_level.value}. {BLOOM_PROMPTS[bloom_level]}.
            Сложность: {difficulty}.

            Для multiple_choice: 4 варианта, 1 правильный, 3 правдоподобных дистрактора.
            Для open_answer: эталонный ответ + критерии оценки.
            Для case_study: ситуация + 3-5 вопросов разного уровня.

            Верни JSON: {{
                question: "текст вопроса",
                type: "{question_type}",
                bloom_level: "{bloom_level.value}",
                options: ["A...", "B...", ...],  // только для MC
                correct_answer: "...",
                explanation: "почему именно этот ответ",
                scoring_rubric: {{...}}  // для open_answer
            }}"""
        }, {
            "role": "user",
            "content": f"Тема: {topic}\n\nМатериал:\n{source_text[:2000]}"
        }],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

Генерация полного варианта экзамена

async def generate_exam_variant(
    course_topics: list[str],
    total_questions: int = 30,
    time_limit_min: int = 60,
    bloom_distribution: dict = None
) -> dict:
    """
    bloom_distribution: {BloomLevel.REMEMBER: 0.3, BloomLevel.APPLY: 0.4, ...}
    По умолчанию: 20% Remember, 30% Understand, 30% Apply, 20% Analyze
    """
    if not bloom_distribution:
        bloom_distribution = {
            BloomLevel.REMEMBER: 0.2,
            BloomLevel.UNDERSTAND: 0.3,
            BloomLevel.APPLY: 0.3,
            BloomLevel.ANALYZE: 0.2
        }

    questions_by_level = {
        level: int(total_questions * fraction)
        for level, fraction in bloom_distribution.items()
    }

    all_questions = []
    tasks = []

    for level, count in questions_by_level.items():
        for i in range(count):
            topic = course_topics[i % len(course_topics)]
            q_type = "multiple_choice" if level in [BloomLevel.REMEMBER, BloomLevel.UNDERSTAND] else "open_answer"
            tasks.append(generate_question(
                topic=topic,
                source_text="",
                question_type=q_type,
                bloom_level=level
            ))

    all_questions = await asyncio.gather(*tasks)

    return {
        "variant_id": f"V{random.randint(1000, 9999)}",
        "time_limit_min": time_limit_min,
        "total_points": sum(q.get("points", 1) for q in all_questions),
        "questions": list(all_questions),
        "bloom_distribution": {l.value: c for l, c in questions_by_level.items()}
    }

Автоматическая проверка открытых ответов

async def auto_grade_open_answer(
    question: str,
    correct_answer: str,
    rubric: dict,
    student_answer: str
) -> dict:
    response = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": f"""Проверяй ответ студента по рубрике.
            Вопрос: {question}
            Эталонный ответ: {correct_answer}
            Критерии оценки: {json.dumps(rubric, ensure_ascii=False)}

            Оцени ответ и верни JSON:
            {{score: 0-100, feedback: "подробная обратная связь", strengths: [], weaknesses: []}}"""
        }, {
            "role": "user",
            "content": f"Ответ студента: {student_answer}"
        }],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

Антиплагиат — уникальные варианты

async def generate_unique_variants(
    base_question: str,
    n_variants: int = 30,
    maintain_difficulty: bool = True
) -> list[dict]:
    """Генерируем N уникальных версий вопроса"""
    response = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": f"""Создай {n_variants} уникальных версий вопроса.
            Варьируй: числа, имена, контекст, порядок вариантов ответа.
            Сложность {'должна оставаться одинаковой' if maintain_difficulty else 'может варьироваться'}.
            Верни JSON массив."""
        }, {
            "role": "user",
            "content": f"Исходный вопрос: {base_question}"
        }],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)["variants"]

Сроки: генератор тестов из текстового материала — 1–2 недели. Полноценная платформа с автопроверкой, аналитикой и интеграцией в LMS (Moodle/iSpring) — 2–3 месяца.