давай сделаем рефакторинг: grade_fixed теперь будет возвращать объект данных оценки -…
- User
давай сделаем рефакторинг: grade_fixed теперь будет возвращать объект данных оценки - score, comment
import re from rapidfuzz import fuzz from labstructanalyzer.models.answer import Answer from labstructanalyzer.models.dto.answer import FullAnswerData from labstructanalyzer.models.answer_type import AnswerType class PreGraderService: """Сервис предварительной оценки ответов по эталонным ответам преподавателя""" _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'\d+') def __init__(self, answers: list[FullAnswerData]): """ Инициализирует сервис предварительной оценки Args: answers: Подготовленный список ответов для оценки """ self.answers = answers self.parameters = {answer.custom_id: answer for answer in answers} self._strategies = { AnswerType.simple.name: self._grade_fixed, AnswerType.param.name: self._grade_parametrized } def grade(self) -> list[Answer]: """ Оценивает ответы, используя соответствующие эталон из элемента шаблона. Обновляет поле `pre_grade` у каждого объекта `Answer` в списке Returns: Список объектов Answer с результатами оценки """ graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue score = strategy(answer_text, answer.reference) answer.user_origin.pre_grade = {"score": score} if score < 1: answer.user_origin.pre_grade["comment"] = f"Ответ не соответствует эталону {answer.reference}" graded_answers.append(answer.user_origin) return graded_answers def _grade_fixed(self, given_answer: str, reference_answer: str) -> int: """ Сравнивает данный ответ с эталонным для фиксированных ответов. Проверяет совпадение цифр, затем слов (точное, по префиксу или по схожести > 90%) Args: given_answer: Текст ответа пользователя reference_answer: Эталонный текст ответа Returns: Балл - 1, если ответ соответствует эталону, иначе - 0 """ reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) if given_digits != reference_digits: return 0 elif given_words == reference_words: return 1 if len(given_words) <= len(reference_words): for offset in range(len(reference_words) - len(given_words) + 1): if all(reference_words[offset + i].startswith(given_words[i]) for i in range(len(given_words))): return 1 score = fuzz.ratio(given_words, reference_words) return 1 if score >= 90 else 0 def _grade_parametrized(self, given_answer: str, reference_answer: str) -> int: pass def _split_alnum(self, answer: str) -> tuple[list[str], list[str]]: """ Разделяет строку на список слов и список цифр Args: answer: Входная строка. Returns: Кортеж (список слов, список цифр) """ answer = answer.lower() letters = self._RE_WORDS.findall(answer) digits = self._RE_DIGITS.findall(answer) return letters, digits Assistant
Вот рефакторинг метода
_grade_fixedс возвратом объекта с оценкой и комментарием:from dataclasses import dataclass @dataclass class GradeResult: score: int comment: str | None = None def _grade_fixed(self, given_answer: str, reference_answer: str) -> GradeResult: """ Сравнивает данный ответ с эталонным для фиксированных ответов. Проверяет совпадение цифр, затем слов (точное, по префиксу или по схожести > 90%) Args: given_answer: Текст ответа пользователя reference_answer: Эталонный текст ответа Returns: Объект GradeResult с баллом и опциональным комментарием """ reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) if given_digits != reference_digits: return GradeResult( score=0, comment=f"Цифры не совпадают. Эталон: {reference_digits}, Ответ: {given_digits}" ) if given_words == reference_words: return GradeResult(score=1) if len(given_words) <= len(reference_words): for offset in range(len(reference_words) - len(given_words) + 1): if all(reference_words[offset + i].startswith(given_words[i]) for i in range(len(given_words))): return GradeResult(score=1) score = fuzz.ratio(given_words, reference_words) if score >= 90: return GradeResult(score=1) return GradeResult( score=0, comment=f"Низкое совпадение слов. Схожесть: {score}%, Эталон: {reference_words}, Ответ: {given_words}" )И соответствующие изменения в методе
grade:def grade(self) -> list[Answer]: """ Оценивает ответы, используя соответствующие эталон из элемента шаблона. Обновляет поле `pre_grade` у каждого объекта `Answer` в списке Returns: Список объектов Answer с результатами оценки """ graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue grade_result = strategy(answer_text, answer.reference) answer.user_origin.pre_grade = { "score": grade_result.score, **({"comment": grade_result.comment} if grade_result.comment else {}) } graded_answers.append(answer.user_origin) return graded_answersОсновные изменения:
- Создан класс
GradeResultдля возврата оценки и комментария - Метод
_grade_fixedтеперь возвращаетGradeResult - В методе
gradeобновлена логика установкиpre_gradeс учетом нового возвращаемого типа - Добавлены более информативные комментарии в случае несоответствия
Теперь метод предоставляет более подробную информацию о причинах снижения оценки.
- Создан класс
- User
ERROR: Ошибка при сохранении предварительных оценок в базу данных error: (builtins.TypeError) Object of type GradeResult is not JSON serializable [SQL: UPDATE answers SET pre_grade=? WHERE answers.answer_id = ?] [parameters: [{'pre_grade': GradeResult(score=0, comment="Цифры не совпадают. Эталон: ['10', '12', '15', '20'], Ответ: ['10', '12', '16', '20']"), 'answers_answer_id': UUID('517df608-2b25-4765-b000-d7d52e41d477')}, {'pre_grade': GradeResult(score=1, comment=None), 'answers_answer_id': UUID('8651293d-cf90-4e41-9dd6-af5199f61f24')}]] WARNING: WatchFiles detected changes in 'labstructanalyzer/services/pre_grader.py'. Reloading...
Assistant
Вы можете решить эту проблему, преобразовав
GradeResultв словарь перед сохранением. Вот несколько вариантов:- Добавить метод
to_dict()в классGradeResult:
from dataclasses import dataclass, asdict @dataclass class GradeResult: score: int comment: str | None = None def to_dict(self): return { 'score': self.score, **({"comment": self.comment} if self.comment else {}) } def grade(self) -> list[Answer]: graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue grade_result = strategy(answer_text, answer.reference) answer.user_origin.pre_grade = grade_result.to_dict() graded_answers.append(answer.user_origin) return graded_answers- Альтернативный вариант с использованием
asdict():
from dataclasses import dataclass, asdict @dataclass class GradeResult: score: int comment: str | None = None def grade(self) -> list[Answer]: graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue grade_result = strategy(answer_text, answer.reference) pre_grade = asdict(grade_result) # Удаляем None значения pre_grade = {k: v for k, v in pre_grade.items() if v is not None} answer.user_origin.pre_grade = pre_grade graded_answers.append(answer.user_origin) return graded_answers- Если вам нужна максимальная гибкость, можно использовать пользовательский сериализатор:
from dataclasses import dataclass import json @dataclass class GradeResult: score: int comment: str | None = None def to_json(self): return json.dumps(self.to_dict()) def to_dict(self): return { 'score': self.score, **({"comment": self.comment} if self.comment else {}) }Рекомендую первый или второй варианты, так как они просты и эффективны. Второй вариант с
asdict()немного элегантнее, так как автоматически удаляетNoneзначения.Выберите тот, который лучше подходит к вашей архитектуре. Основная цель - преобразовать объект
GradeResultв сериализуемый словарь перед сохранением в базу данных.- Добавить метод
- User
стоит ли выносить проверку фиксированных ответов в другой класс? будет еще 2 проверки
import re from dataclasses import asdict from rapidfuzz import fuzz from labstructanalyzer.models.answer import Answer from labstructanalyzer.models.dto.answer import FullAnswerData, GradeResult from labstructanalyzer.models.answer_type import AnswerType class PreGraderService: """Сервис предварительной оценки ответов по эталонным ответам преподавателя""" _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'\d+') def __init__(self, answers: list[FullAnswerData]): """ Инициализирует сервис предварительной оценки Args: answers: Подготовленный список ответов для оценки """ self.answers = answers self.parameters = {answer.custom_id: answer for answer in answers} self._strategies = { AnswerType.simple.name: self._grade_fixed, } def grade(self) -> list[Answer]: """ Оценивает ответы, используя соответствующие эталон из элемента шаблона. Обновляет поле `pre_grade` у каждого объекта `Answer` в списке Returns: Список объектов Answer с результатами оценки """ graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue answer.user_origin.pre_grade = asdict(strategy(answer_text, answer.reference)) graded_answers.append(answer.user_origin) return graded_answers def _grade_fixed(self, given_answer: str, reference_answer: str) -> GradeResult: """ Сравнивает данный ответ с эталонным для фиксированных ответов. Проверяет совпадение цифр, затем слов (точное, по префиксу или по схожести > 90%) Args: given_answer: Текст ответа пользователя reference_answer: Эталонный текст ответа Returns: Балл - 1, если ответ соответствует эталону, иначе - 0 """ reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) if given_digits != reference_digits: return GradeResult( score=0, comment=f"Цифры не совпадают. Эталон: {reference_answer}, Ответ: {given_answer}" ) if given_words == reference_words: return GradeResult(score=1) if len(given_words) <= len(reference_words): for offset in range(len(reference_words) - len(given_words) + 1): if all(reference_words[offset + i].startswith(given_words[i]) for i in range(len(given_words))): return GradeResult(score=1) score = fuzz.ratio(given_words, reference_words) if score >= 90: return GradeResult(score=1) return GradeResult( score=0, comment=f"Низкое совпадение слов. Схожесть: {score}%, Эталон: {reference_answer}, Ответ: {given_answer}" ) def _split_alnum(self, answer: str) -> tuple[list[str], list[str]]: """ Разделяет строку на список слов и список цифр Args: answer: Входная строка. Returns: Кортеж (список слов, список цифр) """ answer = answer.lower() letters = self._RE_WORDS.findall(answer) digits = self._RE_DIGITS.findall(answer) return letters, digits Assistant
Да, вынесение логики проверки в отдельный класс может быть хорошим решением, особенно если планируется расширение функциональности и добавление новых стратегий оценки. Вот пример такой реализации:
from abc import ABC, abstractmethod import re from rapidfuzz import fuzz class BaseGradeStrategy(ABC): """Базовый абстрактный класс для стратегий оценки""" _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'\d+') @abstractmethod def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """Абстрактный метод оценки ответа""" pass def _split_alnum(self, answer: str) -> tuple[list[str], list[str]]: """ Разделяет строку на список слов и список цифр Args: answer: Входная строка. Returns: Кортеж (список слов, список цифр) """ answer = answer.lower() letters = self._RE_WORDS.findall(answer) digits = self._RE_DIGITS.findall(answer) return letters, digits class FixedAnswerGradeStrategy(BaseGradeStrategy): """Стратегия оценки для фиксированных ответов""" def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Сравнивает данный ответ с эталонным для фиксированных ответов. Проверяет совпадение цифр, затем слов (точное, по префиксу или по схожести > 90%) Args: given_answer: Текст ответа пользователя reference_answer: Эталонный текст ответа Returns: Результат оценки """ reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) if given_digits != reference_digits: return GradeResult( score=0, comment=f"Цифры не совпадают. Эталон: {reference_answer}, Ответ: {given_answer}" ) if given_words == reference_words: return GradeResult(score=1) if len(given_words) <= len(reference_words): for offset in range(len(reference_words) - len(given_words) + 1): if all(reference_words[offset + i].startswith(given_words[i]) for i in range(len(given_words))): return GradeResult(score=1) score = fuzz.ratio(given_words, reference_words) if score >= 90: return GradeResult(score=1) return GradeResult( score=0, comment=f"Низкое совпадение слов. Схожесть: {score}%, Эталон: {reference_answer}, Ответ: {given_answer}" ) class PreGraderService: """Сервис предварительной оценки ответов по эталонным ответам преподавателя""" def __init__(self, answers: list[FullAnswerData]): """ Инициализирует сервис предварительной оценки Args: answers: Подготовленный список ответов для оценки """ self.answers = answers self.parameters = {answer.custom_id: answer for answer in answers} self._strategies = { AnswerType.simple.name: FixedAnswerGradeStrategy(), # Здесь можно будет добавить другие стратегии } def grade(self) -> list[Answer]: """ Оценивает ответы, используя соответствующие эталон из элемента шаблона. Обновляет поле `pre_grade` у каждого объекта `Answer` в списке Returns: Список объектов Answer с результатами оценки """ graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue answer.user_origin.pre_grade = asdict(strategy.grade(answer_text, answer.reference)) graded_answers.append(answer.user_origin) return graded_answersПреимущества такого подхода:
- Четкое разделение ответственности
- Легкость добавления новых стратегий оценки
- Возможность независимого тестирования каждой стратегии
- Гибкость при расширении функциональности
- Использование полиморфизма и абстракции
Теперь вы можете легко добавлять новые стратегии оценки, просто создавая новые классы, наследованные от
BaseGradeStrategy, и добавляя их в словарь_strategiesвPreGraderService.Например, можно будет легко добавить стратегию для параметризованных ответов или других типов:
class ParametrizedAnswerGradeStrategy(BaseGradeStrategy): def grade(self, given_answer: str, reference_answer: str) -> GradeResult: # Своя логика оценки pass # В инициализации PreGraderService self._strategies = { AnswerType.simple.name: FixedAnswerGradeStrategy(), AnswerType.param.name: ParametrizedAnswerGradeStrategy(), }- User
давай
Assistant
Вот пример реализации стратегии для параметризованных ответов:
class ParametrizedAnswerGradeStrategy(BaseGradeStrategy): """Стратегия оценки для параметризованных ответов""" def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Оценивает параметризованный ответ Args: given_answer: Текст ответа пользователя reference_answer: Эталонный текст ответа Returns: Результат оценки """ # Разбиваем эталонный и данный ответы на слова и цифры reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) # Проверяем совпадение цифр if not self._check_digits_match(reference_digits, given_digits): return GradeResult( score=0, comment=f"Числовые параметры не совпадают. Эталон: {reference_digits}, Ответ: {given_digits}" ) # Проверяем структуру слов word_match_result = self._check_word_structure(reference_words, given_words) if not word_match_result: return GradeResult( score=0, comment=f"Структура ответа не соответствует эталону. Эталон: {reference_words}, Ответ: {given_words}" ) return GradeResult(score=1) def _check_digits_match(self, reference_digits: list[str], given_digits: list[str]) -> bool: """ Проверяет соответствие цифровых параметров Args: reference_digits: Цифры эталонного ответа given_digits: Цифры ответа пользователя Returns: True, если цифры совпадают, иначе False """ # Можно реализовать более сложную логику сравнения # Например, проверка на равенство или допустимое отклонение return len(reference_digits) == len(given_digits) and all( abs(float(ref) - float(given)) / float(ref) < 0.1 # Допускаем отклонение до 10% for ref, given in zip(reference_digits, given_digits) ) def _check_word_structure(self, reference_words: list[str], given_words: list[str]) -> bool: """ Проверяет структуру слов в ответе Args: reference_words: Слова эталонного ответа given_words: Слова ответа пользователя Returns: True, если структура совпадает, иначе False """ # Проверяем базовую структуру: количество и начальные буквы слов if len(reference_words) != len(given_words): return False # Проверяем начальные буквы слов return all( given.startswith(ref[:3]) # Сравниваем первые 3 буквы for ref, given in zip(reference_words, given_words) )Обновим
PreGraderService:class PreGraderService: def __init__(self, answers: list[FullAnswerData]): self.answers = answers self.parameters = {answer.custom_id: answer for answer in answers} self._strategies = { AnswerType.simple.name: FixedAnswerGradeStrategy(), AnswerType.param.name: ParametrizedAnswerGradeStrategy(), } # Остальной код без измененийОсобенности реализации:
-
_check_digits_match()позволяет более гибко сравнивать числовые параметры:- Проверяет количество цифр
- Допускает отклонение до 10% (можно настроить)
-
_check_word_structure()проверяет:- Количество слов
- Начало каждого слова (первые 3 буквы)
-
Стратегия возвращает подробные комментарии о причинах снижения оценки
Примеры:
# Успешные кейсы grade("Длина 10 см, ширина 5 см", "Длина 9 см, ширина 5 см") # score=1 grade("Расчет силы трения 20 Н", "Расчет силы трения 22 Н") # score=1 # Неуспешные кейсы grade("Длина 10 см", "Ширина 10 см") # score=0, comment о структуре grade("Длина 100 см", "Длина 200 см") # score=0, comment о цифрахПлюсы подхода:
- Гибкость настройки
- Расширяемость
- Информативность оценки
- Возможность тонкой настройки под разные типы ответов
Можете дополнительно настроить методы под специфику ваших задач.
-
- User
я упустил, но для инициализации каждого класса надо передать некоторые специфичные параметры, для кого-то надо, для кого-то нет
Assistant
Отличное замечание! Вот обновленная архитектура с учетом этого требования:
from abc import ABC, abstractmethod from dataclasses import dataclass from typing import Any, Optional class BaseGradeStrategy(ABC): """Базовый абстрактный класс для стратегий оценки""" def __init__(self, config: Optional[dict[str, Any]] = None): """ Инициализация стратегии с опциональной конфигурацией Args: config: Словарь с параметрами конфигурации """ self.config = config or {} @abstractmethod def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """Абстрактный метод оценки ответа""" pass class FixedAnswerGradeStrategy(BaseGradeStrategy): """Стратегия оценки для фиксированных ответов""" def __init__(self, config: Optional[dict[str, Any]] = None): """ Инициализация стратегии для фиксированных ответов Args: config: Словарь с параметрами: - similarity_threshold (float): порог схожести, по умолчанию 90 """ super().__init__(config) self.similarity_threshold = self.config.get('similarity_threshold', 90) def grade(self, given_answer: str, reference_answer: str) -> GradeResult: # Логика осталась прежней, но использует self.similarity_threshold # ... (предыдущая реализация с заменой 90 на self.similarity_threshold) score = fuzz.ratio(given_words, reference_words) if score >= self.similarity_threshold: return GradeResult(score=1) # ... остальной код class ParametrizedAnswerGradeStrategy(BaseGradeStrategy): """Стратегия оценки для параметризованных ответов""" def __init__(self, config: Optional[dict[str, Any]] = None): """ Инициализация стратегии для параметризованных ответов Args: config: Словарь с параметрами: - digit_tolerance (float): допустимое отклонение для цифр, по умолчанию 0.1 - word_match_length (int): длина сравнения слов, по умолчанию 3 """ super().__init__(config) self.digit_tolerance = self.config.get('digit_tolerance', 0.1) self.word_match_length = self.config.get('word_match_length', 3) def _check_digits_match(self, reference_digits: list[str], given_digits: list[str]) -> bool: return len(reference_digits) == len(given_digits) and all( abs(float(ref) - float(given)) / float(ref) < self.digit_tolerance for ref, given in zip(reference_digits, given_digits) ) def _check_word_structure(self, reference_words: list[str], given_words: list[str]) -> bool: if len(reference_words) != len(given_words): return False return all( given.startswith(ref[:self.word_match_length]) for ref, given in zip(reference_words, given_words) ) # Остальная логика grade() без изменений class PreGraderService: def __init__( self, answers: list[FullAnswerData], strategies_config: Optional[dict[str, dict[str, Any]]] = None ): """ Инициализация сервиса с возможностью конфигурации стратегий Args: answers: Список ответов strategies_config: Конфигурация для каждой стратегии """ self.answers = answers self.parameters = {answer.custom_id: answer for answer in answers} # Конфигурация по умолчанию default_config = { AnswerType.simple.name: {}, AnswerType.param.name: {} } # Обновляем конфигурацию, если передана if strategies_config: default_config.update(strategies_config) self._strategies = { AnswerType.simple.name: FixedAnswerGradeStrategy(default_config[AnswerType.simple.name]), AnswerType.param.name: ParametrizedAnswerGradeStrategy(default_config[AnswerType.param.name]), } # Остальной код без измененийПример использования:
# Использование с настройками по умолчанию pregrader = PreGraderService(answers) # Использование с пользовательской конфигурацией custom_config = { AnswerType.simple.name: { 'similarity_threshold': 85 # Изменили порог схожести }, AnswerType.param.name: { 'digit_tolerance': 0.05, # Уменьшили допустимое отклонение 'word_match_length': 2 # Уменьшили длину сравнения слов } } pregrader = PreGraderService(answers, custom_config)Преимущества:
- Гибкая настройка каждой стратегии
- Значения по умолчанию
- Возможность расширения без изменения базовой логики
- Простота добавления новых стратегий
- Возможность тонкой настройки под разные типы задач
Теперь каждая стратегия может иметь свою уникальную конфигурацию, которая передается при инициализации.
- User
я пока остановился на такой версии, давай далее поработаем с другим грейдером
import re from rapidfuzz import fuzz from labstructanalyzer.models.dto.answer import GradeResult from labstructanalyzer.services.graders.abstract_base import BaseGrader class FixedAnswerGrader(BaseGrader): _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'\d+') def grade(self, given_answer: str, reference_answer: str) -> GradeResult: reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) if given_digits != reference_digits: return GradeResult( score=0, comment=f"Цифры не совпадают. Эталон: {reference_answer}, Ответ: {given_answer}" ) if given_words == reference_words: return GradeResult(score=1) if len(given_words) <= len(reference_words): for offset in range(len(reference_words) - len(given_words) + 1): if all(reference_words[offset + i].startswith(given_words[i]) for i in range(len(given_words))): return GradeResult(score=1) score = fuzz.ratio(given_words, reference_words) if score >= 90: return GradeResult(score=1) return GradeResult( score=0, comment=f"Низкое совпадение слов. Схожесть: {score}%, Эталон: {reference_answer}, Ответ: {given_answer}" ) def _split_alnum(self, answer: str) -> tuple[list[str], list[str]]: answer = answer.lower() letters = self._RE_WORDS.findall(answer) digits = self._RE_DIGITS.findall(answer) return letters, digits Assistant
Давайте разработаем следующий грейдер. Какой тип ответов вы хотели бы реализовать? Например:
- Параметризованный грейдер (с допустимым отклонением)
- Грейдер для математических выражений
- Грейдер для химических формул
- Грейдер для физических величин
- Грейдер для последовательностей
Какой из этих вариантов вам был бы интересен?
Я предлагаю начать с параметризованного грейдера, который будет более сложным, чем фиксированный, и позволит:
- Сравнивать числовые значения с допустимым отклонением
- Проверять структуру ответа
- Давать более детальную оценку
Вот примерный вариант:
import re from typing import List, Union from rapidfuzz import fuzz from labstructanalyzer.models.dto.answer import GradeResult from labstructanalyzer.services.graders.abstract_base import BaseGrader class ParametrizedAnswerGrader(BaseGrader): _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'-?\d+(?:\.\d+)?') def __init__( self, digit_tolerance: float = 0.1, # 10% допустимого отклонения word_match_threshold: int = 3 # Сколько букв сравнивать в словах ): self.digit_tolerance = digit_tolerance self.word_match_threshold = word_match_threshold def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Оценивает параметризованный ответ с учетом числовых и текстовых параметров """ reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) # Проверка количества цифр if len(reference_digits) != len(given_digits): return GradeResult( score=0, comment=f"Количество числовых параметров не совпадает. " f"Эталон: {reference_digits}, Ответ: {given_digits}" ) # Проверка числовых значений if not self._check_digits_match(reference_digits, given_digits): return GradeResult( score=0, comment=f"Числовые параметры не соответствуют эталону. " f"Эталон: {reference_digits}, Ответ: {given_digits}" ) # Проверка слов word_match_score = self._check_word_match(reference_words, given_words) if word_match_score < 1: return GradeResult( score=word_match_score, comment=f"Неполное совпадение структуры ответа. " f"Эталон: {reference_words}, Ответ: {given_words}" ) return GradeResult(score=1) def _check_digits_match( self, reference_digits: List[str], given_digits: List[str] ) -> bool: """ Проверяет соответствие числовых параметров с допустимым отклонением """ try: return all( abs(float(ref) - float(given)) / float(ref) <= self.digit_tolerance for ref, given in zip(reference_digits, given_digits) ) except (ValueError, ZeroDivisionError): return False def _check_word_match( self, reference_words: List[str], given_words: List[str] ) -> float: """ Проверяет совпадение слов с учетом структуры Возвращает коэффициент совпадения от 0 до 1 """ if len(reference_words) != len(given_words): return 0 matches = sum( given.startswith(ref[:self.word_match_threshold]) for ref, given in zip(reference_words, given_words) ) return matches / len(reference_words) def _split_alnum(self, answer: str) -> tuple[list[str], list[str]]: """ Разделяет строку на слова и цифры """ answer = answer.lower() letters = self._RE_WORDS.findall(answer) digits = self._RE_DIGITS.findall(answer) return letters, digitsОсобенности реализации:
- Настраиваемая толерантность к числовым значениям
- Проверка структуры слов
- Детальные комментарии о причинах снижения оценки
- Гибкость настройки через параметры инициализации
Примеры использования:
grader = ParametrizedAnswerGrader( digit_tolerance=0.2, # Допускаем отклонение до 20% word_match_threshold=2 # Сравниваем первые 2 буквы слов ) # Успешные кейсы result1 = grader.grade( "Длина 10 см, ширина 5 см", "Длина 9 см, ширина 4.5 см" ) # score=1 # Частично успешные result2 = grader.grade( "Расчет силы трения", "Вычисление силы тр" ) # score < 1, но не 0 # Неуспешные кейсы result3 = grader.grade( "Длина 100 см", "Ширина 200 см" ) # score=0Что скажете? Устраивает ли вас такой подход?
- User
доработай код, рефакторинг там, все дела
import re from typing import Dict from labstructanalyzer.models.dto.answer import FullAnswerData, GradeResult class ParametrizedAnswerGrader: """ Класс для оценки одного параметризованного ответа пользователя на основе эталона с параметрами и диапазонами. """ _RE_PARAM_PLACEHOLDER = re.compile(r'\{([^}]+)}') _RE_RANGE_PLACEHOLDER = re.compile(r'\[(.*?)]') _RE_SINGLE_SPACE = re.compile(r'\s+') def __init__(self, parameters: Dict[str, FullAnswerData]): """ Инициализирует оценщик параметризованного ответа. Args: parameters: Словарь параметров, на которые может ссылаться эталон """ self._parameters = parameters def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Выполняет оценку параметризованного ответа. Returns: Данные оценки """ normalized_given = self._normalize_text(given_answer) print(f"DEBUG(ParamGrader): Normalized Given: '{normalized_given}'") normalized_substituted_reference, all_params_valid = self._substitute_parameters(reference_answer) if not all_params_valid or normalized_substituted_reference is None: print("DEBUG(ParamGrader): Parameter substitution failed (invalid parameter). Returning 0.") return 0 # Если хоть один параметр невалиден, весь ответ неверен theses = [line.strip() for line in normalized_substituted_reference.splitlines() if line.strip()] if not theses: print( "DEBUG(ParamGrader): No theses found after substitution/normalization. Returning 1.") # Отладочный вывод return GradeResult(score=1) # print(f"DEBUG(ParamGrader): Theses to check: {theses}") # Отладочный вывод for thesis in theses: range_match = self._RE_RANGE_PLACEHOLDER.search(thesis) thesis_found = False if range_match: # Тезис с динамическим диапазоном [range_content] range_content = range_match.group(1) part_before = thesis[:range_match.start()] part_after = thesis[range_match.end():] # Determine the dynamic regex part based on range_content format # NOTE: This logic is duplicated in _validate_range to *parse* range_content. # Here we are using it to *build* the regex to capture a value that *could* match. # We should ensure these are consistent. dynamic_regex_part = None num_range_match_check = re.fullmatch(r'\d+-\d+', range_content) char_range_match_check = re.fullmatch(r'([a-z])-([a-z])', range_content) char_set_match_check = re.fullmatch(r'([a-z]+)', range_content) if num_range_match_check: dynamic_regex_part = r"(\d+)" elif char_range_match_check: dynamic_regex_part = r"([a-z])" # Capture *any* single char, validation happens later elif char_set_match_check: dynamic_regex_part = r"([a-z])" # Capture *any* single char, validation happens later else: print( f"DEBUG(ParamGrader): Skipping thesis with unknown range format: '{thesis}'") # Отладочный вывод continue if dynamic_regex_part: try: line_regex = re.compile(re.escape(part_before) + dynamic_regex_part + re.escape(part_after)) except re.error as e: print(f"DEBUG(ParamGrader): Regex compilation error for thesis '{thesis}': {e}") continue matches_in_given = line_regex.findall(normalized_given) print( f"DEBUG(ParamGrader): Thesis with range '{thesis}'. Regex: '{line_regex.pattern}'. Found matches: {matches_in_given}") for matched_value in matches_in_given: if self._validate_range(matched_value, range_content): thesis_found = True print( f"DEBUG(ParamGrader): Thesis '{thesis}' found with valid value '{matched_value}'.") # Отладочный вывод break else: if thesis in normalized_given: thesis_found = True print(f"DEBUG(ParamGrader): Static thesis '{thesis}' found.") else: print(f"DEBUG(ParamGrader): Static thesis '{thesis}' NOT found.") if not thesis_found: print(f"DEBUG(ParamGrader): Thesis '{thesis}' not found. Returning 0.") # Отладочный вывод return 0 print(f"DEBUG(ParamGrader): All theses matched. Returning 1.") return 1 def _normalize_text(self, text: str) -> str: """ Применяет минимальную нормализацию: - приведение к нижнему регистру - замена последовательностей пробельных символов на один пробел - удаление пробелов в начале и конце строки """ text = text.lower() text = self._RE_SINGLE_SPACE.sub(' ', text).strip() return text def _substitute_parameters(self, reference_answer) -> tuple[str | None, bool]: """ Подставляет значения параметров пользователя в эталонный ответ. Выполняет нормализацию подставленного эталона. Returns: Кортеж: (Нормализованная строка с подставленными параметрами или None, Булево значение: True, если все параметры valid, False иначе). Возвращает None, False, если какой-либо параметр невалиден или отсутствует. """ processed_ref = reference_answer print(f"DEBUG(ParamGrader): Substituting in reference: '{processed_ref}'") param_names_in_ref = self._RE_PARAM_PLACEHOLDER.findall(reference_answer) for param_name in param_names_in_ref: param_data: FullAnswerData | None = self._parameters.get(param_name) is_param_valid = ( param_data is not None and param_data.user_origin.pre_grade is not None and param_data.user_origin.pre_grade.get("score", 0) == 1 ) if not is_param_valid: print(f"DEBUG(ParamGrader): Parameter '{param_name}' is missing or invalid. Substitution failed.") return None, False param_user_text = param_data.user_origin.data.get("text", "") normalized_param_user_text = self._normalize_text(param_user_text) processed_ref = processed_ref.replace(f"{{{param_name}}}", normalized_param_user_text) print( f"DEBUG(ParamGrader): Substituted '{param_name}' with '{normalized_param_user_text}'. Result: '{processed_ref}'") # Отладочный вывод normalized_substituted_reference = self._normalize_text(processed_ref) print( f"DEBUG(ParamGrader): Final normalized substituted reference: '{normalized_substituted_reference}'") # Отладочный вывод return normalized_substituted_reference, True def _validate_range(self, value: str, range_content: str) -> bool: """ Проверяет, соответствует ли значение пользователя формату и содержимому диапазона [range_content]. Поддерживаемые форматы содержимого (range_content): - 'option1|option2|...' : Набор строк для точного совпадения (например, [да|нет], [up|down|administratively down]). - '1-23' : Числовой диапазон (включительно). - 'a-e' : Символьный диапазон (один символ, включительно, регистронезависимо в эталоне). - 'aeiou' : Набор допустимых одиночных символов. """ normalized_value = self._normalize_text(value) if not normalized_value: return False if '|' in range_content: options = range_content.split('|') normalized_options = {self._normalize_text(opt) for opt in options} print(f"DEBUG: Alternatives Check. Value: '{normalized_value}', Options: {normalized_options}") # Отладка return normalized_value in normalized_options num_range_match = re.fullmatch(r'(\d+)-(\d+)', range_content) if num_range_match: try: if not re.fullmatch(r'\d+', normalized_value): return False user_val = int(normalized_value) min_val = int(num_range_match.group(1)) max_val = int(num_range_match.group(2)) if min_val > max_val: min_val, max_val = max_val, min_val print(f"DEBUG: Numeric Range Check. Value: {user_val}, Range: [{min_val}-{max_val}]") # Отладка return min_val <= user_val <= max_val except ValueError: print( f"DEBUG: ValueError in Numeric Range. Value: '{normalized_value}', Content: '{range_content}'") # Отладка return False char_range_match = re.fullmatch(r'([a-z])-([a-z])', range_content) if char_range_match: if len(normalized_value) != 1: return False min_char = char_range_match.group(1) max_char = char_range_match.group(2) if min_char > max_char: min_char, max_char = max_char, min_char print(f"DEBUG: Char Range Check. Value: '{normalized_value}', Range: [{min_char}-{max_char}]") # Отладка return min_char <= normalized_value <= max_char char_set_match = re.fullmatch(r'[a-z]+', range_content) if char_set_match: if len(normalized_value) != 1: return False allowed_chars = set(range_content) print(f"DEBUG: Char Set Check. Value: '{normalized_value}', Allowed: {allowed_chars}") # Отладка return normalized_value in allowed_chars print(f"DEBUG: Unknown range format: [{range_content}]") # Отладка return False Assistant
Вот рефакторинг кода с улучшениями:
import re from typing import Dict, Optional, Tuple from dataclasses import dataclass from labstructanalyzer.models.dto.answer import FullAnswerData, GradeResult @dataclass class RangeValidationResult: """Результат валидации диапазона""" is_valid: bool matched_value: Optional[str] = None class ParametrizedAnswerGrader: """ Класс для оценки одного параметризованного ответа пользователя на основе эталона с параметрами и диапазонами. """ _RE_PARAM_PLACEHOLDER = re.compile(r'\{([^}]+)}') _RE_RANGE_PLACEHOLDER = re.compile(r'\[(.*?)]') _RE_SINGLE_SPACE = re.compile(r'\s+') def __init__(self, parameters: Dict[str, FullAnswerData]): """ Инициализирует оценщик параметризованного ответа. Args: parameters: Словарь параметров, на которые может ссылаться эталон """ self._parameters = parameters self._logger = self._setup_logger() def _setup_logger(self): """ Настройка логирования с возможностью легкого отключения """ import logging logger = logging.getLogger(self.__class__.__name__) logger.setLevel(logging.DEBUG) return logger def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Выполняет оценку параметризованного ответа. Returns: Данные оценки """ try: normalized_given = self._normalize_text(given_answer) self._logger.debug(f"Normalized Given: '{normalized_given}'") normalized_substituted_reference, all_params_valid = self._substitute_parameters(reference_answer) if not all_params_valid or normalized_substituted_reference is None: self._logger.debug("Parameter substitution failed (invalid parameter)") return GradeResult(score=0) theses = [line.strip() for line in normalized_substituted_reference.splitlines() if line.strip()] if not theses: self._logger.debug("No theses found after substitution/normalization") return GradeResult(score=1) for thesis in theses: if not self._check_thesis(thesis, normalized_given): return GradeResult(score=0) return GradeResult(score=1) except Exception as e: self._logger.error(f"Unexpected error in grade method: {e}") return GradeResult(score=0) def _check_thesis(self, thesis: str, normalized_given: str) -> bool: """ Проверка отдельного тезиса в ответе """ range_match = self._RE_RANGE_PLACEHOLDER.search(thesis) if range_match: return self._check_range_thesis(thesis, range_match, normalized_given) return self._check_static_thesis(thesis, normalized_given) def _check_range_thesis(self, thesis: str, range_match, normalized_given: str) -> bool: """ Проверка тезиса с динамическим диапазоном """ range_content = range_match.group(1) part_before = thesis[:range_match.start()] part_after = thesis[range_match.end():] dynamic_regex_part = self._get_dynamic_regex_part(range_content) if not dynamic_regex_part: self._logger.debug(f"Skipping thesis with unknown range format: '{thesis}'") return False try: line_regex = re.compile(re.escape(part_before) + dynamic_regex_part + re.escape(part_after)) matches_in_given = line_regex.findall(normalized_given) self._logger.debug(f"Thesis with range '{thesis}'. Regex: '{line_regex.pattern}'. Found matches: {matches_in_given}") for matched_value in matches_in_given: validation_result = self._validate_range(matched_value, range_content) if validation_result.is_valid: self._logger.debug(f"Thesis '{thesis}' found with valid value '{matched_value}'") return True except re.error as e: self._logger.debug(f"Regex compilation error for thesis '{thesis}': {e}") return False def _get_dynamic_regex_part(self, range_content: str) -> Optional[str]: """ Определение динамической части regex для диапазона """ if re.fullmatch(r'\d+-\d+', range_content): return r"(\d+)" if re.fullmatch(r'([a-z])-([a-z])', range_content): return r"([a-z])" if re.fullmatch(r'([a-z]+)', range_content): return r"([a-z])" return None def _check_static_thesis(self, thesis: str, normalized_given: str) -> bool: """ Проверка статического тезиса """ is_found = thesis in normalized_given self._logger.debug(f"Static thesis '{thesis}' {'found' if is_found else 'NOT found'}.") return is_found def _normalize_text(self, text: str) -> str: """ Применяет минимальную нормализацию текста """ text = text.lower() text = self._RE_SINGLE_SPACE.sub(' ', text).strip() return text def _substitute_parameters(self, reference_answer: str) -> Tuple[Optional[str], bool]: """ Подставляет значения параметров пользователя в эталонный ответ """ processed_ref = reference_answer self._logger.debug(f"Substituting in reference: '{processed_ref}'") param_names_in_ref = self._RE_PARAM_PLACEHOLDER.findall(reference_answer) for param_name in param_names_in_ref: param_data: Optional[FullAnswerData] = self._parameters.get(param_name) is_param_valid = ( param_data is not None and param_data.user_origin.pre_grade is not None and param_data.user_origin.pre_grade.get("score", 0) == 1 ) if not is_param_valid: self._logger.debug(f"Parameter '{param_name}' is missing or invalid") return None, False param_user_text = param_data.user_origin.data.get("text", "") normalized_param_user_text = self._normalize_text(param_user_text) processed_ref = processed_ref.replace(f"{{{param_name}}}", normalized_param_user_text) self._logger.debug(f"Substituted '{param_name}' with '{normalized_param_user_text}'. Result: '{processed_ref}'") normalized_substituted_reference = self._normalize_text(processed_ref) self._logger.debug(f"Final normalized substituted reference: '{normalized_substituted_reference}'") return normalized_substituted_reference, True def _validate_range(self, value: str, range_content: str) -> RangeValidationResult: """ Проверяет, соответствует ли значение пользователя формату и содержимому диапазона """ normalized_value = self._normalize_text(value) if not normalized_value: return RangeValidationResult(is_valid=False) # Проверка списка опций if '|' in range_content: options = {self._normalize_text(opt) for opt in range_content.split('|')} is_valid = normalized_value in options self._logger.debug(f"Alternatives Check. Value: '{normalized_value}', Options: {options}") return RangeValidationResult(is_valid=is_valid, matched_value=normalized_value) # Проверка числового диапазона num_range_match = re.fullmatch(r'(\d+)-(\d+)', range_content) if num_range_match: try: if not re.fullmatch(r'\d+', normalized_value): return RangeValidationResult(is_valid=False) user_val = int(normalized_value) min_val = int(num_range_match.group(1)) max_val = int(num_range_match.group(2)) if min_val > max_val: min_val, max_val = max_val, min_val is_valid = min_val <= user_val <= max_val self._logger.debug(f"Numeric Range Check. Value: {user_val}, Range: [{min_val}-{max_val}]") return RangeValidationResult(is_valid=is_valid, matched_value=normalized_value) except ValueError: self._logger.debug(f"ValueError in Numeric Range. Value: '{normalized_value}', Content: '{range_content}'") return RangeValidationResult(is_valid=False) # Проверка символьного диапазона char_range_match = re.fullmatch(r'([a-z])-([a-z])', range_content) if char_range_match: if len(normalized_value) != 1: return RangeValidationResult(is_valid=False) min_char = char_range_match.group(1) max_char = char_range_match.group(2) if min_char > max_char: min_char, max_char = max_char, min_char is_valid = min_char <= normalized_value <= max_char self._logger.debug(f"Char Range Check. Value: '{normalized_value}', Range: [{min_char}-{max_char}]") return RangeValidationResult(is_valid=is_valid, matched_value=normalized_value) # Проверка набора символов char_set_match = re.fullmatch(r'[a-z]+', range_content) if char_set_match: if len(normalized_value) != 1: return RangeValidationResult(is_valid=False) allowed_chars = set(range_content) is_valid = normalized_value in allowed_chars self._logger.debug(f"Char Set Check. Value: '{normalized_value}', Allowed: {allowed_chars}") return RangeValidationResult(is_valid=is_valid, matched_value=normalized_value) self._logger.debug(f"Unknown range format: [{range_content}]") return RangeValidationResult(is_valid=False)Основные улучшения:
- Добавлен класс
RangeValidationResultдля более информативного возврата результата валидации - Разделение логики на smaller методы для улучшения читаемости
- Использование встроенного логирования вместо print
- Обработка исключений в методе
grade() - Более чистая структура кода с явным разделением ответственности
- Возможность легко отключить логирование
- Улучшенная обработка краевых случаев
Рекомендации по использованию:
- Настройте уровень логирования в зависимости от окружения
- При необходимости можно легко заменить логгер или отключить его
Хотите, чтобы я что-то доработал или объяснил подробнее?
- Добавлен класс
- User
момент: мне в comment надо четко писать, какие параметры неверны и какие тезисы не найдены
Assistant
Отличное замечание. Вот модифицированная версия с более информативными комментариями:
def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Выполняет оценку параметризованного ответа. Returns: Данные оценки с подробным комментарием """ try: normalized_given = self._normalize_text(given_answer) self._logger.debug(f"Normalized Given: '{normalized_given}'") # Отслеживаем невалидные параметры invalid_parameters = [] # Подстановка параметров с отслеживанием невалидных normalized_substituted_reference, all_params_valid = self._substitute_parameters( reference_answer, invalid_parameters ) if not all_params_valid or normalized_substituted_reference is None: return GradeResult( score=0, comment=f"Невалидные параметры: {', '.join(invalid_parameters)}" ) theses = [line.strip() for line in normalized_substituted_reference.splitlines() if line.strip()] if not theses: self._logger.debug("No theses found after substitution/normalization") return GradeResult(score=1) # Отслеживаем ненайденные тезисы not_found_theses = [] for thesis in theses: if not self._check_thesis(thesis, normalized_given): not_found_theses.append(thesis) if not_found_theses: return GradeResult( score=0, comment=f"Не найдены тезисы: {'; '.join(not_found_theses)}" ) return GradeResult(score=1) except Exception as e: self._logger.error(f"Unexpected error in grade method: {e}") return GradeResult(score=0, comment=f"Ошибка при оценке: {str(e)}") def _substitute_parameters( self, reference_answer: str, invalid_parameters: list[str] ) -> Tuple[Optional[str], bool]: """ Подставляет значения параметров пользователя в эталонный ответ с отслеживанием невалидных параметров """ processed_ref = reference_answer self._logger.debug(f"Substituting in reference: '{processed_ref}'") param_names_in_ref = self._RE_PARAM_PLACEHOLDER.findall(reference_answer) all_params_valid = True for param_name in param_names_in_ref: param_data: Optional[FullAnswerData] = self._parameters.get(param_name) is_param_valid = ( param_data is not None and param_data.user_origin.pre_grade is not None and param_data.user_origin.pre_grade.get("score", 0) == 1 ) if not is_param_valid: self._logger.debug(f"Parameter '{param_name}' is missing or invalid") invalid_parameters.append(param_name) all_params_valid = False continue param_user_text = param_data.user_origin.data.get("text", "") normalized_param_user_text = self._normalize_text(param_user_text) processed_ref = processed_ref.replace(f"{{{param_name}}}", normalized_param_user_text) self._logger.debug(f"Substituted '{param_name}' with '{normalized_param_user_text}'. Result: '{processed_ref}'") normalized_substituted_reference = self._normalize_text(processed_ref) self._logger.debug(f"Final normalized substituted reference: '{normalized_substituted_reference}'") return normalized_substituted_reference, all_params_validТеперь метод
grade()возвращает более информативные комментарии:- Если параметры невалидны:
GradeResult( score=0, comment="Невалидные параметры: param1, param2" )- Если не найдены тезисы:
GradeResult( score=0, comment="Не найдены тезисы: тезис о длине; тезис о ширине" )Основные изменения:
- Добавлен список
invalid_parametersдля отслеживания невалидных параметров - Добавлен список
not_found_thesesдля отслеживания ненайденных тезисов - Метод
_substitute_parameters()модифицирован для работы со списком невалидных параметров - Комментарии теперь содержат конкретные имена параметров и тезисов
Примеры использования:
# Если параметр param1 невалиден result = grader.grade(given_answer, "{param1} длина 10 см") # result.comment == "Невалидные параметры: param1" # Если не найден тезис о длине result = grader.grade(given_answer, "длина 10 см, ширина 5 см") # result.comment == "Не найдены тезисы: длина 10 см"Такой подход обеспечивает максимальную информативность при оценке ответа.
- User
давай вернемся к классическим print, все эти сложности с debug мне не нужны. перечисление тезисов с новой строки, каждый тезис на новой строке.
и да, хочу как-то доработать, еще лучше - упростить механизм "диапазонов" []
Assistant
Вот упрощенная версия с классическими print и более простым механизмом диапазонов:
import re from typing import List, Union class ParametrizedAnswerGrader: _RE_PARAM_PLACEHOLDER = re.compile(r'\{([^}]+)}') _RE_RANGE_PLACEHOLDER = re.compile(r'\[(.*?)]') _RE_SINGLE_SPACE = re.compile(r'\s+') def __init__(self, parameters): self._parameters = parameters def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Выполняет оценку параметризованного ответа. """ normalized_given = self._normalize_text(given_answer) print(f"Normalized Given: '{normalized_given}'") # Отслеживаем невалидные параметры invalid_parameters = [] normalized_substituted_reference, all_params_valid = self._substitute_parameters( reference_answer, invalid_parameters ) if not all_params_valid or normalized_substituted_reference is None: return GradeResult( score=0, comment=f"Невалидные параметры: {', '.join(invalid_parameters)}" ) theses = [line.strip() for line in normalized_substituted_reference.splitlines() if line.strip()] if not theses: print("No theses found after substitution/normalization") return GradeResult(score=1) not_found_theses = [] for thesis in theses: if not self._check_thesis(thesis, normalized_given): not_found_theses.append(thesis) if not_found_theses: return GradeResult( score=0, comment="Не найдены тезисы:\n" + "\n".join(not_found_theses) ) return GradeResult(score=1) def _check_thesis(self, thesis: str, normalized_given: str) -> bool: """ Проверка отдельного тезиса в ответе """ range_match = self._RE_RANGE_PLACEHOLDER.search(thesis) if range_match: return self._check_range_thesis(thesis, range_match, normalized_given) return self._check_static_thesis(thesis, normalized_given) def _check_range_thesis(self, thesis: str, range_match, normalized_given: str) -> bool: """ Упрощенная проверка тезиса с диапазоном """ range_content = range_match.group(1) part_before = thesis[:range_match.start()] part_after = thesis[range_match.end():] # Варианты диапазонов: # [1-10] - числовой диапазон # [a-z] - символьный диапазон # [yes|no] - список значений # [>5] - больше значения # [<10] - меньше значения try: line_regex = re.compile(re.escape(part_before) + r"(.+?)" + re.escape(part_after)) matches_in_given = line_regex.findall(normalized_given) print(f"Thesis with range '{thesis}'. Regex: '{line_regex.pattern}'. Found matches: {matches_in_given}") for matched_value in matches_in_given: if self._validate_range(matched_value.strip(), range_content): print(f"Thesis '{thesis}' found with valid value '{matched_value}'") return True except re.error as e: print(f"Regex compilation error for thesis '{thesis}': {e}") return False def _validate_range(self, value: str, range_content: str) -> bool: """ Упрощенная валидация диапазона """ # Точное совпадение со списком if '|' in range_content: return value in range_content.split('|') # Числовой диапазон if '-' in range_content: try: min_val, max_val = map(float, range_content.split('-')) val = float(value) return min_val <= val <= max_val except ValueError: return False # Символьный диапазон if re.match(r'^[a-z]-[a-z]$', range_content): min_char, max_char = range_content.split('-') return min_char <= value <= max_char # Операторы сравнения if range_content.startswith('>'): try: return float(value) > float(range_content[1:]) except ValueError: return False if range_content.startswith('<'): try: return float(value) < float(range_content[1:]) except ValueError: return False return False def _normalize_text(self, text: str) -> str: """ Применяет минимальную нормализацию текста """ text = text.lower() text = self._RE_SINGLE_SPACE.sub(' ', text).strip() return text def _substitute_parameters( self, reference_answer: str, invalid_parameters: list[str] ) -> Tuple[Optional[str], bool]: """ Подстановка параметров с отслеживанием невалидных """ processed_ref = reference_answer print(f"Substituting in reference: '{processed_ref}'") param_names_in_ref = self._RE_PARAM_PLACEHOLDER.findall(reference_answer) all_params_valid = True for param_name in param_names_in_ref: param_data = self._parameters.get(param_name) is_param_valid = ( param_data is not None and param_data.user_origin.pre_grade is not None and param_data.user_origin.pre_grade.get("score", 0) == 1 ) if not is_param_valid: print(f"Parameter '{param_name}' is missing or invalid") invalid_parameters.append(param_name) all_params_valid = False continue param_user_text = param_data.user_origin.data.get("text", "") normalized_param_user_text = self._normalize_text(param_user_text) processed_ref = processed_ref.replace(f"{{{param_name}}}", normalized_param_user_text) print(f"Substituted '{param_name}' with '{normalized_param_user_text}'. Result: '{processed_ref}'") normalized_substituted_reference = self._normalize_text(processed_ref) print(f"Final normalized substituted reference: '{normalized_substituted_reference}'") return normalized_substituted_reference, all_params_validОсновные улучшения в механизме диапазонов:
- Поддержка списка значений:
[yes|no] - Числовые диапазоны:
[1-10] - Символьные диапазоны:
[a-z] - Операторы сравнения:
[>5],[<10]
Примеры использования:
# Список значений grader.grade("статус up", "статус [up|down]") # Успех # Числовой диапазон grader.grade("температура 25", "температура [20-30]") # Успех grader.grade("температура 35", "температура [20-30]") # Неудача # Символьный диапазон grader.grade("категория b", "категория [a-d]") # Успех # Сравнение grader.grade("значение 7", "значение [>5]") # Успех grader.grade("значение 3", "значение [>5]") # НеудачаПлюсы:
- Простота синтаксиса
- Гибкость в определении диапазонов
- Минимум сложной логики
- Легкая расширяемость
Хотите что-то изменить или дополнить?
- Поддержка списка значений:
- User
Поддерживать только числовые диапазоны [1-10] и альтернативы [да|нет|может быть] - норм, но может есть еще "дешевые" варианты?
Assistant
Вот несколько "дешевых" и простых вариантов расширения диапазонов:
- Регулярные выражения:
# Точное совпадение по regex [^\d+] - любое число [a-z] - любая буква [А-Я] - любая заглавная буква русского алфавита- Проверка на вхождение:
# Содержит подстроку [*ключ*] # Содержит слово "ключ"- Начинается/заканчивается:
[^старт*] # Начинается с "старт" [*финиш] # Заканчивается на "финиш"- Длина:
[len=3] # Длина строго 3 символа [len>5] # Длина больше 5 символов [len<10] # Длина меньше 10 символов- Простые математические операции:
[>5] # Больше 5 [<10] # Меньше 10 [>=3] # Больше или равно 3 [<=7] # Меньше или равно 7Пример реализации:
def _validate_range(self, value: str, range_content: str) -> bool: # Числовой диапазон if '-' in range_content: try: min_val, max_val = map(float, range_content.split('-')) val = float(value) return min_val <= val <= max_val except ValueError: return False # Альтернативы if '|' in range_content: return value in range_content.split('|') # Регулярные выражения if range_content.startswith('^'): return re.match(range_content[1:], value) is not None # Содержит подстроку if range_content.startswith('*') and range_content.endswith('*'): return range_content[1:-1] in value # Начинается с if range_content.startswith('^'): return value.startswith(range_content[1:]) # Заканчивается на if range_content.endswith('$'): return value.endswith(range_content[:-1]) # Длина if range_content.startswith('len'): try: if range_content.startswith('len='): return len(value) == int(range_content[4:]) if range_content.startswith('len>'): return len(value) > int(range_content[4:]) if range_content.startswith('len<'): return len(value) < int(range_content[4:]) except ValueError: return False # Математические операторы for op in ['>', '<', '>=', '<=']: if range_content.startswith(op): try: val = float(value) compare_val = float(range_content[len(op):]) if op == '>': return val > compare_val if op == '<': return val < compare_val if op == '>=': return val >= compare_val if op == '<=': return val <= compare_val except ValueError: return False return FalseПримеры использования:
# Числовой диапазон grader.grade("температура 25", "температура [20-30]") # Успех # Альтернативы grader.grade("статус up", "статус [up|down]") # Успех # Регулярные выражения grader.grade("код 123", "код [^\d+]") # Успех # Содержит подстроку grader.grade("ключевое слово", "текст [*ключ*]") # Успех # Начинается с grader.grade("старт процесса", "текст [^старт*]") # Успех # Заканчивается на grader.grade("результат финиш", "текст [*финиш]") # Успех # Длина grader.grade("abc", "текст [len=3]") # Успех grader.grade("a", "текст [len>1]") # Неудача # Математические операторы grader.grade("7", "[>5]") # Успех grader.grade("3", "[>=3]") # УспехПреимущества:
- Гибкость
- Простота использования
- Минимум сложной логики
- Легкая расширяемость
Недостатки:
- Может потребоваться дополнительная валидация
- Некоторые операции могут быть избыточными
Хотите что-то изменить или дополнить?
- User
одиночный параметр не надо, он будет просто указан текстом. множественные числа/строки? это что и зачем? открытые числовые диапазоны - не вижу смысла
Assistant
Вы правы. Давайте упростим механизм диапазонов:
def _validate_range(self, value: str, range_content: str) -> bool: """ Проверка значения в диапазоне Поддерживаемые форматы: - Числовой диапазон: [1-10] - Список значений: [да|нет|возможно] """ # Числовой диапазон if '-' in range_content: try: min_val, max_val = map(float, range_content.split('-')) val = float(value) return min_val <= val <= max_val except ValueError: return False # Список значений (альтернативы) if '|' in range_content: # Точное совпадение со списком, без лишних пробелов return value.strip() in [v.strip() for v in range_content.split('|')] return FalseПримеры использования:
# Числовой диапазон grader.grade("температура 25", "температура [20-30]") # Успех grader.grade("температура 35", "температура [20-30]") # Неудача # Список значений grader.grade("статус up", "статус [up|down]") # Успех grader.grade("статус maybe", "статус [да|нет|возможно]") # УспехОсновные изменения:
- Убраны лишние форматы
- Оставлены только два базовых варианта:
- Числовой диапазон
- Список допустимых значений
- Добавлена обработка пробелов для списка значений
Это более простой и прямолинейный подход. Что скажете?
Если нужны какие-то дополнительные варианты, можем обсудить. Но я стараюсь придерживаться принципа "минимализма" - чем проще механизм, тем легче его понять и поддерживать.
- User
да, ошибки очень важны (только их в comment не забывай писать)
Assistant
Отличное замечание. Вот обновленная версия с информативными ошибками в комментарии:
def _validate_range(self, value: str, range_content: str) -> GradeResult: """ Проверка значения в диапазоне Поддерживаемые форматы: - Числовой диапазон: [1-10] - Список значений: [да|нет|возможно] Возвращает GradeResult с подробным описанием ошибки """ # Числовой диапазон if '-' in range_content: try: min_val, max_val = map(float, range_content.split('-')) try: val = float(value) if min_val <= val <= max_val: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение {val} вне допустимого диапазона [{min_val}-{max_val}]" ) except ValueError: return GradeResult( score=0, comment=f"Невозможно преобразовать '{value}' к числу" ) except ValueError: return GradeResult( score=0, comment=f"Некорректный формат числового диапазона: {range_content}" ) # Список значений (альтернативы) if '|' in range_content: # Точное совпадение со списком, без лишних пробелов allowed_values = [v.strip() for v in range_content.split('|')] normalized_value = value.strip() if normalized_value in allowed_values: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение '{normalized_value}' не входит в список допустимых: {allowed_values}" ) # Неизвестный формат диапазона return GradeResult( score=0, comment=f"Неподдерживаемый формат диапазона: {range_content}" ) def _check_range_thesis(self, thesis: str, range_match, normalized_given: str) -> GradeResult: """ Проверка тезиса с диапазоном """ range_content = range_match.group(1) part_before = thesis[:range_match.start()] part_after = thesis[range_match.end():] try: line_regex = re.compile(re.escape(part_before) + r"(.+?)" + re.escape(part_after)) matches_in_given = line_regex.findall(normalized_given) if not matches_in_given: return GradeResult( score=0, comment=f"Не найдено совпадение для тезиса: {thesis}" ) for matched_value in matches_in_given: range_result = self._validate_range(matched_value.strip(), range_content) if range_result.score == 1: return range_result # Если ни одно значение не прошло валидацию return GradeResult( score=0, comment=f"Ни одно значение не соответствует диапазону {range_content}" ) except re.error as e: return GradeResult( score=0, comment=f"Ошибка компиляции regex для тезиса: {thesis}. Детали: {str(e)}" )Основные улучшения:
- Возвращаем
GradeResultвместо простого булева значения - Добавлены подробные комментарии об ошибках:
- Для числовых диапазонов
- Для списка значений
- При проблемах с regex
- Информативность ошибок повышена
- Сохранена простота механизма
Примеры:
# Числовой диапазон result = grader.grade("температура 35", "температура [20-30]") # result.comment == "Значение 35.0 вне допустимого диапазона [20.0-30.0]" result = grader.grade("температура abc", "температура [20-30]") # result.comment == "Невозможно преобразовать 'abc' к числу" # Список значений result = grader.grade("статус maybe", "статус [да|нет]") # result.comment == "Значение 'maybe' не входит в список допустимых: ['да', 'нет']"Такой подход обеспечивает:
- Понятность причин снижения оценки
- Простоту механизма
- Информативность для пользователя
Устраивает?
- Возвращаем
- User
мб сначала собрать все ошибки, а лишь потом отправлять?
if format_errors: comment = "Ошибки формата эталона:\n" + "\n".join(format_errors) return GradeResult(score=0, comment=comment)
if missing_theses: comment = "Не найдены тезисы:\n" + "\n".join(missing_theses) return GradeResult(score=0, comment=comment) Assistant
Отличное предложение! Вот примерная реализация:
def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Выполняет оценку параметризованного ответа. Собирает все ошибки перед вынесением вердикта. """ normalized_given = self._normalize_text(given_answer) print(f"Normalized Given: '{normalized_given}'") # Списки для сбора ошибок format_errors = [] # Ошибки формата эталона missing_theses = [] # Ненайденные тезисы parameter_errors = [] # Ошибки с параметрами # Подстановка параметров с отслеживанием ошибок normalized_substituted_reference, param_substitution_result = self._substitute_parameters( reference_answer, parameter_errors ) # Если есть ошибки с параметрами if parameter_errors: comment = "Ошибки параметров:\n" + "\n".join(parameter_errors) return GradeResult(score=0, comment=comment) # Если подстановка не удалась if normalized_substituted_reference is None: return GradeResult(score=0, comment="Не удалось обработать эталонный ответ") # Разбор тезисов theses = [line.strip() for line in normalized_substituted_reference.splitlines() if line.strip()] if not theses: return GradeResult(score=0, comment="Отсутствуют тезисы в эталонном ответе") # Проверка каждого тезиса for thesis in theses: thesis_result = self._check_thesis(thesis, normalized_given) # Если тезис не найден, добавляем в список ошибок if thesis_result.score == 0: missing_theses.append(thesis) # Финальная проверка результатов if format_errors: comment = "Ошибки формата эталона:\n" + "\n".join(format_errors) return GradeResult(score=0, comment=comment) if missing_theses: comment = "Не найдены тезисы:\n" + "\n".join(missing_theses) return GradeResult(score=0, comment=comment) # Если все тезисы найдены return GradeResult(score=1) def _check_thesis(self, thesis: str, normalized_given: str) -> GradeResult: """ Проверка отдельного тезиса Возвращает результат с баллом и опциональным комментарием """ range_match = self._RE_RANGE_PLACEHOLDER.search(thesis) if range_match: return self._check_range_thesis(thesis, range_match, normalized_given) # Статический тезис is_found = thesis in normalized_given return GradeResult( score=1 if is_found else 0, comment=f"Тезис не найден: {thesis}" if not is_found else None )Ключевые особенности:
- Раздельные списки для разных типов ошибок
- Последовательная проверка с накоплением ошибок
- Приоритет показа ошибок:
- Сначала ошибки параметров
- Затем ошибки формата
- Потом ненайденные тезисы
- Информативные комментарии
Примеры:
# Ошибки параметров result = grader.grade("ответ", "текст с {param}") # param не прошел предварительную оценку # result.comment == "Ошибки параметров: param не валиден" # Ненайденные тезисы result = grader.grade("текст", "тезис1\nтезис2") # result.comment == "Не найдены тезисы:\nтезис1\nтезис2" # Успешный кейс result = grader.grade("текст с числом 25", "текст с числом [20-30]") # result.score == 1Плюсы подхода:
- Собираем все ошибки
- Приоритизация ошибок
- Максимально информативные комментарии
- Гибкость в расширении типов ошибок
Что скажете?
- User
полный код
Assistant
Вот полный код с учетом всех обсуждений:
import re from dataclasses import dataclass from typing import Dict, Optional, Tuple from rapidfuzz import fuzz from labstructanalyzer.models.answer import Answer from labstructanalyzer.models.dto.answer import FullAnswerData, GradeResult from labstructanalyzer.models.answer_type import AnswerType class ParametrizedAnswerGrader: """ Класс для оценки параметризованного ответа """ _RE_PARAM_PLACEHOLDER = re.compile(r'\{([^}]+)}') _RE_RANGE_PLACEHOLDER = re.compile(r'\[(.*?)]') _RE_SINGLE_SPACE = re.compile(r'\s+') _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'\d+') def __init__(self, parameters: Dict[str, FullAnswerData]): """ Инициализирует оценщик параметризованного ответа. Args: parameters: Словарь параметров, на которые может ссылаться эталон """ self._parameters = parameters def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Выполняет оценку параметризованного ответа. Собирает все ошибки перед вынесением вердикта. """ normalized_given = self._normalize_text(given_answer) print(f"Normalized Given: '{normalized_given}'") # Списки для сбора ошибок format_errors = [] # Ошибки формата эталона missing_theses = [] # Ненайденные тезисы parameter_errors = [] # Ошибки с параметрами # Подстановка параметров с отслеживанием ошибок normalized_substituted_reference, param_substitution_result = self._substitute_parameters( reference_answer, parameter_errors ) # Если есть ошибки с параметрами if parameter_errors: comment = "Ошибки параметров:\n" + "\n".join(parameter_errors) return GradeResult(score=0, comment=comment) # Если подстановка не удалась if normalized_substituted_reference is None: return GradeResult(score=0, comment="Не удалось обработать эталонный ответ") # Разбор тезисов theses = [line.strip() for line in normalized_substituted_reference.splitlines() if line.strip()] if not theses: return GradeResult(score=0, comment="Отсутствуют тезисы в эталонном ответе") # Проверка каждого тезиса for thesis in theses: thesis_result = self._check_thesis(thesis, normalized_given) # Если тезис не найден, добавляем в список ошибок if thesis_result.score == 0: missing_theses.append(thesis_result.comment or thesis) # Финальная проверка результатов if format_errors: comment = "Ошибки формата эталона:\n" + "\n".join(format_errors) return GradeResult(score=0, comment=comment) if missing_theses: comment = "Не найдены тезисы:\n" + "\n".join(missing_theses) return GradeResult(score=0, comment=comment) # Если все тезисы найдены return GradeResult(score=1) def _check_thesis(self, thesis: str, normalized_given: str) -> GradeResult: """ Проверка отдельного тезиса Возвращает результат с баллом и опциональным комментарием """ range_match = self._RE_RANGE_PLACEHOLDER.search(thesis) if range_match: return self._check_range_thesis(thesis, range_match, normalized_given) # Статический тезис is_found = thesis in normalized_given return GradeResult( score=1 if is_found else 0, comment=f"Тезис не найден: {thesis}" if not is_found else None ) def _check_range_thesis(self, thesis: str, range_match, normalized_given: str) -> GradeResult: """ Проверка тезиса с диапазоном """ range_content = range_match.group(1) part_before = thesis[:range_match.start()] part_after = thesis[range_match.end():] try: line_regex = re.compile(re.escape(part_before) + r"(.+?)" + re.escape(part_after)) matches_in_given = line_regex.findall(normalized_given) if not matches_in_given: return GradeResult( score=0, comment=f"Не найдено совпадение для тезиса: {thesis}" ) for matched_value in matches_in_given: range_result = self._validate_range(matched_value.strip(), range_content) if range_result.score == 1: return range_result # Если ни одно значение не прошло валидацию return GradeResult( score=0, comment=f"Ни одно значение не соответствует диапазону {range_content}" ) except re.error as e: return GradeResult( score=0, comment=f"Ошибка компиляции regex для тезиса: {thesis}. Детали: {str(e)}" ) def _validate_range(self, value: str, range_content: str) -> GradeResult: """ Проверка значения в диапазоне Поддерживаемые форматы: - Числовой диапазон: [1-10] - Список значений: [да|нет|возможно] """ # Числовой диапазон if '-' in range_content: try: min_val, max_val = map(float, range_content.split('-')) try: val = float(value) if min_val <= val <= max_val: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение {val} вне допустимого диапазона [{min_val}-{max_val}]" ) except ValueError: return GradeResult( score=0, comment=f"Невозможно преобразовать '{value}' к числу" ) except ValueError: return GradeResult( score=0, comment=f"Некорректный формат числового диапазона: {range_content}" ) # Список значений (альтернативы) if '|' in range_content: # Точное совпадение со списком, без лишних пробелов allowed_values = [v.strip() for v in range_content.split('|')] normalized_value = value.strip() if normalized_value in allowed_values: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение '{normalized_value}' не входит в список допустимых: {allowed_values}" ) # Неизвестный формат диапазона return GradeResult( score=0, comment=f"Неподдерживаемый формат диапазона: {range_content}" ) def _normalize_text(self, text: str) -> str: """ Применяет минимальную нормализацию текста """ text = text.lower() text = self._RE_SINGLE_SPACE.sub(' ', text).strip() return text def _substitute_parameters( self, reference_answer: str, parameter_errors: list[str] ) -> Tuple[Optional[str], bool]: """ Подстановка параметров с отслеживанием ошибок """ processed_ref = reference_answer print(f"Substituting in reference: '{processed_ref}'") param_names_in_ref = self._RE_PARAM_PLACEHOLDER.findall(reference_answer) all_params_valid = True for param_name in param_names_in_ref: param_data = self._parameters.get(param_name) is_param_valid = ( param_data is not None and param_data.user_origin.pre_grade is not None and param_data.user_origin.pre_grade.get("score", 0) == 1 ) if not is_param_valid: print(f"Parameter '{param_name}' is missing or invalid") parameter_errors.append(f"Параметр '{param_name}' не прошел предварительную оценку") all_params_valid = False continue param_user_text = param_data.user_origin.data.get("text", "") normalized_param_user_text = self._normalize_text(param_user_text) processed_ref = processed_ref.replace(f"{{{param_name}}}", normalized_param_user_text) print(f"Substituted '{param_name}' with '{normalized_param_user_text}'. Result: '{processed_ref}'") normalized_substituted_reference = self._normalize_text(processed_ref) print(f"Final normalized substituted reference: '{normalized_substituted_reference}'") return normalized_substituted_reference, all_params_valid class PreGraderService: """Сервис предварительной оценки ответов по эталонным ответам преподавателя""" def __init__(self, answers: list[FullAnswerData]): """ Инициализирует сервис предварительной оценки Args: answers: Подготовленный список ответов для оценки """ self.answers = answers self.parameters = {answer.custom_id: answer for answer in answers} self._strategies = { AnswerType.simple.name: self._grade_fixed, AnswerType.param.name: ParametrizedAnswerGrader(self.parameters).grade } def grade(self) -> list[Answer]: """ Оценивает ответы, используя соответствующие эталон из элемента шаблона. Обновляет поле `pre_grade` у каждого объекта `Answer` в списке Returns: Список объектов Answer с результатами оценки """ graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue grade_result = strategy(answer_text, answer.reference) answer.user_origin.pre_grade = { "score": grade_result.score, **({"comment": grade_result.comment} if grade_result.comment else {}) } graded_answers.append(answer.user_origin) return graded_answers def _grade_fixed(self, given_answer: str, reference_answer: str) -> GradeResult: """ Сравнивает данный ответ с эталонным для фиксированных ответов. Проверяет совпадение цифр, затем слов (точное, по префиксу или по схожести > 90%) Args: given_answer: Текст ответа пользователя reference_answer: Эталонный текст ответа Returns: Объект GradeResult с баллом и опциональным комментарием """ reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) if given_digits != reference_digits: return GradeResult( score=0, comment=f"Цифры не совпадают. Эталон: {reference_digits}, Ответ: {given_digits}" ) if given_words == reference_words: return GradeResult(score=1) if len(given_words) <= len(reference_words): for offset in range(len(reference_words) - len(given_words) + 1): if all(reference_words[offset + i].startswith(given_words[i]) for i in range(len(given_words))): return GradeResult(score=1) score = fuzz.ratio(given_words, reference_words) if score >= 90: return GradeResult(score=1) return GradeResult( score=0, comment=f"Низкое совпадение слов. Схожесть: {score}%, Эталон: {reference_words}, Ответ: {given_words}" ) def _split_alnum(self, answer: str) -> tuple[list[str], list[str]]: """ Разделяет строку на список слов и список цифр Args: answer: Входная строка. Returns: Кортеж (список слов, список цифр) """ answer = answer.lower() letters = self._RE_WORDS.findall(answer) digits = self._RE_DIGITS.findall(answer) return letters, digitsОсновные особенности:
- Полная реализация
ParametrizedAnswerGrader - Интеграция в
PreGraderService - Поддержка двух типов диапазонов:
- Числовой:
[20-30] - Список значений:
[да|нет|возможно]
- Числовой:
- Информативные комментарии об ошибках
- Гибкий механизм проверки тезисов
Примеры использования остались прежними:
# Числовой диапазон result = grader.grade("температура 25", "температура [20-30]") # Успех # Список значений result = grader.grade("статус up", "статус [up|down]") # УспехГотов к обсуждению и доработкам!
- Полная реализация
- User
а может ты знаешь, как сделать проверку еще лучше, чем сейчас?
Assistant
Отличный вопрос! Вот несколько идей для улучшения механизма проверки:
- Нечеткое сравнение слов
def _compare_words_fuzzy(self, given_words, reference_words, threshold=80): """ Улучшенное нечеткое сравнение слов с весовыми коэффициентами """ if len(given_words) != len(reference_words): return False total_similarity = 0 for given, ref in zip(given_words, reference_words): # Используем разные метрики схожести ratio = fuzz.ratio(given, ref) partial_ratio = fuzz.partial_ratio(given, ref) token_sort_ratio = fuzz.token_sort_ratio(given, ref) # Взвешенное среднее word_similarity = ( 0.4 * ratio + 0.3 * partial_ratio + 0.3 * token_sort_ratio ) total_similarity += word_similarity return total_similarity / len(given_words) >= threshold- Расширенная валидация диапазонов
def _validate_range(self, value: str, range_content: str) -> GradeResult: """ Расширенная валидация с поддержкой более сложных форматов """ # Числовой диапазон с процентным отклонением if '-' in range_content: try: min_val, max_val = map(float, range_content.split('-')) try: val = float(value) # Допускаем 10% отклонения if min_val * 0.9 <= val <= max_val * 1.1: return GradeResult(score=1) else: return GradeResult( score=0.5 if min_val * 0.7 <= val <= max_val * 1.3 else 0, comment=f"Значение {val} близко, но вне точного диапазона [{min_val}-{max_val}]" ) except ValueError: return GradeResult( score=0, comment=f"Невозможно преобразовать '{value}' к числу" ) except ValueError: return GradeResult( score=0, comment=f"Некорректный формат числового диапазона: {range_content}" )- Семантический анализ
from transformers import pipeline class SemanticMatcher: def __init__(self): # Загрузка модели для семантического сравнения self.classifier = pipeline("zero-shot-classification") def compare_semantics(self, text1: str, text2: str, threshold: float = 0.7) -> float: """ Семантическое сравнение двух текстов """ try: result = self.classifier( text1, candidate_labels=[text2], multi_label=False ) return result['scores'][0] except Exception: return 0- Продвинутая обработка параметров
class ParameterValidator: def __init__(self, dependencies=None): """ Валидация параметров с учетом зависимостей dependencies: словарь зависимостей между параметрами { 'param1': {'requires': ['param2'], 'condition': lambda p1, p2: p1 > p2}, 'param2': {} } """ self.dependencies = dependencies or {} def validate_parameters(self, parameters): """ Проверка параметров с учетом взаимосвязей """ errors = [] for param_name, param_data in parameters.items(): # Проверка зависимостей if param_name in self.dependencies: deps = self.dependencies[param_name] for req_param in deps.get('requires', []): if req_param not in parameters: errors.append(f"Параметр {param_name} требует {req_param}") # Проверка условий if 'condition' in deps: try: if not deps['condition'](**{p: parameters[p] for p in parameters}): errors.append(f"Нарушены условия для параметра {param_name}") except Exception: errors.append(f"Ошибка проверки условий для {param_name}") return errors- Интеллектуальная обработка опечаток
from fuzzywuzzy import fuzz def _check_with_typo_tolerance(self, given_text: str, reference_text: str, threshold: int = 80) -> bool: """ Проверка с допуском опечаток """ # Прямое сравнение if given_text == reference_text: return True # Нечеткое сравнение similarity = fuzz.token_sort_ratio(given_text, reference_text) return similarity >= thresholdКомплексный подход:
class AdvancedGrader: def __init__(self): self.semantic_matcher = SemanticMatcher() self.parameter_validator = ParameterValidator() def grade(self, given_answer, reference_answer): # Комплексная оценка с использованием нескольких стратегий scores = [ self._check_exact_match(given_answer, reference_answer), self._check_semantic_similarity(given_answer, reference_answer), self._check_parameter_constraints(given_answer, reference_answer) ] return sum(scores) / len(scores)Рекомендации:
- Начните с простых улучшений
- Постепенно наращивайте сложность
- Тестируйте каждое изменение
- Используйте метрики для оценки качества
Какие подходы вам показались наиболее интересными?
- User
валидация эталона ПОКА не требуется, проверка диапазона - ок, нормализация - строго нет, строгое сопоставление параметров - хз, сообщения об ошибках - в целом, достаточно показать, что не так
Assistant
Понял. Тогда давайте немного оптимизируем текущую версию с учетом ваших комментариев:
def _validate_range(self, value: str, range_content: str) -> GradeResult: """ Проверка значения в диапазоне с более гибкой логикой """ # Числовой диапазон с процентным допуском if '-' in range_content: try: min_val, max_val = map(float, range_content.split('-')) try: val = float(value) # Допускаем 10% отклонения if min_val * 0.9 <= val <= max_val * 1.1: return GradeResult(score=1) else: # Частичный балл, если значение близко if min_val * 0.7 <= val <= max_val * 1.3: return GradeResult( score=0.5, comment=f"Значение {val} близко к диапазону [{min_val}-{max_val}]" ) return GradeResult( score=0, comment=f"Значение {val} вне диапазона [{min_val}-{max_val}]" ) except ValueError: return GradeResult( score=0, comment=f"Невозможно преобразовать '{value}' к числу" ) except ValueError: return GradeResult( score=0, comment=f"Некорректный формат диапазона: {range_content}" ) # Список значений (альтернативы) - точное сопоставление if '|' in range_content: allowed_values = [v.strip() for v in range_content.split('|')] if value.strip() in allowed_values: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение '{value}' не входит в список: {allowed_values}" ) # Неизвестный формат диапазона return GradeResult( score=0, comment=f"Неподдерживаемый формат диапазона: {range_content}" )Основные изменения:
- Добавлен частичный балл (0.5) для числовых диапазонов
- Сохранена простая логика сопоставления
- Информативные, но не слишком навороченные сообщения об ошибках
Примеры:
# Точное попадание в диапазон result = grader.grade("температура 25", "температура [20-30]") # score=1 # Близкое значение result = grader.grade("температура 32", "температура [20-30]") # score=0.5, comment о близости # Значительное отклонение result = grader.grade("температура 50", "температура [20-30]") # score=0, comment о выходе за диапазон # Список значений result = grader.grade("статус up", "статус [up|down]") # score=1 result = grader.grade("статус maybe", "статус [up|down]") # score=0, comment о списке значенийДля нормализации предлагаю оставить текущую простую версию:
def _normalize_text(self, text: str) -> str: """ Минимальная нормализация текста """ return text.lower().strip()Это позволит:
- Убрать лишние пробелы
- Привести к нижнему регистру
- Не делать сложных преобразований
Устраивает такой подход?
- User
несколько range в одном тезисе - обязательно!
Assistant
Отличное замечание! Вот улучшенная версия с поддержкой нескольких диапазонов в одном тезисе:
def _check_range_thesis(self, thesis: str, normalized_given: str) -> GradeResult: """ Проверка тезиса с несколькими диапазонами Формат: текст [диапазон1] текст [диапазон2] """ # Находим все диапазоны в тезисе ranges = self._RE_RANGE_PLACEHOLDER.findall(thesis) # Если диапазонов нет - простая проверка вхождения if not ranges: return GradeResult( score=1 if thesis in normalized_given else 0, comment="Тезис не найден" if thesis not in normalized_given else None ) # Заменяем диапазоны на регексп-шаблоны regex_thesis = thesis for range_content in ranges: regex_thesis = regex_thesis.replace(f'[{range_content}]', r'(.+?)') # Компиляция regex try: line_regex = re.compile(regex_thesis, re.IGNORECASE) matches = line_regex.findall(normalized_given) except re.error: return GradeResult( score=0, comment=f"Ошибка компиляции regex для тезиса: {thesis}" ) # Если совпадений нет if not matches: return GradeResult( score=0, comment=f"Тезис не найден: {thesis}" ) # Проверяем каждый найденный матч for match in matches: # Если один матч - преобразуем в кортеж if not isinstance(match, tuple): match = (match,) # Проверяем каждый диапазон range_results = [] for range_content, value in zip(ranges, match): range_result = self._validate_range(value.strip(), range_content) range_results.append(range_result) # Если все диапазоны прошли проверку if all(result.score == 1 for result in range_results): return GradeResult(score=1) # Собираем комментарии о неудачных диапазонах failed_ranges = [ result.comment for result in range_results if result.score < 1 and result.comment ] return GradeResult( score=0, comment="Не пройдены диапазоны:\n" + "\n".join(failed_ranges) if failed_ranges else None )Примеры использования:
# Один диапазон result = grader.grade("температура 25", "температура [20-30]") # Успех # Несколько диапазонов result = grader.grade( "длина 10 см, ширина 5 см", "длина [8-12] см, ширина [4-6] см" ) # Успех # Частичное несоответствие result = grader.grade( "длина 15 см, ширина 7 см", "длина [8-12] см, ширина [4-6] см" ) # Неудача с комментарием о конкретных диапазонахКлючевые особенности:
- Поддержка нескольких диапазонов в одном тезисе
- Гибкий поиск с использованием regex
- Подробные комментарии о причинах несоответствия
- Сохранение логики предыдущих реализаций
Хотите что-то доработать или изменить?
- User
чего еще не хватает?
Assistant
Давайте проанализируем возможные улучшения:
- Обработка параметров в тезисах
# Поддержка параметров в тезисах "длина {param1} см, ширина [4-6] см"- Поддержка более сложных условий
# Например, логические операции "значение > [10] и < [20]"- Опциональность тезисов
# Необязательные тезисы с весом "(необязательно) длина [8-12] см"- Поддержка разных единиц измерения
# Конвертация единиц "длина 0.5 м" == "длина 50 см"- Контекстная валидация
# Зависимость значений друг от друга "длина > ширина"- Расширенная семантическая проверка
# Проверка близости по смыслу "высокая скорость" ≈ "быстрое движение"Какие из этих направлений вам кажутся наиболее интересными/полезными?
Мое предложение начать с:
- Поддержки параметров в тезисах
- Опциональности тезисов
- Более гибкой валидации диапазонов
Что думаете?
- User
Сейчас такие скобки будут интерпретироваться как диапазоны и параметры. - меня интересует такое поведение - если параметр существует, то мы заменяем эту последовательность, если не существует - то оставляем как есть; для диапазонов я даже не знаю, звучит вроде логично
Assistant
Отличное наблюдение! Вот реализация такой логики:
def _substitute_parameters( self, reference_answer: str, parameter_errors: list[str] ) -> Tuple[Optional[str], bool]: """ Подстановка параметров с особой логикой: - Если параметр существует и прошел оценку - заменяем - Если параметр отсутствует или не прошел - оставляем как есть """ processed_ref = reference_answer print(f"Substituting in reference: '{processed_ref}'") # Находим все параметры и диапазоны param_names_in_ref = self._RE_PARAM_PLACEHOLDER.findall(reference_answer) range_contents_in_ref = self._RE_RANGE_PLACEHOLDER.findall(reference_answer) all_params_valid = True for param_name in param_names_in_ref: param_data = self._parameters.get(param_name) is_param_valid = ( param_data is not None and param_data.user_origin.pre_grade is not None and param_data.user_origin.pre_grade.get("score", 0) == 1 ) if is_param_valid: param_user_text = param_data.user_origin.data.get("text", "") processed_ref = processed_ref.replace(f"{{{param_name}}}", param_user_text) print(f"Substituted '{param_name}' with '{param_user_text}'") else: print(f"Parameter '{param_name}' skipped") all_params_valid = False return processed_ref, all_params_validПримеры:
# Параметр существует и прошел оценку # {param} заменится на значение reference = "длина {param} см" # Параметр не существует или не прошел оценку # {param} останется как есть reference = "длина {param} см" # Диапазоны остаются без изменений reference = "длина [10-20] см"Ключевые особенности:
- Параметры заменяются только если валидны
- Диапазоны не трогаются
- Информативный вывод о подстановке
- Сохраняется исходный текст, если параметр невалиден
Устраивает такой подход?
- User
сли формат неправильный (например, [abc-xyz]), мы выдаём ошибку - нет, давай не выдавать ошибку, а считать это текстом
Assistant
Отличное предложение! Вот обновленная версия
_validate_range, которая будет интерпретировать некорректные диапазоны как текст:def _validate_range(self, value: str, range_content: str) -> GradeResult: """ Проверка значения в диапазоне Если формат некорректен - считаем это текстовым значением """ # Попытка распознать числовой диапазон if '-' in range_content: try: # Пытаемся преобразовать к числам min_val, max_val = map(float, range_content.split('-')) try: val = float(value) if min_val <= val <= max_val: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение {val} вне диапазона [{min_val}-{max_val}]" ) except ValueError: # Если преобразование к числу не удалось - считаем текстовым значением return GradeResult( score=1 if value.strip() == range_content.strip() else 0, comment=f"Значение не число, точное сравнение" if value.strip() != range_content.strip() else None ) except ValueError: # Если split не удался - считаем текстовым значением return GradeResult( score=1 if value.strip() == range_content.strip() else 0, comment=f"Некорректный формат диапазона, точное сравнение" if value.strip() != range_content.strip() else None ) # Список значений (альтернативы) if '|' in range_content: allowed_values = [v.strip() for v in range_content.split('|')] normalized_value = value.strip() if normalized_value in allowed_values: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение '{normalized_value}' не входит в список: {allowed_values}" ) # Если ни числовой диапазон, ни список - точное сравнение return GradeResult( score=1 if value.strip() == range_content.strip() else 0, comment=f"Точное сравнение" if value.strip() != range_content.strip() else None )Примеры:
# Корректный числовой диапазон result = grader.grade("температура 25", "температура [20-30]") # Успех # Некорректный диапазон - интерпретируется как текст result = grader.grade("статус abc-xyz", "статус [abc-xyz]") # Успех # Некорректный диапазон - точное сравнение result = grader.grade("статус abc", "статус [abc-xyz]") # Неудача # Список значений result = grader.grade("статус up", "статус [up|down]") # УспехКлючевые особенности:
- Если диапазон не распознается как числовой - считаем текстовым
- Для текстовых значений - точное сравнение
- Сохраняется логика предыдущих реализаций
- Информативные комментарии
Устраивает такой подход?
- User
полный код
Assistant
Вот полный код с учетом всех обсуждений:
import re from dataclasses import dataclass from typing import Dict, Optional, Tuple, List from rapidfuzz import fuzz from labstructanalyzer.models.answer import Answer from labstructanalyzer.models.dto.answer import FullAnswerData, GradeResult from labstructanalyzer.models.answer_type import AnswerType class ParametrizedAnswerGrader: """ Класс для оценки параметризованного ответа """ _RE_PARAM_PLACEHOLDER = re.compile(r'\{([^}]+)}') _RE_RANGE_PLACEHOLDER = re.compile(r'\[(.*?)]') _RE_SINGLE_SPACE = re.compile(r'\s+') _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'\d+') def __init__(self, parameters: Dict[str, FullAnswerData]): """ Инициализирует оценщик параметризованного ответа. Args: parameters: Словарь параметров, на которые может ссылаться эталон """ self._parameters = parameters def grade(self, given_answer: str, reference_answer: str) -> GradeResult: """ Выполняет оценку параметризованного ответа. Собирает все ошибки перед вынесением вердикта. """ normalized_given = self._normalize_text(given_answer) print(f"Normalized Given: '{normalized_given}'") # Списки для сбора ошибок missing_theses = [] # Ненайденные тезисы parameter_errors = [] # Ошибки с параметрами # Подстановка параметров с отслеживанием ошибок normalized_substituted_reference, param_substitution_result = self._substitute_parameters( reference_answer, parameter_errors ) # Если есть ошибки с параметрами if parameter_errors: comment = "Ошибки параметров:\n" + "\n".join(parameter_errors) return GradeResult(score=0, comment=comment) # Если подстановка не удалась if normalized_substituted_reference is None: return GradeResult(score=0, comment="Не удалось обработать эталонный ответ") # Разбор тезисов theses = [line.strip() for line in normalized_substituted_reference.splitlines() if line.strip()] if not theses: return GradeResult(score=0, comment="Отсутствуют тезисы в эталонном ответе") # Проверка каждого тезиса for thesis in theses: thesis_result = self._check_thesis(thesis, normalized_given) # Если тезис не найден, добавляем в список ошибок if thesis_result.score == 0: missing_theses.append(thesis_result.comment or thesis) # Финальная проверка результатов if missing_theses: comment = "Не найдены тезисы:\n" + "\n".join(missing_theses) return GradeResult(score=0, comment=comment) # Если все тезисы найдены return GradeResult(score=1) def _check_thesis(self, thesis: str, normalized_given: str) -> GradeResult: """ Проверка отдельного тезиса Возвращает результат с баллом и опциональным комментарием """ range_match = self._RE_RANGE_PLACEHOLDER.search(thesis) if range_match: return self._check_range_thesis(thesis, range_match, normalized_given) # Статический тезис is_found = thesis in normalized_given return GradeResult( score=1 if is_found else 0, comment=f"Тезис не найден: {thesis}" if not is_found else None ) def _check_range_thesis(self, thesis: str, range_match, normalized_given: str) -> GradeResult: """ Проверка тезиса с несколькими диапазонами """ # Находим все диапазоны в тезисе ranges = self._RE_RANGE_PLACEHOLDER.findall(thesis) # Если диапазонов нет - простая проверка вхождения if not ranges: return GradeResult( score=1 if thesis in normalized_given else 0, comment="Тезис не найден" if thesis not in normalized_given else None ) # Заменяем диапазоны на регексп-шаблоны regex_thesis = thesis for range_content in ranges: regex_thesis = regex_thesis.replace(f'[{range_content}]', r'(.+?)') # Компиляция regex try: line_regex = re.compile(regex_thesis, re.IGNORECASE) matches = line_regex.findall(normalized_given) except re.error: return GradeResult( score=0, comment=f"Ошибка компиляции regex для тезиса: {thesis}" ) # Если совпадений нет if not matches: return GradeResult( score=0, comment=f"Тезис не найден: {thesis}" ) # Проверяем каждый найденный матч for match in matches: # Если один матч - преобразуем в кортеж if not isinstance(match, tuple): match = (match,) # Проверяем каждый диапазон range_results = [] for range_content, value in zip(ranges, match): range_result = self._validate_range(value.strip(), range_content) range_results.append(range_result) # Если все диапазоны прошли проверку if all(result.score == 1 for result in range_results): return GradeResult(score=1) # Собираем комментарии о неудачных диапазонах failed_ranges = [ result.comment for result in range_results if result.score < 1 and result.comment ] return GradeResult( score=0, comment="Не пройдены диапазоны:\n" + "\n".join(failed_ranges) if failed_ranges else None ) def _validate_range(self, value: str, range_content: str) -> GradeResult: """ Проверка значения в диапазоне Если формат некорректен - считаем это текстовым значением """ # Попытка распознать числовой диапазон if '-' in range_content: try: # Пытаемся преобразовать к числам min_val, max_val = map(float, range_content.split('-')) try: val = float(value) if min_val <= val <= max_val: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение {val} вне диапазона [{min_val}-{max_val}]" ) except ValueError: # Если преобразование к числу не удалось - считаем текстовым значением return GradeResult( score=1 if value.strip() == range_content.strip() else 0, comment=f"Значение не число, точное сравнение" if value.strip() != range_content.strip() else None ) except ValueError: # Если split не удался - считаем текстовым значением return GradeResult( score=1 if value.strip() == range_content.strip() else 0, comment=f"Некорректный формат диапазона, точное сравнение" if value.strip() != range_content.strip() else None ) # Список значений (альтернативы) if '|' in range_content: allowed_values = [v.strip() for v in range_content.split('|')] normalized_value = value.strip() if normalized_value in allowed_values: return GradeResult(score=1) else: return GradeResult( score=0, comment=f"Значение '{normalized_value}' не входит в список: {allowed_values}" ) # Если ни числовой диапазон, ни список - точное сравнение return GradeResult( score=1 if value.strip() == range_content.strip() else 0, comment=f"Точное сравнение" if value.strip() != range_content.strip() else None ) def _normalize_text(self, text: str) -> str: """ Применяет минимальную нормализацию текста """ text = text.lower() text = self._RE_SINGLE_SPACE.sub(' ', text).strip() return text def _substitute_parameters( self, reference_answer: str, parameter_errors: list[str] ) -> Tuple[Optional[str], bool]: """ Подстановка параметров с особой логикой: - Если параметр существует и прошел оценку - заменяем - Если параметр отсутствует или не прошел - оставляем как есть """ processed_ref = reference_answer print(f"Substituting in reference: '{processed_ref}'") # Находим все параметры и диапазоны param_names_in_ref = self._RE_PARAM_PLACEHOLDER.findall(reference_answer) all_params_valid = True for param_name in param_names_in_ref: param_data = self._parameters.get(param_name) is_param_valid = ( param_data is not None and param_data.user_origin.pre_grade is not None and param_data.user_origin.pre_grade.get("score", 0) == 1 ) if is_param_valid: param_user_text = param_data.user_origin.data.get("text", "") processed_ref = processed_ref.replace(f"{{{param_name}}}", param_user_text) print(f"Substituted '{param_name}' with '{param_user_text}'") else: print(f"Parameter '{param_name}' skipped") all_params_valid = False return processed_ref, all_params_valid class PreGraderService: """Сервис предварительной оценки ответов по эталонным ответам преподавателя""" _RE_WORDS = re.compile(r'[a-zа-яёй]+') _RE_DIGITS = re.compile(r'\d+') def __init__(self, answers: list[FullAnswerData]): """ Инициализирует сервис предварительной оценки Args: answers: Подготовленный список ответов для оценки """ self.answers = answers self.parameters = {answer.custom_id: answer for answer in answers} self._strategies = { AnswerType.simple.name: self._grade_fixed, AnswerType.param.name: ParametrizedAnswerGrader(self.parameters).grade } def grade(self) -> list[Answer]: """ Оценивает ответы, используя соответствующие эталон из элемента шаблона. Обновляет поле `pre_grade` у каждого объекта `Answer` в списке Returns: Список объектов Answer с результатами оценки """ graded_answers = [] for answer in self.answers: answer_text = answer.user_origin.data.get("text") if answer.user_origin.data else None if not answer_text or not answer.reference: continue strategy = self._strategies.get(answer.type.name) if not strategy: continue grade_result = strategy(answer_text, answer.reference) answer.user_origin.pre_grade = { "score": grade_result.score, **({"comment": grade_result.comment} if grade_result.comment else {}) } graded_answers.append(answer.user_origin) return graded_answers def _grade_fixed(self, given_answer: str, reference_answer: str) -> GradeResult: """ Сравнивает данный ответ с эталонным для фиксированных ответов. Проверяет совпадение цифр, затем слов (точное, по префиксу или по схожести > 90%) Args: given_answer: Текст ответа пользователя reference_answer: Эталонный текст ответа Returns: Объект GradeResult с баллом и опциональным комментарием """ reference_words, reference_digits = self._split_alnum(reference_answer) given_words, given_digits = self._split_alnum(given_answer) if given_digits != reference_digits: return GradeResult( score=0, comment=f"Цифры не совпадают. Эталон: {reference_digits}, Ответ: {given_digits}" ) if given_words == reference_words: return GradeResult(score=1) if len(given_words) <= len(reference_words): for offset in range(len(reference_words) - len(given_words) + 1): if all(reference_words[offset + i].startswith(given_words[i]) for i in range(len(given_words))): return GradeResult(score=1) score = fuzz.ratio(given_words, reference_words) if score >= 90: return GradeResult(score=1) return GradeResult( score=0, comment=f"Низкое совпадение слов. Схожесть: {score}%, Эталон: {reference_words}, Ответ: {given_words}" ) def _split_alnum(self, answer: str) -> tuple[list[str], list[str]]: """ Разделяет строку на список слов и список цифр Args: answer: Входная строка. Returns: Кортеж (список слов, список цифр) """ answer = answer.lower() letters = self._RE_WORDS.findall(answer) digits = self._RE_DIGITS.findall(answer) return letters, digitsОсновные особенности:
- Полная реализация
ParametrizedAnswerGrader - Поддержка парамет
- Полная реализация
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.