Тестирование Объяснимого ИИ: Понимание и Валидация Решений ИИ

from lime.lime_tabular import LimeTabularExplainer

class (как обсуждается в [AI Copilot for Test Automation: GitHub Copilot, Amazon CodeWhisperer and the Future of QA](/blog/ai-copilot-testing)) ОбъяснительLIME:
    def __init__(self, модель, данные_обучения, имена_признаков, имена_классов):
        self.модель = модель
        self.объяснитель = LimeTabularExplainer(
            training_data=данные_обучения,
            feature_names=имена_признаков,
            class_names=имена_классов,
            mode='classification'
        )

    def объяснить_предсказание(self, экземпляр):
        """Сгенерировать объяснение для одного экземпляра"""
        объяснение = self.объяснитель.explain_instance(
            экземпляр,
            self.модель.predict_proba,
            num_features=10
        )

        return {
            'предсказание': self.модель.predict([экземпляр])[0],
            'главные_признаки': объяснение.as_list()
        }

# Использование
объяснитель = ОбъяснительLIME(модель_займа, X_train, имена_признаков, ['Отклонен', 'Одобрен'])

экземпляр = X_test[0]  # Отклоненный займ
объяснение = объяснитель.объяснить_предсказание(экземпляр)

print("Предсказание:", объяснение['предсказание'])
print("\nГлавные факторы:")
for признак, вес in объяснение['главные_признаки']:
    print(f"  {признак}: {вес:.3f}")

# Вывод:
# Предсказание: Отклонен
# Главные факторы:
#   кредитный_рейтинг <= 650: -0.45
#   долг_к_доходу > 0.4: -0.32

import shap

class ОбъяснительSHAP:
    def __init__(self, модель, фоновые_данные):
        self.модель = модель
        self.объяснитель = shap.TreeExplainer(модель, фоновые_данные)

    def объяснить_экземпляр(self, экземпляр):
        """Получить SHAP значения для одного предсказания"""
        значения_shap = self.объяснитель.shap_values(экземпляр)

        return {
            'базовое_значение': self.объяснитель.expected_value,
            'значения_shap': значения_shap,
            'воздействие_признака': dict(zip(
                имена_признаков,
                значения_shap[0] if isinstance(значения_shap, list) else значения_shap
            ))
        }

    def получить_глобальную_важность(self, X_test):
        """Глобальная важность признаков"""
        значения_shap = self.объяснитель.shap_values(X_test)

        # Среднее абсолютных SHAP значений
        среднее_абс_shap = np.abs(значения_shap).mean(axis=0)

        return dict(sorted(
            zip(имена_признаков, среднее_абс_shap),
            key=lambda x: x[1],
            reverse=True
        ))

# Использование
объяснитель_shap = ОбъяснительSHAP(модель_xgboost, X_train[:100])

объяснение = объяснитель_shap.объяснить_экземпляр(X_test[[0]])
print("Воздействия признаков:")
for признак, воздействие in объяснение['воздействие_признака'].items():
    print(f"  {признак}: {воздействие:+.3f}")

class ТестерКонсистентностиОбъяснений:
    def __init__(self, объяснитель):
        self.объяснитель = объяснитель

    def тестировать_стабильность(self, экземпляр, количество_запусков=10):
        """Тестировать консистентность объяснений между запусками"""
        объяснения = []

        for _ in range(количество_запусков):
            объясн = self.объяснитель.объяснить_предсказание(экземпляр)
            объяснения.append(объясн['главные_признаки'])

        # Рассчитать вариацию в рангах важности
        ранги_признаков = {}
        for объясн in объяснения:
            for ранг, (признак, вес) in enumerate(объясн):
                if признак not in ранги_признаков:
                    ранги_признаков[признак] = []
                ранги_признаков[признак].append(ранг)

        # Рассчитать оценку стабильности
        оценки_стабильности = {
            признак: 1 - (np.std(ранги) / len(объясн))
            for признак, ранги in ранги_признаков.items()
        }

        средняя_стабильность = np.mean(list(оценки_стабильности.values()))

        return {
            'средняя_стабильность': средняя_стабильность,
            'стабильность_по_признакам': оценки_стабильности,
            'стабильно': средняя_стабильность > 0.8
        }

# Использование
тестер_консистентности = ТестерКонсистентностиОбъяснений(объяснитель_lime)
стабильность = тестер_консистентности.тестировать_стабильность(тестовый_экземпляр)

if not стабильность['стабильно']:
    print("⚠️ ПРЕДУПРЕЖДЕНИЕ: Объяснения нестабильны!")
    print(f"Средняя стабильность: {стабильность['средняя_стабильность']:.2%}")

class ТестерВерности:
    def __init__(self, модель, объяснитель):
        self.модель = модель
        self.объяснитель = объяснитель

    def тестировать_аблацию_признаков(self, экземпляр):
        """Удалить главные признаки, проверить изменение предсказания"""
        # Получить оригинальное предсказание
        оригинальное_предск = self.модель.predict_proba([экземпляр])[0]

        # Получить объяснение
        объяснение = self.объяснитель.объяснить_предсказание(экземпляр)
        главные_признаки = объяснение['главные_признаки'][:3]

        # Аблировать главные признаки
        аблированный_экз = экземпляр.copy()
        for имя_признака, вес in главные_признаки:
            индекс_признака = имена_признаков.index(имя_признака)
            аблированный_экз[индекс_признака] = np.median(X_train[:, индекс_признака])

        # Получить новое предсказание
        аблированное_предск = self.модель.predict_proba([аблированный_экз])[0]

        # Рассчитать изменение предсказания
        изменение_предск = abs(оригинальное_предск[1] - аблированное_предск[1])

        return {
            'оригинальное_предсказание': оригинальное_предск[1],
            'аблированное_предсказание': аблированное_предск[1],
            'изменение_предсказания': изменение_предск,
            'верно': изменение_предск > 0.1
        }

class ТестерСоответствияGDPR:
    def тестировать_адекватность_объяснения(self, объяснение, предсказание):
        """Проверить что объяснение соответствует требованиям GDPR"""
        проверки = {
            'имеет_читаемые_человеком_признаки': self.проверить_имена_признаков(объяснение),
            'предоставляет_реальные_значения': self.проверить_значения_признаков(объяснение),
            'показывает_направление_воздействия': self.проверить_знаки_воздействия(объяснение),
            'включает_уверенность': 'уверенность' in предсказание,
            'макс_признаков_разумно': len(объяснение['главные_признаки']) <= 10
        }

        оценка_соответствия = sum(проверки.values()) / len(проверки)

        return {
            'соответствует': оценка_соответствия >= 0.8,
            'оценка_соответствия': оценка_соответствия,
            'проваленные_проверки': [к for к, в in проверки.items() if not в]
        }