Руководство по Тестированию Чатботов: Валидация Систем Разговорного ИИ

class НаборТестовНамерений:
    def __init__(self, движок_nlu):
        self.nlu = движок_nlu
        self.тестовые_случаи = []

    def добавить_тест_намерения(self, высказывание, ожидаемое_намерение, мин_уверенность=0.8):
        self.тестовые_случаи.append({
            'вход': высказывание,
            'ожидаемое_намерение': ожидаемое_намерение,
            'мин_уверенность': мин_уверенность
        })

    def запустить_тесты(self):
        результаты = []
        for тест in self.тестовые_случаи:
            предсказание = self.nlu.предсказать_намерение(тест['вход'])

            результаты.append({
                'высказывание': тест['вход'],
                'ожидаемое': тест['ожидаемое_намерение'],
                'предсказанное': предсказание['намерение'],
                'уверенность': предсказание['уверенность'],
                'пройдено': (
                    предсказание['намерение'] == тест['ожидаемое_намерение'] and
                    предсказание['уверенность'] >= тест['мин_уверенность']
                )
            })

        return результаты

# Пример использования
тесты_nlu = НаборТестовНамерений(мой_чатбот.nlu)

# Позитивные примеры
тесты_nlu.добавить_тест_намерения("Хочу забронировать рейс", "забронировать_рейс")
тесты_nlu.добавить_тест_намерения("Помоги мне зарезервировать билет на самолет", "забронировать_рейс")

# Вариации и крайние случаи
тесты_nlu.добавить_тест_намерения("брнирование рийса пжлста", "забронировать_рейс")  # Опечатки
тесты_nlu.добавить_тест_намерения("ЗАБРОНИРОВАТЬ РЕЙС СЕЙЧАС!", "забронировать_рейс")  # Все заглавные

результаты = тесты_nlu.запустить_тесты()
точность = sum(р['пройдено'] for р in результаты) / len(результаты)
print(f"Точность намерений: {точность:.2%}")

class ТестПотокаДиалога:
    def __init__(self, чатбот):
        self.чатбот = чатбот
        self.ид_разговора = None

    def начать_разговор(self):
        self.ид_разговора = self.чатбот.создать_сессию()
        return self

    def отправить(self, сообщение, ожидаемые_паттерны=None):
        ответ = self.чатбот.отправить_сообщение(
            self.ид_разговора,
            сообщение
        )

        if ожидаемые_паттерны:
            for паттерн in ожидаемые_паттерны:
                assert re.search(паттерн, ответ['текст'], re.IGNORECASE), \
                    f"Ответ '{ответ['текст']}' не соответствует '{паттерн}'"

        return ответ

    def проверить_контекст(self, ключ, ожидаемое_значение):
        контекст = self.чатбот.получить_контекст(self.ид_разговора)
        фактическое = контекст.get(ключ)

        assert фактическое == ожидаемое_значение, \
            f"Несовпадение контекста: {ключ}={фактическое}, ожидалось {ожидаемое_значение}"

# Пример: Мульти-ход поток бронирования
диалог = ТестПотокаДиалога(мой_чатбот).начать_разговор()

диалог.отправить(
    "Хочу забронировать отель",
    ожидаемые_паттерны=["куда.*едете", "направление"]
)

диалог.отправить(
    "Барселона",
    ожидаемые_паттерны=["когда.*заезд", "даты"]
)
диалог.проверить_контекст('направление', 'Барселона')

from sentence_transformers import SentenceTransformer, util

class ОценщикРелевантностиОтветов:
    def __init__(self):
        self.модель = SentenceTransformer('all-MiniLM-L6-v2')

    def рассчитать_релевантность(self, вход_пользователя, ответ_бота, порог=0.5):
        эмбеддинги = self.модель.encode([вход_пользователя, ответ_бота])
        похожесть = util.cos_sim(эмбеддинги[0], эмбеддинги[1]).item()

        return {
            'оценка_похожести': похожесть,
            'релевантен': похожесть >= порог,
            'вход_пользователя': вход_пользователя,
            'ответ_бота': ответ_бота
        }

from transformers import pipeline

class ВалидаторБезопасности:
    def __init__(self):
        self.детектор_токсичности = pipeline(
            "text-classification",
            model="unitary/toxic-bert"
        )

    def валидировать_ответ(self, ответ_бота):
        результат_токсичности = self.детектор_токсичности(ответ_бота)[0]

        return {
            'текст': ответ_бота,
            'безопасен': результат_токсичности['label'] == 'non-toxic',
            'оценка_токсичности': результат_токсичности['score']
        }

import time

class ТестПроизводительности:
    def __init__(self, чатбот):
        self.чатбот = чатбот

    def измерить_время_ответа(self, сообщение, количество_запусков=100):
        времена_ответа = []

        for _ in range(количество_запусков):
            начало = time.time()
            self.чатбот.отправить_сообщение(сообщение)
            конец = time.time()
            времена_ответа.append((конец - начало) * 1000)

        return {
            'среднее_мс': sum(времена_ответа) / len(времена_ответа),
            'мин_мс': min(времена_ответа),
            'макс_мс': max(времена_ответа),
            'p95_мс': sorted(времена_ответа)[int(len(времена_ответа) * 0.95)]
        }

произв = ТестПроизводительности(мой_чатбот)
базовое = произв.измерить_время_ответа("Привет")
print(f"Среднее время ответа: {базовое['среднее_мс']:.2f}мс")

class ТестНеоднозначности:
    def __init__(self, чатбот):
        self.чатбот = чатбот

    def тестировать_неоднозначные_входы(self):
        тестовые_случаи = [
            {
                'вход': "банк",  # Финансовое учреждение или скамейка?
                'ожидать_уточнение': True
            },
            {
                'вход': "Хочу летать",  # Забронировать рейс или научиться летать?
                'ожидать_уточнение': True
            }
        ]

        for тест in тестовые_случаи:
            ответ = self.чатбот.отправить_сообщение(тест['вход'])

            паттерны_уточнения = [
                r"какой из них",
                r"имеете в виду",
                r"уточнить",
                r"более конкретно"
            ]

            запросил_уточнение = any(
                re.search(паттерн, ответ['текст'], re.IGNORECASE)
                for паттерн in паттерны_уточнения
            )

            if тест['ожидать_уточнение']:
                assert запросил_уточнение, \
                    f"Бот должен был запросить уточнение для '{тест['вход']}'"

class ТестРезервный:
    def __init__(self, чатбот):
        self.чатбот = чатбот

    def тестировать_вне_области(self):
        вне_области = [
            "Каков смысл жизни?",
            "asdfghjkl",
            "🚀🎉🔥",  # Только эмодзи
        ]

        for входной_текст in вне_области:
            ответ = self.чатбот.отправить_сообщение(входной_текст)

            приемлемые_резервные = [
                r"не понимаю",
                r"не могу помочь с этим",
                r"вне моей компетенции"
            ]

            есть_приемлемый_резервный = any(
                re.search(паттерн, ответ['текст'], re.IGNORECASE)
                for паттерн in приемлемые_резервные
            )

            assert есть_приемлемый_резервный

import json

class НаборРегрессионныхТестов:
    def __init__(self, чатбот, путь_золотого_датасета):
        self.чатбот = чатбот
        with open(путь_золотого_датасета) as f:
            self.золотой_датасет = json.load(f)

    def запустить_регрессионные_тесты(self):
        регрессии = []

        for тестовый_случай in self.золотой_датасет:
            текущий_ответ = self.чатбот.отправить_сообщение(тестовый_случай['вход'])

            if текущий_ответ['намерение'] != тестовый_случай['ожидаемое_намерение']:
                регрессии.append({
                    'тип': 'регрессия_намерения',
                    'вход': тестовый_случай['вход'],
                    'ожидаемое': тестовый_случай['ожидаемое_намерение'],
                    'фактическое': текущий_ответ['намерение']
                })

        return {
            'всего_тестов': len(self.золотой_датасет),
            'регрессии': len(регрессии),
            'процент_регрессии': len(регрессии) / len(self.золотой_датасет),
            'детали': регрессии
        }

const BotiumConnector = require('botium-connector-dialogflow')

describe('Чатбот Бронирования Рейсов', function() {
  it('должен понимать намерение бронирования рейса', async function() {
    await this.connector.UserSays('Хочу забронировать рейс')
    const response = await (как обсуждается в [AI-Assisted Bug Triaging: Intelligent Defect Prioritization at Scale](/blog/ai-bug-triaging)) this.connector.WaitBotSays()

 (как обсуждается в [AI Code Smell Detection: Finding Problems in Test Automation with ML](/blog/ai-code-smell-detection))    expect(response.intent).to.equal('забронировать_рейс')
  })
})