Update app.py

app.py

@@ -1,6 +1,12 @@
 import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
+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"
@@ -11,50 +17,190 @@ model = AutoModelForSequenceClassification.from_pretrained(REPO_ID, subfolder=MO
 model.config.id2label = {0: "hate_speech", 1: "offensive", 2: "neither", 3: "spam"}
 model.config.label2id = {"hate_speech": 0, "offensive": 1, "neither": 2, "spam": 3}
 
-def classify_text(texto):
-    inputs = tokenizer(
-        texto,
-        return_tensors="pt",
-        truncation=True,
-        padding="max_length",
-        max_length=128
-    ).to(model.device)
+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)[0].cpu().numpy()
-        pred = int(torch.argmax(logits, dim=1))
-
-    return {
-        "classe_prevista": model.config.id2label[pred],
-        "prob_hate_speech": float(probs[0]),
-        "prob_offensive": float(probs[1]),
-        "prob_neither": float(probs[2]),
-        "prob_spam": float(probs[3])
-    }
-
-def gradio_predict(text):
-    result = classify_text(text)
+        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 (
-        result["classe_prevista"],
-        f"{result['prob_hate_speech']:.4f}",
-        f"{result['prob_offensive']:.4f}",
-        f"{result['prob_neither']:.4f}",
-        f"{result['prob_spam']:.4f}"
+        text_en,
+        pred_label,
+        f"{probs[0]:.4f}",
+        f"{probs[1]:.4f}",
+        f"{probs[3]:.4f}",
+        f"{probs[2]:.4f}",
+        lime_fig,
+        shap_fig 
     )
 
-demo = gr.Interface(
-    fn=gradio_predict,
-    inputs=gr.Textbox(lines=5, label="Digite ou cole um texto"),
-    outputs=[
-        gr.Label(label="Classificação Prevista"),
-        gr.Textbox(label="Probabilidade (Hate Speech)"),
-        gr.Textbox(label="Probabilidade (Offensive)"),
-        gr.Textbox(label="Probabilidade (Neither)"),
-        gr.Textbox(label="Probabilidade (Spam)")
-    ],
-    title="Protótipo de Moderador de Conteúdo (HateBR + BERT)",
-    description="Ferramenta experimental utilizada na pesquisa para classificação de conteúdo em três classes: Hate Speech, Offensive, Neither e Spam."
-)
+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 três 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()