Upload 4 files

Final_Project_ML_DL_Sentiment_Amazon.ipynb

@@ -0,0 +1,522 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "48470cbd",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# Projeto Final – Machine Learning e Deep Learning (PLN: Análise de Sentimentos)\n",
+    "\n",
+    "**Professor Rodrigo aqui!**  \n",
+    "Este notebook é o guia didático para o **Projeto Final**. Vamos construir uma solução completa de **Classificação de Sentimentos** usando avaliações da Amazon (**dataset `amazon_polarity` do Hugging Face**), cobrindo todo o pipeline:\n",
+    "\n",
+    "1. Definição do problema e escolha do dataset  \n",
+    "2. Coleta/limpeza, preparação e divisão do conjunto de dados  \n",
+    "3. **Baseline** com *Machine Learning tradicional* (TF-IDF + Regressão Logística)  \n",
+    "4. Modelo de *Deep Learning* com **LSTM (PyTorch)**  \n",
+    "5. Avaliação com métricas adequadas (Accuracy, F1, Matriz de Confusão)  \n",
+    "6. Exportação dos artefatos e **deploy** com **Gradio** (+ passo a passo para publicar no **Hugging Face Spaces**)  \n",
+    "\n",
+    "> **Importante**: Execute célula por célula e leia as explicações. Onde houver blocos \"Experimente\", preencha as suas observações. Esse notebook pode ser entregue como parte dos **entregáveis** do projeto.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Objetivo Geral\n",
+    "Desenvolver uma solução prática de **ML + DL** aplicada a um problema de **PLN** (classificação binária de sentimento), integrando desde a preparação até o deploy em ambiente público gratuito.\n",
+    "\n",
+    "## Entregáveis\n",
+    "- Notebook **.ipynb** com comentários e resultados  \n",
+    "- **README.md** do projeto (modelo fornecido)  \n",
+    "- Deploy funcional com **Gradio** (arquivos `app.py` e `requirements.txt` prontos)  \n",
+    "- Relatório (5–8 páginas) — usar o modelo do README como base\n",
+    "\n",
+    "---\n",
+    "\n",
+    "> **Dica para execução no Google Colab**: ative GPU (Menu: Runtime → Change runtime type → **GPU**).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8e7be1b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Instalação de dependências (Colab)\n",
+    "# Se estiver no Colab, descomente as linhas abaixo para instalar.\n",
+    "# Em ambiente local com venv, rode `pip install -r requirements.txt`.\n",
+    "\n",
+    "# !pip install -q datasets==3.0.1 scikit-learn==1.5.2 matplotlib==3.9.2 torch==2.4.1 \\\n",
+    "#                   pandas==2.2.2 numpy==2.1.3 gradio==5.7.1 tqdm==4.66.5\n",
+    "\n",
+    "print(\"✅ Ambiente pronto (ajuste as instalações se necessário).\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99d5bff0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Importações centrais\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix, classification_report\n",
+    "import joblib\n",
+    "import os\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "\n",
+    "SEED = 42\n",
+    "np.random.seed(SEED)\n",
+    "torch.manual_seed(SEED)\n",
+    "print(\"✅ Imports OK\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dde7d907",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 1) Definição do Problema\n",
+    "\n",
+    "**Tarefa**: Classificar avaliações de produtos como **positivas (1)** ou **negativas (-1)**.  \n",
+    "**Dataset**: `amazon_polarity` (Hugging Face Datasets).  \n",
+    "**Justificativa**: análise de sentimentos é amplamente usada em e-commerce e suporte a decisões.\n",
+    "\n",
+    "> **Critérios de avaliação**: accuracy, F1, matriz de confusão; comparação entre baseline (ML) e LSTM (DL).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b875e79",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Coleta e preparação dos dados (amostragem para execução rápida)\n",
+    "# Carrega partições 'train' e 'test' do dataset amazon_polarity\n",
+    "ds_train = load_dataset(\"amazon_polarity\", split=\"train\")\n",
+    "ds_test  = load_dataset(\"amazon_polarity\", split=\"test\")\n",
+    "\n",
+    "# Convertendo para DataFrame\n",
+    "df_train = pd.DataFrame({\"text\": ds_train[\"content\"], \"label\": ds_train[\"label\"]})\n",
+    "df_test  = pd.DataFrame({\"text\": ds_test[\"content\"],  \"label\": ds_test[\"label\"]})\n",
+    "\n",
+    "# O dataset possui rótulos {0,1}; vamos mapeá-los para {-1, +1} opcionalmente para leitura humana\n",
+    "label_map = {0:0, 1:1}  # manter 0/1 para facilitar as métricas de sklearn\n",
+    "df_train[\"label\"] = df_train[\"label\"].map(label_map)\n",
+    "df_test[\"label\"]  = df_test[\"label\"].map(label_map)\n",
+    "\n",
+    "# Amostragem para acelerar (ajuste conforme sua GPU/tempo):\n",
+    "N_TRAIN = 12000   # experimente 50k+ com GPU boa\n",
+    "N_TEST  = 6000\n",
+    "df_train = df_train.sample(n=N_TRAIN, random_state=SEED).reset_index(drop=True)\n",
+    "df_test  = df_test.sample(n=N_TEST,  random_state=SEED).reset_index(drop=True)\n",
+    "\n",
+    "# Split treino/val\n",
+    "train_text, val_text, train_y, val_y = train_test_split(\n",
+    "    df_train[\"text\"].values, df_train[\"label\"].values, test_size=0.2, random_state=SEED, stratify=df_train[\"label\"].values\n",
+    ")\n",
+    "\n",
+    "print(\"Tamanhos: \", len(train_text), len(val_text), len(df_test))\n",
+    "df_train.head()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed2e0c79",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 2) Baseline com Machine Learning Tradicional\n",
+    "\n",
+    "Vamos iniciar com um pipeline simples: **TF-IDF** para vetorização + **Regressão Logística**.  \n",
+    "Depois, comparamos com um **Random Forest** para observar diferenças.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5d7ba98",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Treino e avaliação: TF-IDF + Regressão Logística\n",
+    "baseline_pipe = Pipeline([\n",
+    "    (\"tfidf\", TfidfVectorizer(max_features=40000, ngram_range=(1,2))),\n",
+    "    (\"clf\", LogisticRegression(max_iter=1000, n_jobs=None))\n",
+    "])\n",
+    "\n",
+    "baseline_pipe.fit(train_text, train_y)\n",
+    "\n",
+    "val_pred = baseline_pipe.predict(val_text)\n",
+    "test_pred = baseline_pipe.predict(df_test[\"text\"].values)\n",
+    "\n",
+    "print(\"Val Accuracy:\", accuracy_score(val_y, val_pred))\n",
+    "print(\"Val F1:\", f1_score(val_y, val_pred, average=\"weighted\"))\n",
+    "print(\"\\nTest Accuracy:\", accuracy_score(df_test[\"label\"].values, test_pred))\n",
+    "print(\"Test F1:\", f1_score(df_test[\"label\"].values, test_pred, average=\"weighted\"))\n",
+    "\n",
+    "# Matriz de confusão (teste)\n",
+    "cm = confusion_matrix(df_test[\"label\"].values, test_pred)\n",
+    "plt.figure()\n",
+    "plt.imshow(cm, cmap='Blues')\n",
+    "plt.title(\"Matriz de Confusão - Baseline (Teste)\")\n",
+    "plt.xlabel(\"Predito\")\n",
+    "plt.ylabel(\"Verdadeiro\")\n",
+    "for i in range(cm.shape[0]):\n",
+    "    for j in range(cm.shape[1]):\n",
+    "        plt.text(j, i, cm[i, j], ha=\"center\", va=\"center\")\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"\\nRelatório de Classificação (Teste):\\n\")\n",
+    "print(classification_report(df_test[\"label\"].values, test_pred))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbdd4c7a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Comparativo rápido: TF-IDF + RandomForest\n",
+    "rf_pipe = Pipeline([\n",
+    "    (\"tfidf\", TfidfVectorizer(max_features=30000, ngram_range=(1,1))),\n",
+    "    (\"rf\", RandomForestClassifier(n_estimators=200, random_state=SEED, n_jobs=-1))\n",
+    "])\n",
+    "\n",
+    "rf_pipe.fit(train_text, train_y)\n",
+    "rf_val = rf_pipe.predict(val_text)\n",
+    "rf_test = rf_pipe.predict(df_test[\"text\"].values)\n",
+    "\n",
+    "print(\"RF Val Acc:\", accuracy_score(val_y, rf_val), \" | Val F1:\", f1_score(val_y, rf_val, average=\"weighted\"))\n",
+    "print(\"RF Test Acc:\", accuracy_score(df_test[\"label\"].values, rf_test), \" | Test F1:\", f1_score(df_test[\"label\"].values, rf_test, average=\"weighted\"))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02952330",
+   "metadata": {},
+   "source": [
+    "\n",
+    "> **Experimente:**  \n",
+    "> - Aumente/diminua `max_features` do TF-IDF.  \n",
+    "> - Troque Regressão Logística por SVM (`LinearSVC`).  \n",
+    "> - Compare overfitting entre ML tradicional e DL.  \n",
+    ">\n",
+    "> **Suas observações:** *(escreva abaixo)*\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22ba8a44",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 3) Deep Learning com LSTM (PyTorch)\n",
+    "\n",
+    "Vamos construir um pipeline enxuto com **tokenização simples**, **vocab** baseado no treino e uma **LSTM** para classificação binária.  \n",
+    "> Para resultados de SOTA, considere **transformers** (BERT, DistilBERT). Aqui focamos nos fundamentos.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b9994fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Tokenização simples + Dataset/Dataloader\n",
+    "import re\n",
+    "from collections import Counter\n",
+    "\n",
+    "def basic_tokenize(text):\n",
+    "    # minuscula, remove caracteres não alfabéticos exceto apóstrofos básicos, separa por espaços\n",
+    "    text = text.lower()\n",
+    "    text = re.sub(r\"[^a-z0-9' ]+\", \" \", text)\n",
+    "    return text.split()\n",
+    "\n",
+    "# constrói vocabulário a partir do treino\n",
+    "MAX_VOCAB = 30000\n",
+    "counter = Counter()\n",
+    "for t in train_text:\n",
+    "    counter.update(basic_tokenize(t))\n",
+    "most_common = counter.most_common(MAX_VOCAB - 2)  # reserva para PAD/UNK\n",
+    "itos = [\"<PAD>\", \"<UNK>\"] + [w for w,_ in most_common]\n",
+    "stoi = {w:i for i,w in enumerate(itos)}\n",
+    "\n",
+    "def encode(tokens, max_len=80):\n",
+    "    ids = [stoi.get(tok, 1) for tok in tokens]  # 1 = <UNK>\n",
+    "    if len(ids) < max_len:\n",
+    "        ids = ids + [0] * (max_len - len(ids))  # 0 = <PAD>\n",
+    "    else:\n",
+    "        ids = ids[:max_len]\n",
+    "    return np.array(ids, dtype=np.int64)\n",
+    "\n",
+    "MAX_LEN = 80\n",
+    "\n",
+    "class SentimentDataset(Dataset):\n",
+    "    def __init__(self, texts, labels):\n",
+    "        self.texts = texts\n",
+    "        self.labels = labels\n",
+    "    def __len__(self):\n",
+    "        return len(self.texts)\n",
+    "    def __getitem__(self, idx):\n",
+    "        x = encode(basic_tokenize(self.texts[idx]), MAX_LEN)\n",
+    "        y = int(self.labels[idx])\n",
+    "        return torch.tensor(x), torch.tensor(y)\n",
+    "\n",
+    "train_ds = SentimentDataset(train_text, train_y)\n",
+    "val_ds   = SentimentDataset(val_text, val_y)\n",
+    "test_ds  = SentimentDataset(df_test[\"text\"].values, df_test[\"label\"].values)\n",
+    "\n",
+    "BATCH_SIZE = 128\n",
+    "train_dl = DataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True)\n",
+    "val_dl   = DataLoader(val_ds, batch_size=BATCH_SIZE)\n",
+    "test_dl  = DataLoader(test_ds, batch_size=BATCH_SIZE)\n",
+    "\n",
+    "len(itos), MAX_LEN, BATCH_SIZE\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71d27538",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Modelo LSTM\n",
+    "class LSTMClassifier(nn.Module):\n",
+    "    def __init__(self, vocab_size, embed_dim=128, hidden_dim=128, num_classes=2, num_layers=1, dropout=0.2):\n",
+    "        super().__init__()\n",
+    "        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)\n",
+    "        self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers=num_layers, batch_first=True, dropout=dropout if num_layers>1 else 0.0)\n",
+    "        self.dropout = nn.Dropout(dropout)\n",
+    "        self.fc = nn.Linear(hidden_dim, num_classes)\n",
+    "    def forward(self, x):\n",
+    "        emb = self.embedding(x)\n",
+    "        out, _ = self.lstm(emb)\n",
+    "        h = out[:, -1, :]\n",
+    "        h = self.dropout(h)\n",
+    "        return self.fc(h)\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model = LSTMClassifier(vocab_size=len(itos)).to(device)\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
+    "\n",
+    "EPOCHS = 4  # aumente se tiver tempo/GPU\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c639c797",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Treino simples + validação\n",
+    "def evaluate(model, loader):\n",
+    "    model.eval()\n",
+    "    ys, ps = [], []\n",
+    "    with torch.no_grad():\n",
+    "        for xb, yb in loader:\n",
+    "            xb, yb = xb.to(device), yb.to(device)\n",
+    "            logits = model(xb)\n",
+    "            pred = torch.argmax(logits, dim=1)\n",
+    "            ys.append(yb.cpu().numpy())\n",
+    "            ps.append(pred.cpu().numpy())\n",
+    "    ys = np.concatenate(ys)\n",
+    "    ps = np.concatenate(ps)\n",
+    "    return accuracy_score(ys, ps), f1_score(ys, ps, average=\"weighted\")\n",
+    "\n",
+    "best_val = 0.0\n",
+    "for epoch in range(1, EPOCHS+1):\n",
+    "    model.train()\n",
+    "    total_loss = 0.0\n",
+    "    for xb, yb in tqdm(train_dl, desc=f\"Epoch {epoch}/{EPOCHS}\"):\n",
+    "        xb, yb = xb.to(device), yb.to(device)\n",
+    "        optimizer.zero_grad()\n",
+    "        logits = model(xb)\n",
+    "        loss = criterion(logits, yb)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        total_loss += loss.item()\n",
+    "    val_acc, val_f1 = evaluate(model, val_dl)\n",
+    "    print(f\"Epoch {epoch} | Loss: {total_loss/len(train_dl):.4f} | Val Acc: {val_acc:.4f} | Val F1: {val_f1:.4f}\")\n",
+    "    if val_acc > best_val:\n",
+    "        best_val = val_acc\n",
+    "        torch.save({\n",
+    "            \"model_state\": model.state_dict(),\n",
+    "            \"vocab\": itos,\n",
+    "            \"max_len\": MAX_LEN\n",
+    "        }, \"lstm_sentiment_best.pt\")\n",
+    "        print(\"✅ Modelo LSTM salvo: lstm_sentiment_best.pt\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b44eb2e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Avaliação no conjunto de teste\n",
+    "# Carrega melhor checkpoint (se houver)\n",
+    "if os.path.exists(\"lstm_sentiment_best.pt\"):\n",
+    "    ckpt = torch.load(\"lstm_sentiment_best.pt\", map_location=device)\n",
+    "    model.load_state_dict(ckpt[\"model_state\"])\n",
+    "\n",
+    "test_acc, test_f1 = evaluate(model, test_dl)\n",
+    "print(\"LSTM Test Accuracy:\", test_acc)\n",
+    "print(\"LSTM Test F1:\", test_f1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b866b6f",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 4) Exportação de Artefatos\n",
+    "\n",
+    "Vamos salvar:\n",
+    "- Pipeline TF-IDF + Regressão Logística (`baseline_pipe.pkl`)\n",
+    "- Modelo LSTM (`lstm_sentiment_best.pt`) + vocabulário embutido no checkpoint\n",
+    "\n",
+    "Esses arquivos serão usados no **deploy** (Gradio + Hugging Face Spaces).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ccf5e781",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Salvar pipeline baseline\n",
+    "joblib.dump(baseline_pipe, \"baseline_pipe.pkl\")\n",
+    "print(\"✅ Pipeline baseline salvo como baseline_pipe.pkl\")\n",
+    "\n",
+    "# O LSTM já foi salvo como lstm_sentiment_best.pt durante o treino (melhor época).\n",
+    "print(\"✅ Verifique se lstm_sentiment_best.pt foi gerado na etapa anterior.\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5d63f93",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 5) Demonstração com Gradio (local)\n",
+    "\n",
+    "Abaixo, uma interface mínima com **Gradio**. Para publicar no **Hugging Face Spaces**, usaremos o arquivo `app.py` (já pronto e salvo ao lado deste notebook).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7efbc3cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# @title Demo local (opcional)\n",
+    "# Para executar no notebook, descomente:\n",
+    "# import gradio as gr\n",
+    "# import torch\n",
+    "# import joblib\n",
+    "\n",
+    "# # Carregar baseline (mais leve para demo)\n",
+    "# baseline = joblib.load(\"baseline_pipe.pkl\")\n",
+    "\n",
+    "# def predict_sentiment(text):\n",
+    "#     proba = baseline.predict_proba([text])[0]\n",
+    "#     pred = int(np.argmax(proba))\n",
+    "#     label = \"positivo\" if pred == 1 else \"negativo\"\n",
+    "#     conf = float(np.max(proba))\n",
+    "#     return {\"predição\": label, \"confiança\": conf}\n",
+    "\n",
+    "# demo = gr.Interface(fn=predict_sentiment,\n",
+    "#                     inputs=gr.Textbox(label=\"Digite uma avaliação\"),\n",
+    "#                     outputs=gr.JSON(label=\"Resultado\"),\n",
+    "#                     title=\"Análise de Sentimentos (Baseline)\")\n",
+    "# demo.launch()\n",
+    "print(\"ℹ️ Use o app.py para deploy no Hugging Face Spaces.\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8454fcd",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 6) Conclusões & Próximos Passos\n",
+    "\n",
+    "- Comparamos **ML tradicional** (TF-IDF + LR/RF) com uma **LSTM** simples.  \n",
+    "- Para melhores resultados, considere **transformers** (ex.: `distilbert-base-uncased` com `transformers`).  \n",
+    "- Faça *tuning* de hiperparâmetros (LR, batch size, epochs, max_features, max_len).  \n",
+    "- Documente no **Relatório**: escolhas, resultados, limitações e próximos passos.\n",
+    "\n",
+    "> **Checklist para o Deploy**  \n",
+    "> - `baseline_pipe.pkl` e/ou `lstm_sentiment_best.pt` gerados  \n",
+    "> - `app.py` pronto (fornecido)  \n",
+    "> - `requirements.txt` pronto (fornecido)  \n",
+    "> - Criar o **Space** no Hugging Face (template Gradio/Python) e subir os arquivos  \n",
+    "> - Preencher o `README.md` com prints e explicações\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17df5370",
+   "metadata": {},
+   "source": [
+    "\n",
+    "---\n",
+    "\n",
+    "### 🧪 Experimente (preencha suas anotações abaixo)\n",
+    "\n",
+    "1. **TF-IDF**: Mude `ngram_range`, `max_features` e compare *accuracy* e *F1* no **val** e **test**.  \n",
+    "2. **Classificador**: Troque para `LinearSVC` e compare com a Regressão Logística.  \n",
+    "3. **LSTM**: Aumente `EPOCHS` e `embed_dim` (128→256) e anote mudanças.  \n",
+    "4. **Limpeza**: Remova *stopwords* no TF-IDF e compare.  \n",
+    "5. **Amostra**: Compare tempos e métricas usando `N_TRAIN`=12k vs. 50k+.\n",
+    "\n",
+    "**Observações do grupo:**\n",
+    "\n",
+    "- \n",
+    "- \n",
+    "- \n"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

README.md

@@ -1,14 +1,55 @@
----
-title: Amazon Classific Polarity
-emoji: 🌍
-colorFrom: purple
-colorTo: pink
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Classificar avaliações em P&N ( MODELO PROJETO FINAL )
+
+# Projeto Final — Análise de Sentimentos (Amazon Polarity)
+
+**Curso**: Machine Learning e Deep Learning  
+**Data**: 2025-11-12  
+**Grupo**: _(preencha com os integrantes)_
+
+## 1. Definição do Problema
+Classificar avaliações de produtos (Amazon) como **positivas** ou **negativas**.
+
+**Justificativa**: problema real de PLN, com alto valor prático em e-commerce e suporte a decisões.
+
+## 2. Dataset
+- **Fonte**: [Hugging Face — `amazon_polarity`](https://huggingface.co/datasets/amazon_polarity)
+- **Tamanho**: milhões de exemplos (usamos amostra para execução rápida)
+- **Divisão**: treino/validação/teste
+
+## 3. Metodologia
+- **Pré-processamento**: limpeza básica de texto; TF‑IDF (ML) e tokenização simples (DL)
+- **Modelos**:
+  - Baseline: TF‑IDF + Regressão Logística
+  - Comparativo: Random Forest
+  - Deep Learning: LSTM (PyTorch)
+- **Métricas**: Accuracy, F1 (macro/weighted), Matriz de Confusão
+
+## 4. Resultados (resumo)
+> _Inclua as tabelas e gráficos principais. Compare ML vs. DL e explique as diferenças observadas._
+
+## 5. Deploy (Hugging Face Spaces)
+**Arquivos necessários**:
+- `app.py`
+- `requirements.txt`
+- `baseline_pipe.pkl` (gerado pelo notebook)
+
+**Passo a passo**:
+1. Crie uma conta em https://huggingface.co (ou use a sua).  
+2. Clique em **Create new Space** → **Gradio** → **Python**.  
+3. Faça **Upload** de `app.py`, `requirements.txt` e `baseline_pipe.pkl`.  
+4. Aguarde o build do Space e teste a interface.  
+5. Edite este **README** com prints da interface funcionando e links.
+
+## 6. Conclusões
+- _Resumo dos achados e justificativas técnicas._  
+- _Limitações e próximos passos (ex.: transformers, tuning avançado, dados balanceados)._
+
+## 7. Como reproduzir localmente
+```bash
+python -m venv .venv && source .venv/bin/activate  # (Windows: .venv\Scripts\activate)
+pip install -r requirements.txt
+python app.py
+```
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+> **Observação**: Este repositório/Space cumpre os **entregáveis**: notebook, deploy funcional e documentação.

app.py

@@ -0,0 +1,33 @@
+
+import gradio as gr
+import joblib
+import numpy as np
+import os
+
+# Carrega o pipeline baseline (TF-IDF + LogisticRegression)
+MODEL_PATH = os.getenv("MODEL_PATH", "baseline_pipe.pkl")
+
+if not os.path.exists(MODEL_PATH):
+    raise FileNotFoundError(f"Arquivo de modelo não encontrado: {MODEL_PATH}. Faça upload de baseline_pipe.pkl.")
+
+baseline = joblib.load(MODEL_PATH)
+
+def predict_sentiment(text: str):
+    if not text or text.strip() == "":
+        return {"predição": "n/a", "confiança": 0.0}
+    proba = baseline.predict_proba([text])[0]
+    pred = int(np.argmax(proba))
+    label = "positivo" if pred == 1 else "negativo"
+    conf = float(np.max(proba))
+    return {"predição": label, "confiança": conf}
+
+demo = gr.Interface(
+    fn=predict_sentiment,
+    inputs=gr.Textbox(label="Digite uma avaliação de produto"),
+    outputs=gr.JSON(label="Resultado"),
+    title="Análise de Sentimentos (Amazon Polarity)",
+    description="Pipeline TF-IDF + Regressão Logística. Faça upload de baseline_pipe.pkl gerado no notebook."
+)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,10 @@
+
+datasets==3.0.1
+pandas==2.2.2
+numpy==2.1.3
+scikit-learn==1.5.2
+matplotlib==3.9.2
+joblib==1.4.2
+torch==2.4.1
+tqdm==4.66.5
+gradio==5.7.1