Explainable AI（XAI）とは

Explainable AI（XAI：説明可能AI）は、人工知能システムの意思決定プロセス、予測根拠、動作原理を人間が理解可能な形で説明・解釈できるようにする技術分野です。機械学習モデルの「ブラックボックス」問題を解決し、AI システムの透明性、信頼性、責任性を確保します。LIME、SHAP、アテンション機構などの手法により、特徴量の重要度、決定境界、予測根拠を可視化・言語化し、専門家から一般ユーザーまで様々なステークホルダーがAIの判断を理解し、適切に活用できるようにする重要な技術です。

背景と重要性

現代のAIシステム、特に深層学習モデルは高い性能を示す一方で、その内部処理が複雑で理解困難な「ブラックボックス」となっています。医療診断、自動運転、金融審査、刑事司法など重要な分野でのAI活用において、説明できない判断は信頼性と責任性の問題を引き起こします。

XAIは、

• AI システムへの信頼性向上
• 規制要件・法的責任への対応
• 人間とAIの効果的な協働

を実現することで、AI技術の社会実装と持続可能な発展を支える基盤技術です。説明可能性により、AI判断の妥当性検証、バイアス検出、システム改善が可能になります。

主な構成要素

解釈性（Interpretability）

モデルの動作原理や構造が人間にとって理解しやすいことです。

説明性（Explainability）

個別の予測や判断について具体的な根拠を提供できることです。

透明性（Transparency）

システム全体の動作が可視化され、検証可能であることです。

信頼性（Trustworthiness）

説明の正確性と一貫性が保証されていることです。

ユーザビリティ（Usability）

説明が対象ユーザーにとって理解しやすく有用であることです。

検証可能性（Verifiability）

説明内容が客観的に検証・評価できることです。

主な特徴

文脈依存性

説明の適切性は使用場面とユーザーによって異なります。

多層性

局所的説明から大域的説明まで複数のレベルがあります。

対話性

ユーザーとの相互作用により説明を改善できます。

説明可能性の手法

モデル固有の説明手法

線形モデルの解釈：

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

class LinearModelExplainer:
    def __init__(self, model, feature_names):
        self.model = model
        self.feature_names = feature_names
        
    def explain_coefficients(self, top_k=10):
        """回帰係数による特徴量重要度の説明"""
        
        if hasattr(self.model, 'coef_'):
            coefficients = self.model.coef_[0] if len(self.model.coef_.shape) > 1 else self.model.coef_
        else:
            raise ValueError("モデルに回帰係数がありません")
        
        # 係数の絶対値でソート
        coef_importance = [(name, coef) for name, coef in zip(self.feature_names, coefficients)]
        coef_importance.sort(key=lambda x: abs(x[1]), reverse=True)
        
        print("=== 特徴量重要度（回帰係数） ===")
        for i, (feature, coef) in enumerate(coef_importance[:top_k]):
            direction = "+" if coef > 0 else "-"
            print(f"{i+1:2d}. {feature:20s}: {direction}{abs(coef):8.4f}")
        
        return coef_importance
    
    def explain_prediction(self, sample, class_names=None):
        """個別サンプルの予測説明"""
        
        if len(sample.shape) == 1:
            sample = sample.reshape(1, -1)
        
        # 予測確率
        if hasattr(self.model, 'predict_proba'):
            prediction_proba = self.model.predict_proba(sample)[0]
            prediction = np.argmax(prediction_proba)
        else:
            prediction = self.model.predict(sample)[0]
            prediction_proba = None
        
        # 各特徴量の寄与度計算
        coefficients = self.model.coef_[0] if len(self.model.coef_.shape) > 1 else self.model.coef_
        intercept = self.model.intercept_[0] if hasattr(self.model.intercept_, '__len__') else self.model.intercept_
        
        contributions = sample[0] * coefficients
        
        print(f"=== 予測説明 ===")
        if class_names and prediction_proba is not None:
            print(f"予測クラス: {class_names[prediction]} (確率: {prediction_proba[prediction]:.3f})")
        else:
            print(f"予測値: {prediction}")
        
        print(f"切片: {intercept:.4f}")
        
        # 寄与度でソート
        feature_contributions = [(name, contrib, value) 
                               for name, contrib, value in zip(self.feature_names, contributions, sample[0])]
        feature_contributions.sort(key=lambda x: abs(x[1]), reverse=True)
        
        print("\n特徴量別寄与度:")
        total_contribution = sum(contributions) + intercept
        
        for feature, contrib, value in feature_contributions[:10]:
            percentage = (contrib / total_contribution) * 100 if total_contribution != 0 else 0
            print(f"{feature:20s}: {value:8.3f} × 係数 = {contrib:8.4f} ({percentage:6.1f}%)")
        
        return {
            'prediction': prediction,
            'prediction_proba': prediction_proba,
            'contributions': dict(zip(self.feature_names, contributions)),
            'intercept': intercept
        }

class TreeModelExplainer:
    def __init__(self, model, feature_names):
        self.model = model
        self.feature_names = feature_names
        
    def explain_feature_importance(self):
        """ランダムフォレストの特徴量重要度"""
        
        if hasattr(self.model, 'feature_importances_'):
            importances = self.model.feature_importances_
        else:
            raise ValueError("モデルに特徴量重要度がありません")
        
        # 重要度でソート
        feature_importance = [(name, imp) for name, imp in zip(self.feature_names, importances)]
        feature_importance.sort(key=lambda x: x[1], reverse=True)
        
        print("=== 特徴量重要度（不純度減少） ===")
        for i, (feature, importance) in enumerate(feature_importance):
            print(f"{i+1:2d}. {feature:20s}: {importance:8.4f}")
        
        return feature_importance
    
    def explain_decision_path(self, sample, tree_index=0):
        """決定木の判定パス説明"""
        
        if len(sample.shape) == 1:
            sample = sample.reshape(1, -1)
        
        # 単一の決定木を取得
        if hasattr(self.model, 'estimators_'):
            tree = self.model.estimators_[tree_index]
        else:
            tree = self.model
        
        # 決定パスを取得
        decision_path = tree.decision_path(sample)
        leaf_id = tree.apply(sample)
        
        print(f"=== 決定パス説明（木 {tree_index}） ===")
        
        # パスの各ノードを辿る
        feature = tree.tree_.feature
        threshold = tree.tree_.threshold
        
        sample_id = 0
        node_indicator = decision_path.toarray()[sample_id, :]
        
        for node_id in range(tree.tree_.node_count):
            if node_indicator[node_id]:
                if leaf_id[sample_id] == node_id:
                    print(f"リーフノード {node_id}: 予測完了")
                else:
                    feature_name = self.feature_names[feature[node_id]]
                    threshold_value = threshold[node_id]
                    sample_value = sample[sample_id, feature[node_id]]
                    
                    if sample_value <= threshold_value:
                        direction = "<="
                    else:
                        direction = ">"
                    
                    print(f"ノード {node_id}: {feature_name} ({sample_value:.3f}) {direction} {threshold_value:.3f}")

def demonstrate_model_specific_explanation():
    # サンプルデータの生成
    np.random.seed(42)
    n_samples = 1000
    
    # 特徴量生成
    age = np.random.normal(35, 10, n_samples)
    income = np.random.normal(50000, 15000, n_samples)
    credit_score = np.random.normal(650, 100, n_samples)
    employment_years = np.random.normal(8, 5, n_samples)
    
    X = np.column_stack([age, income, credit_score, employment_years])
    feature_names = ['age', 'income', 'credit_score', 'employment_years']
    
    # ターゲット生成（融資承認）
    y = np.zeros(n_samples)
    for i in range(n_samples):
        score = (income[i] / 1000) * 0.01 + (credit_score[i] - 600) * 0.002 + (employment_years[i] * 0.05)
        y[i] = 1 if score + np.random.normal(0, 0.1) > 0.5 else 0
    
    # データ分割
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    
    # 線形モデル
    print("=== 線形モデル（ロジスティック回帰） ===")
    lr_model = LogisticRegression()
    lr_model.fit(X_train, y_train)
    
    lr_explainer = LinearModelExplainer(lr_model, feature_names)
    lr_explainer.explain_coefficients()
    
    print("\n=== 個別予測の説明 ===")
    sample_idx = 0
    lr_explainer.explain_prediction(X_test[sample_idx], class_names=['拒否', '承認'])
    
    # ツリーモデル
    print("\n=== ツリーモデル（ランダムフォレスト） ===")
    rf_model = RandomForestClassifier(n_estimators=10, random_state=42)
    rf_model.fit(X_train, y_train)
    
    tree_explainer = TreeModelExplainer(rf_model, feature_names)
    tree_explainer.explain_feature_importance()
    
    print("\n=== 決定パス説明 ===")
    tree_explainer.explain_decision_path(X_test[sample_idx], tree_index=0)

# demonstrate_model_specific_explanation()

モデル非依存の説明手法

LIME（Local Interpretable Model-agnostic Explanations）：

import numpy as np
from sklearn.base import BaseEstimator

class SimpleLIME:
    def __init__(self, model, feature_names, mode='classification'):
        self.model = model
        self.feature_names = feature_names
        self.mode = mode
        
    def explain_instance(self, instance, num_features=5, num_samples=1000):
        """個別インスタンスの局所的説明"""
        
        if len(instance.shape) == 1:
            instance = instance.reshape(1, -1)
        
        # 元の予測
        if self.mode == 'classification':
            original_prediction = self.model.predict_proba(instance)[0]
        else:
            original_prediction = self.model.predict(instance)[0]
        
        # 摂動サンプルの生成
        perturbations = self._generate_perturbations(instance[0], num_samples)
        
        # 摂動サンプルでの予測
        if self.mode == 'classification':
            perturbed_predictions = self.model.predict_proba(perturbations)[:, 1]  # 正例の確率
        else:
            perturbed_predictions = self.model.predict(perturbations)
        
        # 距離の計算（元インスタンスからの距離）
        distances = np.sqrt(np.sum((perturbations - instance[0])**2, axis=1))
        weights = np.exp(-distances / np.std(distances))  # ガウシアンカーネル
        
        # 線形モデルによる近似
        from sklearn.linear_model import LinearRegression
        local_model = LinearRegression()
        local_model.fit(perturbations, perturbed_predictions, sample_weight=weights)
        
        # 特徴量重要度の計算
        feature_importance = np.abs(local_model.coef_)
        
        # 上位特徴量の選択
        top_features = np.argsort(feature_importance)[::-1][:num_features]
        
        print("=== LIME 局所説明 ===")
        print(f"元の予測: {original_prediction}")
        print(f"局所モデルR²: {local_model.score(perturbations, perturbed_predictions, sample_weight=weights):.3f}")
        
        print("\n重要特徴量:")
        for i, feature_idx in enumerate(top_features):
            feature_name = self.feature_names[feature_idx]
            importance = feature_importance[feature_idx]
            feature_value = instance[0, feature_idx]
            coefficient = local_model.coef_[feature_idx]
            
            print(f"{i+1}. {feature_name:20s}: {feature_value:8.3f} (重要度: {importance:6.4f}, 係数: {coefficient:8.4f})")
        
        return {
            'feature_importance': dict(zip(self.feature_names, feature_importance)),
            'top_features': [self.feature_names[i] for i in top_features],
            'local_model': local_model,
            'original_prediction': original_prediction
        }
    
    def _generate_perturbations(self, instance, num_samples):
        """摂動サンプルの生成"""
        n_features = len(instance)
        perturbations = np.zeros((num_samples, n_features))
        
        for i in range(num_samples):
            # 各特徴量を独立にノイズ付加
            for j in range(n_features):
                # 正規分布からサンプリング（平均は元の値、標準偏差は特徴量の標準偏差に比例）
                noise_std = abs(instance[j]) * 0.1 + 0.01  # 適応的なノイズレベル
                perturbations[i, j] = instance[j] + np.random.normal(0, noise_std)
        
        return perturbations

class SimpleSHAP:
    def __init__(self, model, background_data, feature_names):
        self.model = model
        self.background_data = background_data
        self.feature_names = feature_names
        self.baseline = np.mean(background_data, axis=0)
        
    def explain_instance(self, instance, num_samples=100):
        """SHAP値による説明（簡略版）"""
        
        if len(instance.shape) == 1:
            instance = instance.reshape(1, -1)
        
        n_features = instance.shape[1]
        shap_values = np.zeros(n_features)
        
        # 元の予測
        original_pred = self.model.predict(instance)[0]
        
        # ベースライン予測
        baseline_pred = self.model.predict(self.baseline.reshape(1, -1))[0]
        
        # 各特徴量のShapley値を近似計算
        for feature_idx in range(n_features):
            marginal_contributions = []
            
            # 複数のランダムな特徴量集合でマージナル貢献を計算
            for _ in range(num_samples):
                # ランダムに特徴量のサブセットを選択
                subset_size = np.random.randint(1, n_features)
                feature_subset = np.random.choice(n_features, subset_size, replace=False)
                
                # 現在の特徴量を含まない場合
                if feature_idx not in feature_subset:
                    instance_without = instance.copy()
                    instance_with = instance.copy()
                    
                    # サブセット外の特徴量をベースライン値に置換
                    for j in range(n_features):
                        if j not in feature_subset and j != feature_idx:
                            instance_without[0, j] = self.baseline[j]
                            instance_with[0, j] = self.baseline[j]
                    
                    # feature_idxをベースライン値に置換（without）
                    instance_without[0, feature_idx] = self.baseline[feature_idx]
                    
                    # 予測値の差
                    pred_with = self.model.predict(instance_with)[0]
                    pred_without = self.model.predict(instance_without)[0]
                    
                    marginal_contributions.append(pred_with - pred_without)
            
            # 平均マージナル貢献
            shap_values[feature_idx] = np.mean(marginal_contributions)
        
        # 正規化（合計が予測値とベースラインの差になるように）
        total_contribution = np.sum(shap_values)
        expected_total = original_pred - baseline_pred
        
        if abs(total_contribution) > 1e-6:
            shap_values = shap_values * (expected_total / total_contribution)
        
        print("=== SHAP 値説明 ===")
        print(f"ベースライン予測: {baseline_pred:.4f}")
        print(f"現在の予測: {original_pred:.4f}")
        print(f"差分: {expected_total:.4f}")
        
        # SHAP値でソート
        feature_shap = [(name, shap_val, instance[0, i]) 
                       for i, (name, shap_val) in enumerate(zip(self.feature_names, shap_values))]
        feature_shap.sort(key=lambda x: abs(x[1]), reverse=True)
        
        print("\nSHAP値による特徴量寄与:")
        for feature, shap_val, feature_val in feature_shap:
            direction = "+" if shap_val > 0 else ""
            print(f"{feature:20s}: {feature_val:8.3f} → {direction}{shap_val:8.4f}")
        
        return {
            'shap_values': dict(zip(self.feature_names, shap_values)),
            'baseline_prediction': baseline_pred,
            'instance_prediction': original_pred
        }

def demonstrate_model_agnostic_explanation():
    # サンプルデータ（前回と同じ）
    np.random.seed(42)
    n_samples = 1000
    
    age = np.random.normal(35, 10, n_samples)
    income = np.random.normal(50000, 15000, n_samples)
    credit_score = np.random.normal(650, 100, n_samples)
    employment_years = np.random.normal(8, 5, n_samples)
    
    X = np.column_stack([age, income, credit_score, employment_years])
    feature_names = ['age', 'income', 'credit_score', 'employment_years']
    
    y = np.zeros(n_samples)
    for i in range(n_samples):
        score = (income[i] / 1000) * 0.01 + (credit_score[i] - 600) * 0.002 + (employment_years[i] * 0.05)
        y[i] = 1 if score + np.random.normal(0, 0.1) > 0.5 else 0
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    
    # 複雑なモデル（ランダムフォレスト）
    from sklearn.ensemble import RandomForestClassifier
    complex_model = RandomForestClassifier(n_estimators=50, random_state=42)
    complex_model.fit(X_train, y_train)
    
    # LIME説明
    lime_explainer = SimpleLIME(complex_model, feature_names)
    lime_result = lime_explainer.explain_instance(X_test[0])
    
    print("\n" + "="*50)
    
    # SHAP説明
    shap_explainer = SimpleSHAP(complex_model, X_train[:100], feature_names)  # 背景データは一部のみ使用
    shap_result = shap_explainer.explain_instance(X_test[0])

# demonstrate_model_agnostic_explanation()

アテンション機構による説明

アテンション重みの可視化：

import torch
import torch.nn as nn
import torch.nn.functional as F

class AttentionExplainer:
    def __init__(self, attention_model):
        self.model = attention_model
        
    def explain_attention_weights(self, input_sequence, token_names=None):
        """アテンション重みによる説明"""
        
        self.model.eval()
        with torch.no_grad():
            # アテンション重みを取得
            output, attention_weights = self.model(input_sequence, return_attention=True)
            
        # 複数のヘッドがある場合は平均
        if len(attention_weights.shape) > 2:
            attention_weights = attention_weights.mean(dim=1)  # ヘッド次元で平均
        
        attention_weights = attention_weights.squeeze().numpy()
        
        print("=== アテンション重み説明 ===")
        
        if token_names is None:
            token_names = [f"Token_{i}" for i in range(len(attention_weights))]
        
        # アテンション重みでソート
        attention_pairs = [(name, weight) for name, weight in zip(token_names, attention_weights)]
        attention_pairs.sort(key=lambda x: x[1], reverse=True)
        
        print("アテンション重み（重要度順）:")
        total_attention = sum(attention_weights)
        
        for i, (token, weight) in enumerate(attention_pairs):
            percentage = (weight / total_attention) * 100
            bar_length = int(weight * 50 / max(attention_weights))
            bar = "█" * bar_length
            print(f"{i+1:2d}. {token:15s}: {weight:6.4f} ({percentage:5.1f}%) {bar}")
        
        return {
            'attention_weights': dict(zip(token_names, attention_weights)),
            'sorted_attention': attention_pairs
        }
    
    def visualize_attention_matrix(self, input_sequence, token_names=None):
        """アテンション行列の可視化"""
        
        self.model.eval()
        with torch.no_grad():
            output, attention_matrix = self.model(input_sequence, return_attention=True)
        
        if len(attention_matrix.shape) == 4:  # [batch, heads, seq, seq]
            attention_matrix = attention_matrix.squeeze(0).mean(0)  # バッチとヘッド次元を削除/平均
        elif len(attention_matrix.shape) == 3:  # [batch, seq, seq]
            attention_matrix = attention_matrix.squeeze(0)
        
        attention_matrix = attention_matrix.numpy()
        
        if token_names is None:
            token_names = [f"T{i}" for i in range(attention_matrix.shape[0])]
        
        print("=== アテンション行列 ===")
        print("行: クエリトークン, 列: キートークン")
        print("各行は、そのトークンが他のトークンにどれだけ注意を向けているかを示す")
        print()
        
        # ヘッダー印刷
        print("Query\\Key  ", end="")
        for token in token_names:
            print(f"{token:8s}", end="")
        print()
        
        # 行列印刷
        for i, query_token in enumerate(token_names):
            print(f"{query_token:10s}", end="")
            for j in range(len(token_names)):
                print(f"{attention_matrix[i, j]:8.3f}", end="")
            print()
        
        return attention_matrix

# 簡単なアテンション付きモデル（概念実装）
class SimpleAttentionModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(SimpleAttentionModel, self).__init__()
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        
        # アテンション機構
        self.attention_linear = nn.Linear(input_dim, hidden_dim)
        self.attention_weights = nn.Linear(hidden_dim, 1)
        
        # 出力層
        self.output_linear = nn.Linear(input_dim, output_dim)
        
    def forward(self, x, return_attention=False):
        # x: [batch_size, sequence_length, input_dim]
        
        # アテンション重みの計算
        attention_hidden = torch.tanh(self.attention_linear(x))  # [batch, seq, hidden]
        attention_scores = self.attention_weights(attention_hidden).squeeze(-1)  # [batch, seq]
        attention_weights = F.softmax(attention_scores, dim=1)  # [batch, seq]
        
        # 重み付き平均
        attended_features = torch.sum(attention_weights.unsqueeze(-1) * x, dim=1)  # [batch, input_dim]
        
        # 出力
        output = self.output_linear(attended_features)
        
        if return_attention:
            return output, attention_weights
        else:
            return output

def demonstrate_attention_explanation():
    # サンプルシーケンスデータ
    torch.manual_seed(42)
    
    # 文書分類タスクを想定（5つの「単語」、各単語は10次元ベクトル）
    sequence_length = 5
    input_dim = 10
    batch_size = 1
    
    # ランダムな入力シーケンス
    input_sequence = torch.randn(batch_size, sequence_length, input_dim)
    
    # トークン名（例：単語）
    token_names = ["economic", "growth", "inflation", "policy", "market"]
    
    # モデル
    model = SimpleAttentionModel(input_dim, hidden_dim=8, output_dim=2)
    
    # 説明器
    explainer = AttentionExplainer(model)
    
    # アテンション重みによる説明
    attention_result = explainer.explain_attention_weights(input_sequence, token_names)
    
    # より複雑な例：自己アテンション行列
    print("\n" + "="*50)
    print("自己アテンション行列の例")
    
    # 自己アテンション風の行列（概念的）
    self_attention = torch.softmax(torch.randn(sequence_length, sequence_length), dim=1)
    
    print("=== 自己アテンション行列 ===")
    print("各トークンが他のトークンにどれだけ注意を向けているか")
    print()
    
    # ヘッダー
    print("Token     ", end="")
    for token in token_names:
        print(f"{token:10s}", end="")
    print()
    
    # 行列
    for i, token in enumerate(token_names):
        print(f"{token:10s}", end="")
        for j in range(len(token_names)):
            print(f"{self_attention[i, j].item():10.3f}", end="")
        print()

# demonstrate_attention_explanation()

高度な説明手法

概念活性化ベクトル（TCAV）

概念ベースの説明：

from sklearn.svm import LinearSVC
from sklearn.metrics.pairwise import cosine_similarity

class ConceptActivationVector:
    def __init__(self, model, layer_name):
        self.model = model
        self.layer_name = layer_name
        self.concepts = {}
        
    def train_concept(self, concept_name, positive_examples, negative_examples):
        """概念の学習（CAVの訓練）"""
        
        # 概念とランダムサンプルで二値分類器を訓練
        positive_activations = self._get_activations(positive_examples)
        negative_activations = self._get_activations(negative_examples)
        
        X = np.vstack([positive_activations, negative_activations])
        y = np.hstack([np.ones(len(positive_activations)), 
                      np.zeros(len(negative_activations))])
        
        # 線形分類器（概念方向ベクトル）
        classifier = LinearSVC(random_state=42)
        classifier.fit(X, y)
        
        # CAVベクトル（正規化された法線ベクトル）
        cav_vector = classifier.coef_[0]
        cav_vector = cav_vector / np.linalg.norm(cav_vector)
        
        self.concepts[concept_name] = {
            'vector': cav_vector,
            'classifier': classifier,
            'accuracy': classifier.score(X, y)
        }
        
        print(f"概念 '{concept_name}' のCAV訓練完了")
        print(f"分類精度: {self.concepts[concept_name]['accuracy']:.3f}")
        
        return cav_vector
    
    def compute_tcav_score(self, concept_name, test_examples, target_class):
        """TCAV スコアの計算"""
        
        if concept_name not in self.concepts:
            raise ValueError(f"概念 '{concept_name}' が訓練されていません")
        
        cav_vector = self.concepts[concept_name]['vector']
        
        # テスト例での勾配計算（概念的実装）
        tcav_scores = []
        
        for example in test_examples:
            # 活性化の取得
            activation = self._get_activations([example])[0]
            
            # 勾配の計算（簡略化：活性化とCAVベクトルの内積）
            gradient_direction = np.dot(activation, cav_vector)
            
            # 正の勾配の場合、概念が予測に正の影響
            tcav_scores.append(gradient_direction > 0)
        
        # TCAVスコア：正の勾配を持つ例の割合
        tcav_score = np.mean(tcav_scores)
        
        print(f"=== TCAV スコア ===")
        print(f"概念: {concept_name}")
        print(f"対象クラス: {target_class}")
        print(f"TCAV スコア: {tcav_score:.3f}")
        print(f"解釈: この概念は予測に {tcav_score*100:.1f}% の確率で正の影響を与える")
        
        return tcav_score
    
    def _get_activations(self, examples):
        """指定レイヤーでの活性化を取得"""
        # 実際の実装では、モデルの中間層から活性化を抽出
        # ここでは概念的な実装
        activations = []
        for example in examples:
            # ランダムな活性化（実際にはモデルから取得）
            activation = np.random.randn(128)  # 128次元の活性化
            activations.append(activation)
        
        return np.array(activations)

class CounterfactualExplainer:
    def __init__(self, model, feature_names):
        self.model = model
        self.feature_names = feature_names
        
    def generate_counterfactual(self, instance, target_class, max_changes=3, max_iterations=100):
        """反実仮想例の生成"""
        
        if len(instance.shape) == 1:
            instance = instance.reshape(1, -1)
        
        current_instance = instance.copy()
        original_prediction = self.model.predict(instance)[0]
        
        print(f"=== 反実仮想例生成 ===")
        print(f"元の予測: {original_prediction}")
        print(f"目標クラス: {target_class}")
        
        changes_made = []
        
        for iteration in range(max_iterations):
            current_prediction = self.model.predict(current_instance)[0]
            
            if current_prediction == target_class:
                print(f"目標達成！ {iteration} 回の反復で成功")
                break
            
            if len(changes_made) >= max_changes:
                print(f"最大変更数 {max_changes} に達しました")
                break
            
            # 最も影響の大きい特徴量を見つける
            best_feature = None
            best_change = None
            best_improvement = 0
            
            for feature_idx in range(current_instance.shape[1]):
                if feature_idx in [change['feature'] for change in changes_made]:
                    continue  # 既に変更した特徴量はスキップ
                
                # 特徴量を少し変更してみる
                for delta in [-0.5, -0.3, -0.1, 0.1, 0.3, 0.5]:
                    test_instance = current_instance.copy()
                    test_instance[0, feature_idx] += delta
                    
                    # 予測確率の変化を評価
                    if hasattr(self.model, 'predict_proba'):
                        test_proba = self.model.predict_proba(test_instance)[0, target_class]
                        current_proba = self.model.predict_proba(current_instance)[0, target_class]
                        improvement = test_proba - current_proba
                    else:
                        # 予測クラスが目標に近づくかどうか
                        test_pred = self.model.predict(test_instance)[0]
                        improvement = 1 if test_pred == target_class else 0
                    
                    if improvement > best_improvement:
                        best_improvement = improvement
                        best_feature = feature_idx
                        best_change = delta
            
            if best_feature is not None:
                # 最良の変更を適用
                old_value = current_instance[0, best_feature]
                current_instance[0, best_feature] += best_change
                new_value = current_instance[0, best_feature]
                
                changes_made.append({
                    'feature': best_feature,
                    'feature_name': self.feature_names[best_feature],
                    'old_value': old_value,
                    'new_value': new_value,
                    'change': best_change
                })
                
                print(f"変更 {len(changes_made)}: {self.feature_names[best_feature]} "
                      f"{old_value:.3f} → {new_value:.3f} (Δ{best_change:+.3f})")
            else:
                print("有効な変更が見つかりませんでした")
                break
        
        final_prediction = self.model.predict(current_instance)[0]
        
        print(f"\n最終予測: {final_prediction}")
        print("必要な変更:")
        for change in changes_made:
            print(f"- {change['feature_name']}: {change['old_value']:.3f} → {change['new_value']:.3f}")
        
        return {
            'counterfactual_instance': current_instance[0],
            'changes': changes_made,
            'successful': final_prediction == target_class,
            'final_prediction': final_prediction
        }

def demonstrate_advanced_explanation():
    # サンプルデータ
    np.random.seed(42)
    n_samples = 200
    
    # 特徴量（年齢、収入、信用スコア、勤続年数）
    age = np.random.normal(35, 10, n_samples)
    income = np.random.normal(50000, 15000, n_samples)
    credit_score = np.random.normal(650, 100, n_samples)
    employment_years = np.random.normal(8, 5, n_samples)
    
    X = np.column_stack([age, income, credit_score, employment_years])
    feature_names = ['age', 'income', 'credit_score', 'employment_years']
    
    # ターゲット
    y = np.zeros(n_samples)
    for i in range(n_samples):
        score = (income[i] / 1000) * 0.01 + (credit_score[i] - 600) * 0.002 + (employment_years[i] * 0.05)
        y[i] = 1 if score + np.random.normal(0, 0.1) > 0.5 else 0
    
    # モデル訓練
    from sklearn.ensemble import RandomForestClassifier
    model = RandomForestClassifier(n_estimators=20, random_state=42)
    model.fit(X, y)
    
    # 反実仮想例の生成
    cf_explainer = CounterfactualExplainer(model, feature_names)
    
    # 拒否された申請者の例
    rejected_indices = np.where(y == 0)[0]
    if len(rejected_indices) > 0:
        rejected_example = X[rejected_indices[0]]
        print("拒否された申請者を承認に変更するには:")
        cf_result = cf_explainer.generate_counterfactual(
            rejected_example, target_class=1, max_changes=2
        )

# demonstrate_advanced_explanation()

活用事例・ユースケース

XAIは現代社会の様々な重要分野で活用されています。

医療診断支援

診断根拠の提示、治療選択の説明、医師の意思決定支援。

金融サービス

融資審査理由の説明、リスク評価根拠の提示、規制要件への対応。

自動運転

判断プロセスの透明化、安全性検証、責任の明確化。

刑事司法

再犯リスク評価の根拠説明、公正性確保、偏見検出。

人事・採用

選考理由の説明、公平性確保、法的コンプライアンス。

学ぶためのおすすめリソース

書籍

「Interpretable Machine Learning」（Christoph Molnar）、「Explanatory Model Analysis」（Przemyslaw Biecek）

オンラインコース

MIT「Introduction to Machine Learning」、Coursera「Explainable AI」

実装ライブラリ

LIME、SHAP、InterpretML、Captum、ELI5

論文

「Why Should I Trust You?」（LIME論文）、「A Unified Approach to Interpreting Model Predictions」（SHAP論文）

よくある質問（FAQ）

Q. 完璧な説明を提供することは可能か？
A. 完璧な説明は困難ですが、ユーザーの理解と信頼に十分な説明を提供することは可能です。

Q. 説明可能性と予測性能はトレードオフか？
A. 必ずしもそうではありませんが、場合によってはトレードオフが生じます。用途に応じた適切なバランスが重要です。

Q. どの説明手法を選択すべきか？
A. モデルの種類、データの性質、ユーザーの専門性、規制要件に基づいて適切な手法を選択することが重要です。

関連キーワード

解釈可能性、透明性、説明性、LIME、SHAP、アテンション

まとめ

Explainable AI（XAI）は、AIシステムの社会実装において不可欠な技術分野です。LIME、SHAP、アテンション機構、概念活性化ベクトルなど様々な手法により、モデルの判断プロセスを理解可能な形で説明できます。完璧な説明は困難でも、ユーザーのニーズに応じた適切なレベルの透明性を提供することで、AI技術への信頼性向上と責任ある活用が可能になります。今後も、より直感的で有用な説明手法の発展により、人間とAIの協働関係がさらに深化することが期待されます。