Interpretabilidade de IA: SHAP, LIME e Integrated Gradients na prática

Por que interpretabilidade deixou de ser opcional

Um modelo que prevê com precisão e um modelo cujo raciocínio você consegue explicar são conquistas diferentes — e só uma delas ainda é opcional. Um modelo de churn que marca um cliente fiel de cinco anos como alto risco não é só um caso curioso se ninguém na equipe sabe dizer o porquê: é uma decisão que ninguém consegue defender, para o gestor, para o cliente ou, cada vez mais, para o regulador. O Artigo 13 do EU AI Act passou a exigir que sistemas de IA de alto risco forneçam transparência suficiente para que quem os implanta consiga interpretar as saídas — o que tirou a interpretabilidade do terreno do “bom ter” e a colocou como requisito real de implantação.

Neste guia, você vai aprender três técnicas concretas para extrair respostas reais de um modelo que, de outra forma, seria uma caixa-preta: SHAP, LIME e Integrated Gradients. Um único exemplo percorre o texto inteiro — um modelo de previsão de churn de clientes, primeiro uma árvore com gradient boosting, depois uma pequena rede neural treinada nos mesmos dados — para que cada técnica explique o mesmo problema subjacente.

O que interpretabilidade realmente significa

Interpretabilidade de modelo é o grau em que um humano consegue entender por que um modelo produziu uma saída específica, não apenas que produziu. Essa definição se divide em duas perguntas constantemente confundidas:

• Interpretabilidade global: como o modelo se comporta no geral — quais features importam mais e em que direção, no conjunto de dados inteiro.
• Interpretabilidade local: por que o modelo fez esta previsão, para este cliente, agora. Um modelo pode ser razoavelmente interpretável globalmente (“tenure e duração do contrato importam em média”) e ainda ser um mistério local.

Por que o método tradicional não escala

Pergunte a um cientista de dados como explicar um modelo de árvore e a primeira resposta costuma ser a mesma: puxe o atributo .feature_importances_ do scikit-learn ou leia os coeficientes de um modelo linear. É rápido e não exige biblioteca extra. Mas tem limites reais: é global por construção (não diz nada sobre um cliente específico), pode ser viesado para features de alta cardinalidade, e simplesmente não existe para modelos que não expõem esse atributo — redes neurais, ensembles mistos ou APIs caixa-preta.

Pré-requisitos

Instale com pip install shap lime scikit-learn pandas numpy torch captum. Todos os trechos importam de um arquivo compartilhado (churn_data.py) que gera um dataset sintético de churn e treina o modelo de árvore. O rótulo de churn não é aleatório: ele vem de uma relação logística em que tenure curto, contrato mensal e muitos tickets de suporte aumentam a probabilidade de churn — o que permite julgar se cada explicação é plausível, e não apenas plausível-sonante.

Método 1: SHAP (SHapley Additive exPlanations)

O SHAP se baseia na teoria dos jogos cooperativos: trate cada feature como um jogador, o resultado do modelo como o pagamento, e calcule a fatia justa de cada feature calculando a média de sua contribuição marginal em todas as combinações possíveis. O resultado é um método matematicamente consistente que produz explicações globais e locais. É a biblioteca de interpretabilidade mais adotada em produção (versão 0.52.0, de maio de 2026).

import shap
import numpy as np
import pandas as pd
from churn_data import model, X_test, FEATURES

explainer = shap.TreeExplainer(model)
shap_values = explainer(X_test)

# Global: contribuição absoluta média por feature
mean_abs = np.abs(shap_values.values).mean(axis=0)
global_importance = pd.Series(mean_abs, index=FEATURES).sort_values(ascending=False)

Rodando no modelo de churn, o ranking muda de verdade em relação ao método tradicional: contract_is_monthly sobe de quarto para segundo lugar, enquanto support_tickets cai de terceiro para quarto — dois métodos razoáveis discordando sobre o quanto uma feature importa. A explicação local é onde o SHAP brilha: para um cliente com 53 meses de tenure mas 5 tickets recentes, support_tickets contribui +2,81 para o log-odds de churn (o maior empurrão), enquanto tenure puxa só −0,58. Os dois efeitos não se cancelam, e a probabilidade prevista chega a 89,5% de risco. É uma resposta específica e defensável.

Método 2: LIME (Local Interpretable Model-agnostic Explanations)

O LIME adota uma abordagem diferente: em vez de calcular atribuição exata, gera uma nuvem de amostras perturbadas ao redor de uma previsão, pondera pela proximidade do input original e ajusta um modelo simples (tipicamente linear) nessa vizinhança local. O resultado aproxima o comportamento do modelo real perto daquela previsão, sem precisar entender a estrutura interna dele.

import pandas as pd
from lime.lime_tabular import LimeTabularExplainer
from churn_data import model, X_train, X_test, FEATURES

customer = X_test.iloc[0]
explainer = LimeTabularExplainer(
    X_train.values, feature_names=FEATURES,
    class_names=["stayed", "churned"], mode="classification", random_state=42,
)
def predict_proba_df(x):
    return model.predict_proba(pd.DataFrame(x, columns=FEATURES))

explanation = explainer.explain_instance(customer.values, predict_proba_df, num_features=5)

Para o mesmo cliente, o LIME conta a mesma história do SHAP por um mecanismo completamente diferente — support_tickets > 2.00 é o maior peso positivo para churn, enquanto o contrato anual e o tenure longo puxam para o outro lado. Onde o LIME ganha de verdade é velocidade: não precisa raciocinar sobre a estrutura completa do modelo, o que o torna prático em sistemas em tempo real com orçamento apertado de latência. O custo é real: como depende de perturbações aleatórias, rodar duas vezes pode gerar pesos levemente diferentes — uma instabilidade que a base de teoria dos jogos do SHAP não tem.

Método 3: Integrated Gradients

Os dois primeiros tratam o modelo como caixa-preta, o que os faz funcionar em qualquer coisa, mas os impede de explorar a estrutura interna quando ela existe. O Integrated Gradients é feito para modelos diferenciáveis (como redes neurais): percorre um caminho em linha reta de um input de baseline neutro até o input real e acumula o gradiente da saída em relação a cada feature ao longo do caminho. O gradiente acumulado diz quanto o valor real de cada feature, relativo ao baseline, impulsionou a previsão final.

import torch
from captum.attr import IntegratedGradients
from churn_data import X_test, FEATURES

net.eval()
input_tensor = torch.tensor(customer_normalized, dtype=torch.float32).unsqueeze(0)
input_tensor.requires_grad_()
baseline = torch.zeros_like(input_tensor)  # cliente "médio" após normalização
ig = IntegratedGradients(net)
attributions, delta = ig.attribute(input_tensor, baseline,
                                   return_convergence_delta=True, n_steps=200)

O return_convergence_delta é um teste de sanidade que vale usar sempre: ele mede se a soma das atribuições bate com a diferença real entre a saída no input real e no baseline, e deve ficar perto de zero. Neste caso, veio em 0,0006 — confirmando que a atribuição é confiável. O Integrated Gradients conta a mesma história uma terceira vez: support_tickets tem a maior atribuição positiva, enquanto tenure e contrato puxam para “ficar”. Três métodos estruturalmente diferentes convergindo para a mesma explicação é a confirmação mais forte que as ferramentas de interpretabilidade podem oferecer de que a explicação reflete algo real.

Qual escolher?

Alcance o SHAP quando estiver trabalhando com modelos de árvore e quiser o quadro global e explicações locais robustas de um único método consistente. Alcance o LIME quando computação ou latência estiverem apertadas, aceitando que a explicação pode variar um pouco entre execuções. Alcance o Integrated Gradients no momento em que o modelo for uma rede neural — é o único dos três feito para usar essa estrutura em vez de tratar o modelo como função opaca.

Erros comuns e como resolver

• ❌ Interpretabilidade = acurácia — um modelo preciso pode ser totalmente opaco. Use as duas métricas separadamente.
• ❌ Confiar só em feature_importances_ — é global, viesado para alta cardinalidade e não cobre redes neurais. Complemente com explicação local.
• ❌ SHAP e LIME divergem e você escolhe o que gosta — divergência forte é sinal para investigar, não para escolher o resultado conveniente.
• ❌ Ignorar o convergence_delta — se não ficar perto de zero no Integrated Gradients, a atribuição é ruído.
• ❌ Baseline arbitrário no Integrated Gradients — um baseline mal escolhido distorce a atribuição; use o “cliente médio” normalizado.

Perguntas frequentes

Preciso dos três métodos? Não. Eles se sobrepõem; escolha pelo seu modelo e restrição. Árvore → SHAP; latência → LIME; rede neural → Integrated Gradients.

Interpretabilidade substitui auditoria? Não. É uma ferramenta de explicação, não de garantia de robustez ou justiça. O EU AI Act exige transparência, mas a conformidade envolve mais camadas.

SHAP funciona em qualquer modelo? O TreeSHAP é específico de árvore e rápido; o KernelSHAP funciona em qualquer modelo, mas custa muitas avaliações por explicação.

Por que LIME muda entre execuções? Porque amostra perturbações aleatórias. Fixe o random_state para reprodutibilidade.

Isso é só para dados tabulares? Os três se estendem a imagens e texto, com variantes específicas (DeepSHAP, LimeImageExplainer, atribuição em embeddings).

Para fechar

O score tradicional de importância não está errado; está incompleto — um número global que não explica uma previsão, não pode ser confiado uniformemente entre tipos de feature e não existe para uma fatia crescente dos modelos que as equipes realmente implantam. À medida que regulação e cobrança por transparência avançam, construir o hábito de explicar uma previsão antes que um regulador, um cliente confuso ou a própria equipe force a pergunta é o diferencial que separa um modelo que você pode usar de um modelo que você precisa justificar.