Explainability em Machine Learning: Abrindo a Black Box

Autumn 2025

Lembrando

  • Um AI interpretável descreve como chega à sua predição (modelo simples).
  • Um modelo white-box é aquele cuja estrutura interna e lógica são acessíveis para inspeção e análise.

Lembrando

  • Um AI interpretável descreve como chega à sua predição (modelo simples).

  • Um modelo white-box é aquele cuja estrutura interna e lógica são acessíveis para inspeção e análise.

  • Um AI explicável (explainable) descreve por que o modelo fez uma predição (modelos complexos).

  • Um modelo black-box é aquele cujo funcionamento interno é desconhecido, focando nas relações entre input e output.

Por que Precisamos de Explainability?

Por que Precisamos de Explainability?

  • Modelos de ML são cada vez mais usados em áreas críticas (saúde, direito, finanças).

Por que Precisamos de Explainability?

  • Modelos de ML são cada vez mais usados em áreas críticas (saúde, direito, finanças).
  • Muitos modelos de alto desempenho (por exemplo, redes neurais, ensembles) são black boxes.

Por que Precisamos de Explainability?

  • Modelos de ML são cada vez mais usados em áreas críticas (saúde, direito, finanças).
  • Muitos modelos de alto desempenho (por exemplo, redes neurais, ensembles) são black boxes.
  • Precisamos confiar, entender, e validar as decisões complexas do modelo.

O que é um Black Box Model?

O que é um Black Box Model?

  • Modelos complexos com alto poder preditivo mas baixa interpretability
  • Não conseguem explicar facilmente por que uma decisão foi tomada.

O que é Explainability?

O que é Explainability?

  • Capacidade de descrever a mecânica interna de um sistema em termos compreensíveis para humanos

O que é Explainability?

  • Capacidade de descrever a mecânica interna de um sistema em termos compreensíveis para humanos
  • Tipos:
    • Global explainability: entender o comportamento do modelo em geral

O que é Explainability?

  • Capacidade de descrever a mecânica interna de um sistema em termos compreensíveis para humanos
  • Tipos:
    • Global explainability: entender o comportamento do modelo em geral
    • Local explainability: explicar predições individuais

Técnicas de XAI populares

  • Model-specific vs. Model-agnostic

Técnicas de XAI populares

  • Model-specific vs. Model-agnostic
  • Métodos Global vs. Local

Model-specific vs. Model-agnostic

Model-specific vs. Model-agnostic

  • Os métodos model-specific aproveitam a estrutura interna de um modelo.

Model-specific vs. Model-agnostic

  • Os métodos model-specific aproveitam a estrutura interna de um modelo.

Por exemplo, você pode analisar os caminhos de decisão em uma decision tree ou os pesos em um modelo linear. Porém, esses métodos só funcionam para esse tipo específico de modelo.

Model-specific vs. Model-agnostic

  • Os métodos model-specific aproveitam a estrutura interna de um modelo.

Por exemplo, você pode analisar os caminhos de decisão em uma decision tree ou os pesos em um modelo linear. Porém, esses métodos só funcionam para esse tipo específico de modelo.

  • Os métodos model-agnostic tratam o modelo como uma black box: não dependem do funcionamento interno. Em vez disso, usam inputs e outputs para inferir como o modelo se comporta.

Model-specific vs. Model-agnostic

  • Os métodos model-specific aproveitam a estrutura interna de um modelo.

Por exemplo, você pode analisar os caminhos de decisão em uma decision tree ou os pesos em um modelo linear. Porém, esses métodos só funcionam para esse tipo específico de modelo.

  • Os métodos model-agnostic tratam o modelo como uma black box: não dependem do funcionamento interno. Em vez disso, usam inputs e outputs para inferir como o modelo se comporta.

Por exemplo, você pode analisar como as predições mudam em resposta a mudanças no input, sem precisar inspecionar a lógica interna.

Interpretando Black Box Models

Explicações tabulares:

Interpretando Black Box Models

Explicações textuais:

Interpretando Black Box Models

Explicações de imagem:

Interpretando Black Box Models

  • Métodos-chave para dados tabulares:
    • LIME (Local Interpretable Model-Agnostic Explanations)
    • SHAP (SHapley Additive exPlanations)

Interpretando Black Box Models

  • Métodos-chave para dados tabulares e textuais:
    • LIME (Local Interpretable Model-Agnostic Explanations)
    • SHAP (SHapley Additive exPlanations)

Interpretando Black Box Models

  • Métodos-chave para dados tabulares e textuais:
    • LIME (Local Interpretable Model-Agnostic Explanations)
    • SHAP (SHapley Additive exPlanations)
  • Métodos-chave para dados de imagem:
    • LIME (Local Interpretable Model-Agnostic Explanations)
    • SHAP (SHapley Additive exPlanations)
    • CAM (Class Activation MAps)

Local Interpretable Model-Agnostic Explanations (LIME)

  • O que é LIME?

Local Interpretable Model-Agnostic Explanations (LIME)

  • O que é LIME?
    • LIME é uma biblioteca python que explica a predição de qualquer classifier aprendendo um modelo interpretável localmente ao redor da predição

Local Interpretable Model-Agnostic Explanations (LIME)

  • O que é LIME?
    • LIME é uma biblioteca python que explica a predição de qualquer classifier aprendendo um modelo interpretável localmente ao redor da predição
  • Por que LIME é um bom explicador de modelos?

Local Interpretable Model-Agnostic Explanations (LIME)

  • O que é LIME?
    • LIME é uma biblioteca python que explica a predição de qualquer classifier aprendendo um modelo interpretável localmente ao redor da predição
  • Por que LIME é um bom explicador de modelos?
    • Interpretável por não especialistas
    • Fidelidade local (replica o comportamento do modelo na vizinhança da instância sendo predita)
    • Model agnostic (não faz nenhuma suposição sobre o modelo)
    • Perspectiva global (quando usado em um conjunto representativo, LIME pode dar uma intuição global do modelo)

Ref: Sharma (2020)

Como o LIME funciona?

  • Explica a predição de qualquer classifier black-box aproximando-o localmente com um modelo interpretável.

  • Ideias-chave:

    • Foca em uma única predição (explicação local).
    • Cria amostras perturbadas ao redor da instância de input.
    • Observa como as predições mudam.
    • Treina um modelo simples, interpretável (por exemplo, regressão linear) para imitar o modelo complexo naquela região local.

Função Objetivo

LIME resolve o seguinte problema de otimização:

\(\epsilon(x) = \underset{g \in G}{\mathrm{argmin }} \text{ } \mathcal{L}(f, g, \pi_x) + \Omega(g)\)

Função Objetivo

LIME resolve o seguinte problema de otimização:

\(\epsilon(x) = \underset{g \in G}{\mathrm{argmin }} \text{ } \mathcal{L}(f, g, \pi_x) + \Omega(g)\)

Onde:

  • \(x\) é a instância de input a ser explicada.
  • f: o modelo complexo (black-box) original.
  • g: o modelo substituto interpretável (por exemplo, um modelo linear)
  • G: a família de modelos interpretáveis.

Função Objetivo

LIME resolve o seguinte problema de otimização:

\(\epsilon(x) = \underset{g \in G}{\mathrm{argmin }} \text{ } \mathcal{L}(f, g, \pi_x) + \Omega(g)\)

Onde:

  • \(\mathcal{L}(f, g, \pi_x)\) é a perda de fidelidade local: quão bem g aproxima f ao redor de x, ponderada por \(\pi_x\) (perda de erro quadrático).
  • \(\pi_x(z)\): medida de proximidade — quão próxima a amostra perturbada z está de x (tipicamente um kernel exponencial).
  • \(\Omega(g)\): penalização de complexidade para garantir interpretability (por exemplo, limitar o número de coeficientes não nulos), geralmente ridge ou lasso.

LIME: modelo substituto (surrogate)

Um surrogate model é um modelo mais simples e interpretável que é treinado para aproximar as predições de um modelo mais complexo (black-box) — especialmente em uma região específica do espaço de input.

LIME: modelo substituto (surrogate)

Um surrogate model é um modelo mais simples e interpretável que é treinado para aproximar as predições de um modelo mais complexo (black-box) — especialmente em uma região específica do espaço de input.

  • O surrogate model tipicamente é um modelo linear ou uma decision tree.
  • Não é usado para fazer predições reais em produção.
  • Seu único propósito é ajudar a explicar como o modelo black-box se comporta ao redor de um input específico.

LIME: modelo substituto (surrogate)

Um surrogate model é um modelo mais simples e interpretável que é treinado para aproximar as predições de um modelo mais complexo (black-box) — especialmente em uma região específica do espaço de input.

LIME: modelo substituto (surrogate)

Um surrogate model é um modelo mais simples e interpretável que é treinado para aproximar as predições de um modelo mais complexo (black-box) — especialmente em uma região específica do espaço de input.

Exemplo de LIME em Python

Primeiro importamos as bibliotecas relevantes:

import pandas as pd, numpy as np
from sklearn import datasets
from sklearn.decomposition import PCA
from matplotlib import pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score
from sklearn.model_selection import train_test_split
import lime, lime.lime_tabular, shap

Exemplo de LIME em Python

Lembre-se do dataset Iris, que contém flores que podem ser classificadas em 3 subespécies com base em 4 características:

data = datasets.load_iris()

X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

X[0:3]
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2

Exemplo de LIME em Python

Ignoramos a Classe 0 por enquanto (veremos o porquê em breve), e dividimos os dados em um training set (80%) e test set (20%):

#Ignoring one of the three classes

X = X[y != 0]
y = y[y != 0]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)

Exemplo de LIME em Python

Treinamos um random forest classifier no nosso training set, e geramos predições para nosso test set:

classifier = RandomForestClassifier(random_state=42)

classifier.fit(X_train, y_train)

predicted = classifier.predict(X_test)

pre  = precision_score(y_test, predicted)
rec  = recall_score(y_test, predicted)
acc = accuracy_score(y_test, predicted)

print("Precisão: ", pre)
print("Recall: ", rec)
print("Acurácia: ", acc)
Precisão:  1.0
Recall:  0.9166666666666666
Acurácia:  0.95

Exemplo de LIME em Python

Usamos o lime para criar um explainer baseado no nosso training set, e geramos uma explicação para a décima amostra do nosso test set:

explainer1 = lime.lime_tabular.LimeTabularExplainer(X_train.values,
                                                   feature_names=X_train.columns.values.tolist(),
                                                   class_names=['class 1', 'class 2'],
                                                   verbose=True,
                                                   mode='classification',
                                                   random_state=42)

lime_values = explainer1.explain_instance(X_test.values[10], classifier.predict_proba, num_features=4)
##some lime_values properties intercept, local_pred, score
Intercept 0.6704191905472919
Prediction_local [0.233346]
Right: 0.22

Exemplo de LIME em Python

  • Vemos que essa explicação tem três partes:
    • À esquerda, vemos que o classifier estimou uma chance de 78% de que a amostra fosse da Classe 1, e 22% de que fosse da Classe 2
    • No centro, vemos que o comprimento e a largura da pétala aumentaram a probabilidade de que a amostra fosse da Classe 1, enquanto o comprimento e a largura da sépala aumentaram a probabilidade de que fosse da Classe 2. O comprimento e a largura da pétala também tiveram maior influência no respectivo aumento do que o comprimento e a largura da sépala
    • À direita, vemos os valores reais de LIME para cada característica. A cor de cada linha corresponde à classe pela qual aquela característica está "votando"
from IPython.display import display, HTML  # lime still imports from the removed IPython.core.display path
display(HTML(lime_values.as_html()))

Resumo

LIME para dados Tabulares:

Resumo

LIME para dados de Texto:

Resumo

LIME para dados de Imagem:

Class Activation Maps (CAM)

  • O que é CAM?

Class Activation Maps (CAM)

  • O que é CAM?
    • CAM é uma técnica usada para visualizar quais partes de uma imagem de input (tipicamente em CNNs) são importantes para uma predição de classe em particular.

Class Activation Maps (CAM)

  • O que é CAM?
    • CAM é uma técnica usada para visualizar quais partes de uma imagem de input (tipicamente em CNNs) são importantes para uma predição de classe em particular.
  • Por que CAM é um bom explicador de modelos?

Class Activation Maps (CAM)

  • O que é CAM?
    • CAM é uma técnica usada para visualizar quais partes de uma imagem de input (tipicamente em CNNs) são importantes para uma predição de classe em particular.
  • Por que CAM é um bom explicador de modelos?
    • Interpretabilidade visual por não especialistas
    • Explicações específicas por classe
    • Não precisa retreinar o modelo
    • Model agnostic (não faz nenhuma suposição sobre o modelo)
    • Perspectiva local (CAM gera diferentes activation maps para cada classe predita, ajudando a entender por que uma certa classe foi escolhida em vez de outras).

Como o CAM funciona?

  • Só funciona para arquiteturas CNN que terminam em Global Average Pooling (GAP) + Fully Connected Layer.

Como o CAM funciona?

  • Só funciona para arquiteturas CNN que terminam em Global Average Pooling (GAP) + Fully Connected Layer.
  • Cada feature map é espacialmente promediado e ponderado por pesos específicos da classe para gerar um heatmap.

Função Objetivo

CAM calcula as características mais importantes seguindo a equação:

\(CAM_c = \sum_k w_k^c F_k\)

Função Objetivo

CAM calcula as características mais importantes seguindo a equação:

\(CAM_c = \sum_k w_k^c F_k\)

Onde:

  • \(CAM_c\): é o activation map para a classe c.
  • \(w_k^c\): peso para a classe c a partir da camada final fully connected correspondente ao feature map k.
  • \(F_k\): é o GAP aplicado sobre todo o feature map \(F_k\). Global Average Pooling: \(F_k=\frac{1}{Z} \sum_i \sum_j A_k(i,j)\) onde Z é o número de pixels no feature map. \(A_k\): é o feature map k de uma camada de convolução selecionada.

CAM: visão geral

CAM: visão geral

Limitação: requer uma arquitetura específica (GAP + camada FC) e não pode ser aplicada diretamente à maioria das CNNs pré-treinadas.

Grad-CAM (Gradient-weighted CAM)

  • O que é Grad-CAM?

Grad-CAM (Gradient-weighted CAM)

  • O que é Grad-CAM?
    • Grad-CAM é uma extensão mais geral e flexível do CAM. Usa os gradientes de qualquer classe alvo fluindo para uma camada convolucional para produzir um heatmap, mostrando quais regiões da imagem influenciam a predição de classe.

Grad-CAM (Gradient-weighted CAM)

  • O que é Grad-CAM?
    • Grad-CAM é uma extensão mais geral e flexível do CAM. Usa os gradientes de qualquer classe alvo fluindo para uma camada convolucional para produzir um heatmap, mostrando quais regiões da imagem influenciam a predição de classe.
  • Por que grad-CAM é um explicador de modelos melhor?

Grad-CAM (Gradient-weighted CAM)

  • O que é Grad-CAM?
    • Grad-CAM é uma extensão mais geral e flexível do CAM. Usa os gradientes de qualquer classe alvo fluindo para uma camada convolucional para produzir um heatmap, mostrando quais regiões da imagem influenciam a predição de classe.
  • Por que grad-CAM é um explicador de modelos melhor?
    • Funciona com qualquer arquitetura baseada em CNN, incluindo ResNet, VGG, etc.
    • Pode ser usado para explicar tarefas de classification e regression (com adaptação)
    • Amplamente usado para debugging visual de modelos, construção de confiança, e detecção de viés.

Grad-CAM: visão geral

Grad-CAM

Calcula as características mais importantes usando os gradientes de backpropagation:

\(\mathcal{L}_c ^{Grad-CAM} = ReLU(\sum_k w^c _k A_k)\)

Onde:

  • \(\mathcal{L}_c ^{Grad-CAM}\): o heatmap de Grad-CAM para a classe c.
  • \(A_k\): feature map k de uma camada de convolução selecionada.
  • \(w^c_k\): peso de importância do feature map k para a classe c, calculado por: \(w^c_k = \frac{1}{Z} \sum_i \sum_j \frac{\partial y^c}{\partial A_k(i,j)}\) onde Z é o número de pixels no feature map.
  • \(y^c\): pontuação para a classe c (antes do softmax). \(y^c = \sum_k w^c_k \sum_i \sum_j A_k(i,j)\)

Grad-CAM++

Melhora o Grad-CAM ao capturar múltiplas ocorrências de objetos na mesma imagem. Usa gradientes de ordem superior para dar uma melhor localização espacial.

Equação:

\(\mathcal{L}_c ^{Grad-CAM++} = ReLU(\sum_k w^c_k A_k)\)

Onde:

  • \(w^c_k\): peso de importância do feature map k para a classe c, calculado por: \(w^c_k = \sum_i \sum_j \alpha^{c}_k(i,j) ReLU(\frac{\partial y^c}{\partial A_k(i,j)})\) Onde \(\alpha^{c}_k(i,j)\) é o coeficiente de ponderação dos gradientes por pixel para a classe c e o feature map convolucional \(A_k\). \(\alpha^{c}_k(i,j) = \frac{(\frac{\partial S^c}{\partial A^k(i,j)})^2}{ 2 (\frac{\partial S^c}{\partial A^k(i,j)})^2 + \sum_a \sum_b A_k(a,b) (\frac{\partial S^c}{\partial A^k(i,j)})^3}\)

  • \(S^c\): é a pontuação da penúltima camada para a classe c, calculada por: \(S^c=Ln(y^c)\)

Score-CAM

Evita gradientes completamente. Em vez disso, cada activation map é usado como uma máscara sobre a imagem de input, e a pontuação de output do modelo é usada para medir a importância.

Equação:

\(\mathcal{L}_c ^{Score-CAM} = ReLU(\sum_k w^c_k A_k\))

Onde:

  • \(w^c_k\) é o Channel-wise Increase of Confidence (CIC), calculado por: \(w^c_k = f(x \odot Upsample(A_k)) - f(x_{baseline})\) onde \(f(x)\) é a pontuação do modelo para a classe c quando o input está mascarado. \(\odot\): multiplicação elemento a elemento \(x_{baseline}\): referência não informativa (por exemplo, uma imagem preta)

Ablation-CAM

Desabilita (ablate) cada feature map um por um e mede a queda na pontuação de classe. Quanto maior a queda, mais importante o feature map.

Equação:

\(\mathcal{L}_c ^{Ablation-CAM} = ReLU(\sum_k w^c_k A_k\))

Onde:

  • \(w^c_k\): fração do peso de importância da queda no activation score da classe c quando o feature map \(A_k\) é removido. É calculado por: \(w^c_k = \frac{y^c - y^c_k}{ ||A_k|| }\) Onde \(y^c_k\) é o valor da função para a ausência da unidade k e atua como linha de base para \(A_k\).

Layer-CAM

Em vez de promediar os gradientes (como o Grad-CAM), usa o produto elemento a elemento de activation e gradient — preservando a informação espacial.

Equação:

\(\mathcal{L}_c ^{Layer-CAM} = ReLU(\sum_k \hat{A}_k\))

Onde:

  • \(\hat{A}_k\): é a combinação linear ao longo da dimensão de canal para obter o class activation map k. Onde \(\hat{A}_k = \sum_i \sum_j w^c_k(i, j) A_k(i,j)\) O que significa que primeiro multiplica o valor de activation de cada localização no feature map por um peso. Além disso, \(w^c_k(i, j) = ReLU( \frac{\partial y^c}{\partial A_k(i,j)} )\) é o peso da localização espacial \((i, j)\) no k-ésimo feature map.

Eigen-CAM

Aplica PCA aos feature maps de uma camada convolucional e usa o componente principal mais importante como o saliency map.

Equação:

\(\mathcal{L}_c ^{Eigen-CAM} = v^T_1 A_k'\)

Onde:

  • \(A_k'\) é o resultado da matriz de covariância \(\Sigma = A'_k A_k^T\).
  • \(v^T_1\) é a transposta do primeiro componente principal de \(A_k\)

XGrad-CAM

XGrad-CAM melhora o Grad-CAM modificando como os pesos de importância dos feature maps são calculados.

Enquanto o Grad-CAM usa global average pooling (GAP) dos gradientes para obter um peso para cada feature map (ou seja, canal), o XGrad-CAM incorpora as próprias ativações do feature map na fórmula de ponderação.

Isso significa que ele calcula a importância do canal com base em como tanto os gradientes quanto as ativações contribuem para o output — levando a visualizations mais nítidas e focadas.

Equação:

\(\mathcal{L}_c ^{XGrad-CAM} = ReLU(\sum_k w^c_k A_k\))

Onde:

  • \(w^c_k\) é a importância do modelo. Onde \(w^c_k = \sum_i \sum_j A_k(i, j) \frac{\partial y^c}{\partial A^k(i,j)})\)
  • \(A_k(i, j)\) é o valor do activation map na localização espacial \((i,j)\) para o canal k.

Tem mais!!

  • Saliency Maps: destaca os pixels da imagem que mais influenciam o output calculando o gradiente do class score em relação à imagem de input.
  • Integrated gradients: calcula a média dos gradientes conforme o input muda de uma linha de base (por exemplo, uma imagem preta) até a imagem real.
  • Occlusion Sensitivity: mascara sistematicamente trechos da imagem e observa como a predição muda.
  • RISE (Randomized Input Sampling for Explanation): gera muitas máscaras aleatórias, passa as imagens mascaradas para o modelo, e pondera as máscaras pelo output do modelo.
  • SmoothGrad: faz a média de muitos saliency maps ruidosos criados adicionando ruído Gaussiano ao input.
  • etc.

Referências

Sharma, Abhishek. 2020. «Decrypting your machine learning model using lime». Medium. Towards Data Science. https://towardsdatascience.com/decrypting-your-machine-learning-model-using-lime-5adc035109b5.