app.py

import torch
import numpy as np
import gradio as gr
from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
from deep_translator import GoogleTranslator
import lime
from lime.lime_text import LimeTextExplainer
import shap
import matplotlib.pyplot as plt

REPO_ID = "engsoftexperimental/modelos"
MODEL_NAME = "modelo_final_distilbert2"

tokenizer = AutoTokenizer.from_pretrained(REPO_ID, subfolder=MODEL_NAME)
model = AutoModelForSequenceClassification.from_pretrained(REPO_ID, subfolder=MODEL_NAME)

labels = ["hate_speech", "offensive", "neither", "spam"]
model.config.id2label = {0: labels[0], 1: labels[1], 2: labels[2], 3: labels[3]}
model.config.label2id = {labels[0]: 0, labels[1]: 1, labels[2]: 2, labels[3]: 3}

lime_explainer = LimeTextExplainer(class_names=labels)

pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, top_k=None)
shap_explainer = shap.Explainer(pipe)

def predictor_for_lime(texts):
    inputs = tokenizer(texts, return_tensors="pt", truncation=True, padding=True, max_length=128).to(model.device)
    with torch.no_grad():
        logits = model(**inputs).logits
        probs = torch.softmax(logits, dim=1).cpu().numpy()
    return probs

def translate_text(text, source_lang_name, languages_dict):
    if not text: return ""
    if source_lang_name == "Detectar Automaticamente":
        src = 'auto'
    else:
        src = languages_dict.get(source_lang_name, 'auto')
    try:
        translator = GoogleTranslator(source=src, target='en')
        return translator.translate(text)
    except Exception as e:
        return f"Erro: {str(e)}"

def generate_lime_plot(text_en, pred_idx):
    try:
        exp = lime_explainer.explain_instance(
            text_en, 
            predictor_for_lime, 
            num_features=6, 
            num_samples=100,
            labels=[pred_idx] 
        )
        fig = exp.as_pyplot_figure(label=pred_idx)
        plt.tight_layout()
        return fig
    except Exception as e:
        print(f"Erro LIME: {e}")
        return None

def generate_shap_plot(text_en, pred_idx):
    try:
        shap_values = shap_explainer([text_en])

        vals = shap_values.values
        
        if len(vals.shape) == 3:
            class_values = vals[0, :, pred_idx]
        elif len(vals.shape) == 2:
            class_values = vals[0, :]
        else:
            raise ValueError(f"Shape inesperado do SHAP: {vals.shape}")

        raw_data = shap_values.data[0]
        
        if hasattr(raw_data, 'tolist'):
            tokens = raw_data.tolist()
        else:
            tokens = list(raw_data)
            
        tokens = [str(t).strip() for t in tokens]

        if len(tokens) != len(class_values):
            min_len = min(len(tokens), len(class_values))
            tokens = tokens[:min_len]
            class_values = class_values[:min_len]

        explanation = shap.Explanation(
            values=class_values,
            feature_names=tokens
        )
        
        plt.close('all')
        plt.figure()
        
        shap.plots.bar(explanation, max_display=10, show=False)
        
        plt.tight_layout()
        return plt.gcf()
        
    except Exception as e:
        print(f"Erro CRÍTICO no SHAP: {e}")
        try:
            print(f"Debug Shape: {shap_values.values.shape}")
            print(f"Debug Tokens: {shap_values.data[0]}")
        except:
            pass
            
        plt.close('all')
        fig, ax = plt.subplots(figsize=(6, 2))
        ax.text(0.5, 0.5, "Não foi possível gerar a explicação SHAP\npara este texto específico.", 
                ha='center', va='center', fontsize=10, color='red')
        ax.axis('off')
        return fig

def process_pipeline(source_lang, text):
    try:
        LANGUAGES_DICT = GoogleTranslator().get_supported_languages(as_dict=True)
    except:
        LANGUAGES_DICT = {'portuguese': 'pt', 'english': 'en'}

    text_en = translate_text(text, source_lang, LANGUAGES_DICT)
    
    probs = predictor_for_lime([text_en])[0] 
    pred_idx = int(np.argmax(probs)) 
    pred_label = labels[pred_idx]
    
    lime_fig = generate_lime_plot(text_en, pred_idx)
    shap_fig = generate_shap_plot(text_en, pred_idx)

    return (
        text_en,
        pred_label,
        f"{probs[0]:.4f}",
        f"{probs[1]:.4f}",
        f"{probs[3]:.4f}",
        f"{probs[2]:.4f}",
        lime_fig,
        shap_fig 
    )

try:
    LANGUAGES_DICT = GoogleTranslator().get_supported_languages(as_dict=True)
except:
    LANGUAGES_DICT = {'portuguese': 'pt', 'english': 'en'}
language_options = ["Detectar Automaticamente"] + list(LANGUAGES_DICT.keys())

with gr.Blocks(title="Moderador AI + XAI") as demo:
    
    gr.Markdown("# Moderador de Conteúdo com IA Explicável (Modelo DistilBERT com Hate Speech Dataset + LIME/SHAP)")
    gr.Markdown("Ferramenta experimental utilizada na pesquisa para classificação de conteúdo em quatro classes: Hate Speech, Offensive, Spam e Neither.<br>O modelo foi treinado com dados no idioma inglês. Por isso, textos em outros idiomas serão traduzidos antes da classificação para garantir a precisão da IA.")
    gr.Markdown("Digite um texto. O sistema realiza a tradução automática, classifica e gera gráficos de explicabilidade.")

    with gr.Row():
        with gr.Column(scale=1):
            dd_lang = gr.Dropdown(choices=language_options, value="Detectar Automaticamente", label="Idioma de Origem")
            txt_input = gr.Textbox(lines=5, label="Texto Original", placeholder="Digite aqui...")
            btn_submit = gr.Button("Analisar e Explicar", variant="primary")
            
            gr.Markdown("### Tradução Utilizada")
            txt_translated = gr.Textbox(lines=3, label="Texto em Inglês (Base da Análise)", interactive=False)

        with gr.Column(scale=1):
            lbl_class = gr.Label(label="Classificação Final")
            with gr.Group():
                with gr.Row():
                    txt_p_hate = gr.Textbox(label="Prob. Hate Speech")
                    txt_p_offensive = gr.Textbox(label="Prob. Offensive")
                with gr.Row():
                    txt_p_spam = gr.Textbox(label="Prob. Spam")
                    txt_p_neither = gr.Textbox(label="Prob. Neither")

    gr.Markdown("---") 
    gr.Markdown("## Explicabilidade (XAI)")
    
    with gr.Tabs():
        with gr.TabItem("LIME Analysis"):
            gr.Markdown("""
                Mostra o peso das palavras para a classe vencedora. O LIME (Local Interpretable Model-agnostic Explanations) tenta explicar a decisão simulando pequenas variações no texto. Ele adota uma abordagem mais próxima da leitura humana, separando os termos por espaços em branco. Por isso, ele geralmente analisa palavras completas. O gráfico mostra as 6 palavras mais impactantes na decisão.
            """)
            
            gr.Markdown("""
                * <span style='color: green'>VERDE:</span> Palavras que aumentaram a probabilidade da classe escolhida.
                * <span style='color: red'>VERMELHO:</span> Palavras que diminuíram a confiança na escolha ou que apontaram para outra classe.
            """)
            
            plot_lime = gr.Plot(label="Gráfico LIME")
        
        with gr.TabItem("SHAP Analysis"):
            gr.Markdown("""
                Mostra a magnitude do impacto (Positivo/Negativo) de cada token para a classe prevista. O SHAP (SHapley Additive exPlanations) baseia-se na Teoria dos Jogos para calcular a contribuição matemática exata de cada fragmento. Ele utiliza o vocabulário fixo do modelo (DistilBERT). Isso significa que ele identifica o texto exatamente como a rede neural: palavras desconhecidas podem ser divididas em pedaços (ex: "Jackman" vira "Jack" + "man") e sinais de pontuação (aspas, vírgulas) são avaliados isoladamente.
            """)
             
            gr.Markdown("""
                * <span style='color: #ff0051'>ROSA (Positivo):</span> Tokens que empurraram a probabilidade da classe vencedora para cima. São as evidências fortes que confirmam a decisão final.
                * <span style='color: #008bfb'>AZUL (Negativo):</span> Tokens que empurraram a probabilidade para baixo. São elementos que fizeram o modelo duvidar ou considerar as outras categorias.
            """)
                        
            plot_shap = gr.Plot(label="Gráfico SHAP")

    btn_submit.click(
        fn=process_pipeline,
        inputs=[dd_lang, txt_input],
        outputs=[txt_translated, lbl_class, txt_p_hate, txt_p_offensive, txt_p_spam, txt_p_neither, plot_lime, plot_shap]
    )

demo.launch()