Desvendando a caixa-preta: Por que nossos modelos de IA agem assim? (E por que você deveria se importar!)

import pandas as pd
import shap
from lime.lime_text import LimeTextExplainer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression

# --- Seção de Preparação de Dados e Treinamento do Modelo ---
# 1. Preparando os Dados (apenas um exemplo simples)
# Criamos um pequeno conjunto de dados de textos e seus respectivos sentimentos.
# Usamos 1 para sentimento positivo e 0 para negativo.
data = {
    'text': [
        "A IA é incrível e vai mudar o mundo!",
        "Esse modelo é muito lento e cheio de bugs.",
        "Adorei o artigo do FlipBits, super claro!",
        "Que decepção, a performance está horrível.",
        "Machine Learning é fascinante e promissor."
    ],
    'sentiment': [1, 0, 1, 0, 1] # 1 para positivo, 0 para negativo
}
df = pd.DataFrame(data) # Convertemos o dicionário em um DataFrame do Pandas

# 2. Treinando um Modelo Simples de Classificação de Texto
# Inicializamos o TF-IDF Vectorizer. Ele converte os textos em vetores numéricos
# (representações esparsas) que o modelo de Machine Learning consegue entender.
# "fit_transform" aprende o vocabulário e transforma os textos.
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(df['text']) # Variáveis de entrada (textos vetorizados)
y = df['sentiment'] # Variável de saída (sentimento)

# Criamos e treinamos um modelo de Regressão Logística, que é um classificador linear.
# O `random_state` garante que os resultados sejam reproduzíveis.
model = LogisticRegression(random_state=42)
model.fit(X, y) # Treinamos o modelo com os dados vetorizados e os sentimentos

# Definimos os nomes das classes para facilitar a interpretação dos resultados.
class_names = ['Negativo', 'Positivo']

# Obtemos os nomes das features (palavras) do vetorizador.
# Isso será útil para associar as contribuições de SHAP e LIME às palavras.
feature_names = vectorizer.get_feature_names_out()

# --- Seção de Teste com LIME ---
print("--- Teste LIME ---")

# 3. Utilizando o LIME para Explicar uma Predição Específica
# Inicializamos o LimeTextExplainer. Ele é projetado especificamente para explicar
# classificadores de texto e exige os nomes das classes.
explainer_lime = LimeTextExplainer(class_names=class_names)

# Escolhemos um texto específico para o LIME explicar.
text_to_explain_lime = "Adorei o artigo do FlipBits, super claro!"

# Definimos a função de predição de probabilidades para o LIME.
# O LIME passa textos (perturbados) para essa função.
# Portanto, a função precisa vetorizar internamente os textos antes de passá-los ao modelo.
def predict_proba_func_lime(texts):
     # Garante que 'texts' é uma lista, mesmo que uma única string seja passada.
     if isinstance(texts, str):
        texts = [texts]
     # Converte cada item da lista para string para evitar erros no vetorizador,
     # caso o LIME passe algum tipo de dado inesperado (ex: numpy array em versões mais antigas).
     processed_texts = [str(text) for text in texts]
     # Retorna as probabilidades de cada classe (Negativo, Positivo) para os textos.
     return model.predict_proba(vectorizer.transform(processed_texts))

# Geramos a explicação LIME para a instância de texto escolhida.
# - text_to_explain_lime: o texto a ser explicado.
# - predict_proba_func_lime: a função de predição do nosso modelo.
# - num_features: o número de palavras mais importantes a serem destacadas na explicação.
# - labels: a(s) classe(s) para as quais queremos a explicação (aqui, a classe Positivo, índice 1).
explanation_lime = explainer_lime.explain_instance(
    text_to_explain_lime,
    predict_proba_func_lime,
    num_features=5,
    labels=[1]
)

# Exibimos os resultados do LIME no console.
print(f"Texto original (LIME): '{text_to_explain_lime}'")
# Predizimos e exibimos o sentimento original do texto.
print(f"Predição do modelo (LIME): {class_names[model.predict(vectorizer.transform([text_to_explain_lime]))[0]]}")
print("\nExplicação do LIME para a classe Positivo:")
# Iteramos sobre as palavras mais importantes e seus pesos (contribuições) para a classe Positivo.
for word, weight in explanation_lime.as_list(label=1):
    print(f" - Palavra '{word}': Peso {weight:.4f}")

# Separador visual para diferenciar as seções LIME e SHAP.
print("\n" + "="*40 + "\n")

# Para visualização interativa do LIME em ambientes como Jupyter Notebook.
# Comenta-se para evitar erro se não estiver em um notebook.
# explanation_lime.show_in_notebook(text=True)

# --- Seção de Teste com SHAP ---
print("--- Teste SHAP ---")

# Para modelos lineares como LogisticRegression, o SHAP oferece o LinearExplainer,
# que é mais eficiente e preciso do que o KernelExplainer (que é mais geral, mas computacionalmente mais caro).
# O LinearExplainer é inicializado com o modelo treinado e os dados de treinamento (vetorizados)
# para estabelecer um "background" ou "baseline".
background_data_dense = X.toarray()
explainer_shap = shap.LinearExplainer(model, background_data_dense)

# Escolhemos o mesmo texto para explicar com SHAP, garantindo consistência.
idx_to_explain = 2
text_to_explain_shap = df['text'][idx_to_explain]

# Antes de passar a instância para o `explainer_shap.shap_values`,
# precisamos vetorizá-la usando o mesmo `vectorizer` que foi usado para treinar o modelo.
instance_to_explain_vectorized = vectorizer.transform([text_to_explain_shap])

# Convertemos a matriz esparsa (Sparse Matrix) da instância única para um array NumPy denso.
# Isso é crucial porque o LinearExplainer do SHAP espera dados densos para cálculos.
instance_to_explain_dense = instance_to_explain_vectorized.toarray()

# Calculamos os valores SHAP para a instância vetorizada e densa.
# Para o LinearExplainer e um modelo de classificação com múltiplas classes,
# 'shap_values' geralmente retorna um array com a forma (n_samples, n_classes, n_features)
# ou (n_features, n_classes) para uma única amostra.
# Aqui, como estamos explicando uma única amostra e o modelo tem duas classes,
# ele retorna uma lista de arrays, um array para cada classe.
# O `shap_values[1]` conterá as contribuições para a classe Positivo.
shap_values = explainer_shap.shap_values(instance_to_explain_dense)

print(f"Texto original (SHAP): '{text_to_explain_shap}'")
# Predizer e exibir o sentimento original do texto usando o modelo.
print(f"Predição do modelo (SHAP): {class_names[model.predict(vectorizer.transform([text_to_explain_shap]))[0]]}")
print("\nValores SHAP para a classe Positivo:")

# Acessamos os valores SHAP para a classe positiva (índice 1).
# `shap_values[1][0]` acessa o primeiro (e único) conjunto de contribuições
# para a classe positiva da amostra atual.
shap_contributions = list(zip(feature_names, shap_values[0, :]))

# Ordenamos as contribuições SHAP pela magnitude absoluta para ver as palavras mais influentes,
# independentemente se contribuem positiva ou negativamente.
shap_contributions.sort(key=lambda x: abs(x[1]), reverse=True)

print("Maiores contribuições SHAP para a classe Positivo (mapeado para features TF-IDF):")
# Exibimos as 10 maiores contribuições.
for word, contribution in shap_contributions[:10]:
     print(f" - Palavra/Feature '{word}': Contribuição {contribution:.4f}")

# --- Visualização Interativa SHAP (para Jupyter Notebooks) ---
# Inicializa o JavaScript necessário para as visualizações interativas do SHAP.
# Comenta-se para evitar erro se não estiver em um notebook.
# shap.initjs()

# Calcula o valor esperado (expected_value) para a classe positiva.
# Este é o valor base para a predição da classe positiva, ou seja,
# a probabilidade média da classe positiva nos dados de treinamento.
# expected_value_positive_class = model.predict_proba(X).mean(axis=0)[1]

# Gera o gráfico de força (force plot) do SHAP.
# Este gráfico mostra como cada feature empurra a previsão da "expected_value"
# para o valor final da previsão da instância.
# - expected_value_positive_class: O valor base da previsão para a classe positiva.
# - shap_values[1][0]: As contribuições SHAP para a instância atual, para a classe positiva.
# - features=instance_to_explain_dense[0]: Os valores das features da instância explicada.
# - feature_names: Os nomes das features (palavras) para rotular o gráfico.
# Comenta-se para evitar erro se não estiver em um notebook.
# shap.force_plot(expected_value_positive_class, shap_values[1][0], features=instance_to_explain_dense[0], feature_names=feature_names)