Add all relevant files

app.py

@@ -0,0 +1,292 @@
+import gradio as gr
+
+from models.bow import BowModel
+from models.bertimbau import BertimbauModel
+
+
+# ======================================================
+# Carrega modelos
+# ======================================================
+
+bow_model = BowModel()
+bert_model = BertimbauModel()
+
+
+# ======================================================
+# Inferência
+# ======================================================
+
+def predict(text):
+
+    text = text.strip()
+
+    if len(text) == 0:
+        return (
+            "",
+            {},
+            "",
+            "",
+            {},
+            ""
+        )
+
+    # -------------------------
+    # BoW
+    # -------------------------
+
+    bow = bow_model.predict(text)
+
+    bow_prediction = (
+        "😊 Positivo"
+        if bow["prediction"] == 1
+        else "😞 Negativo"
+    )
+
+    bow_probs = {
+        "Positivo": bow["probabilities"][1],
+        "Negativo": bow["probabilities"][0]
+    }
+
+    if len(bow["representation"]) == 0:
+
+        bow_representation = (
+            "Nenhuma palavra do texto pertence ao vocabulário do modelo."
+        )
+
+    else:
+
+        bow_representation = "\n".join(
+
+            f"{word:<20} {count}"
+
+            for word, count in bow["representation"].items()
+
+        )
+
+    # -------------------------
+    # BERT
+    # -------------------------
+
+    bert = bert_model.predict(text)
+
+    bert_prediction = (
+        "😊 Positivo"
+        if bert["prediction"] == 1
+        else "😞 Negativo"
+    )
+
+    bert_probs = {
+        "Positivo": bert["probabilities"][1],
+        "Negativo": bert["probabilities"][0]
+    }
+
+    bert_repr = "\n".join(
+        f"{item['token']:<15} "
+        f"[{', '.join(f'{v:.3f}' for v in item['vector'])}, ...]"
+        for item in bert["representation"]
+    )
+
+    return (
+
+        bow_prediction,
+        bow_probs,
+        bow_representation,
+
+        bert_prediction,
+        bert_probs,
+        bert_repr
+
+    )
+
+
+# ======================================================
+# Interface
+# ======================================================
+
+with gr.Blocks(
+    title="Sentiment Analysis Playground"
+) as demo:
+
+    gr.Markdown(
+"""
+# Sentiment Analysis Playground
+
+Compare como diferentes modelos processam um mesmo texto.
+
+Atualmente a demonstração possui:
+
+- 🟦 Bag of Words + Naive Bayes
+- 🟩 BERTimbau Fine-Tuned
+
+Digite qualquer texto em português e compare como cada modelo o representa internamente antes de classificá-lo.
+"""
+    )
+
+    textbox = gr.Textbox(
+
+        label="Texto",
+
+        placeholder="Digite um texto...",
+
+        lines=4
+
+    )
+
+    button = gr.Button(
+
+        "Classificar",
+
+        variant="primary"
+
+    )
+
+    with gr.Row():
+
+        # =====================================================
+        # BoW
+        # =====================================================
+
+        with gr.Column():
+
+            gr.Markdown("## 🟦 Bag of Words")
+
+            bow_prediction = gr.Textbox(
+
+                label="Classe",
+
+                interactive=False
+
+            )
+
+            bow_probs = gr.Label(
+
+                label="Probabilidades",
+
+                num_top_classes=2
+
+            )
+
+            with gr.Accordion(
+
+                "Como o modelo representa o texto",
+
+                open=False
+
+            ):
+
+                bow_repr = gr.Textbox(
+
+                    label="Representação BoW",
+
+                    lines=14,
+
+                    interactive=False
+
+                )
+
+            gr.Markdown("""
+
+### Como esse modelo funciona
+
+- Conta palavras
+- Ignora contexto
+- Ignora ordem das palavras
+- Baseado em frequência de termos
+
+""")
+
+        # =====================================================
+        # BERT
+        # =====================================================
+
+        with gr.Column():
+
+            gr.Markdown("## 🟩 BERTimbau")
+
+            bert_prediction = gr.Textbox(
+
+                label="Classe",
+
+                interactive=False
+
+            )
+
+            bert_probs = gr.Label(
+
+                label="Probabilidades",
+
+                num_top_classes=2
+
+            )
+
+            with gr.Accordion(
+
+                "Como o modelo representa o texto",
+
+                open=False
+
+            ):
+
+                bert_repr = gr.Textbox(
+
+                    label="Tokens WordPiece",
+
+                    lines=14,
+
+                    interactive=False
+
+                )
+
+            gr.Markdown("""
+
+### Como esse modelo funciona
+
+- Usa Transformer
+- Considera contexto
+- Considera ordem das palavras
+- Usa mecanismo de atenção
+
+""")
+
+    button.click(
+
+        predict,
+
+        textbox,
+
+        [
+
+            bow_prediction,
+            bow_probs,
+            bow_repr,
+
+            bert_prediction,
+            bert_probs,
+            bert_repr
+
+        ]
+
+    )
+
+    textbox.submit(
+
+        predict,
+
+        textbox,
+
+        [
+
+            bow_prediction,
+            bow_probs,
+            bow_repr,
+
+            bert_prediction,
+            bert_probs,
+            bert_repr
+
+        ]
+
+    )
+
+
+demo.launch()

models/bertimbau.py

@@ -0,0 +1,102 @@
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification
+)
+
+import torch
+
+
+MODEL_NAME = "jvomiranda/BERTimbau-Sent-Analysis"
+
+
+class BertimbauModel:
+
+    def __init__(self):
+
+        self.device = torch.device(
+            "cuda"
+            if torch.cuda.is_available()
+            else "cpu"
+        )
+
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            MODEL_NAME
+        )
+
+        self.model = (
+            AutoModelForSequenceClassification
+            .from_pretrained(MODEL_NAME)
+            .to(self.device)
+        )
+
+        self.model.eval()
+
+    @torch.no_grad()
+    def predict(self, text: str):
+
+        encoding = self.tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=128
+        )
+
+        encoding = {
+            key: value.to(self.device)
+            for key, value in encoding.items()
+        }
+
+        outputs = self.model(**encoding, output_hidden_states=True)
+
+        probabilities = torch.softmax(
+            outputs.logits,
+            dim=1
+        )[0]
+
+        prediction = torch.argmax(
+            probabilities
+        ).item()
+
+        tokens = self.tokenizer.convert_ids_to_tokens(
+            encoding["input_ids"][0]
+        )
+
+        token_ids = (
+            encoding["input_ids"][0]
+            .cpu()
+            .tolist()
+        )
+
+        embeddings = outputs.hidden_states[-1][0]
+
+        representation = []
+
+        for token, vector in zip(tokens, embeddings):
+
+            representation.append({
+                "token": token,
+                "vector": [
+                    round(float(x), 2)
+                    for x in vector[:5]
+                ]
+            })
+
+        return {
+
+            "prediction": prediction,
+
+            "probabilities": {
+
+                0: float(probabilities[0]),
+
+                1: float(probabilities[1])
+
+            },
+
+            "tokens": tokens,
+
+            "token_ids": token_ids,
+
+            "representation": representation
+
+        }

models/bow.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+
+import joblib
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+MODEL_PATH = (
+    ROOT /
+    "train" /
+    "saved_models" /
+    "bow_pipeline.joblib"
+)
+
+
+class BowModel:
+
+    def __init__(self):
+        self.pipeline = joblib.load(MODEL_PATH)
+
+    def predict(self, text):
+
+        prediction = self.pipeline.predict([text])[0]
+
+        probabilities = self.pipeline.predict_proba([text])[0]
+
+        vectorizer = self.pipeline.named_steps["vectorizer"]
+
+        X = vectorizer.transform([text])
+
+        vector = X.toarray()[0]
+
+        vocab = vectorizer.get_feature_names_out()
+
+        representation = {}
+
+        for palavra, contagem in zip(vocab, vector):
+            if contagem > 0:
+                representation[palavra] = int(contagem)
+
+        return {
+            "prediction": prediction,
+            "probabilities": {
+                classe: float(prob)
+                for classe, prob in zip(
+                    self.pipeline.classes_,
+                    probabilities
+                )
+            },
+            "representation": representation
+        }

requirements.txt

@@ -0,0 +1,8 @@
+datasets
+joblib
+numpy
+pandas
+scikit-learn
+torch
+transformers
+gradio

train/saved_models/bow_pipeline.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62c5c4def00e3e3dc56d8b6f7273a92ac7fbdb3cb967bb7e9aca187f108a3258
+size 9240493