Adicionando Imagens, notebboks explicativos e os dados (#1)

- Adicionando Imagens, notebboks explicativos e os dados (613102ef57229f47b30268f8394eed6a01e9d53a)


Co-authored-by: Andre Guarnier De Mitri <AndreMitri@users.noreply.huggingface.co>

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/imdb_reviews.csv filter=lfs diff=lfs merge=lfs -text

data/imdb_reviews.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f1314f123ac922d7d0f2bd5bd17f1734e167d90b2256c34963228bc63f6a4cb
+size 66262310

notebooks_explicativos/Estatistico.ipynb

@@ -0,0 +1,765 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lawNHLqffR_m"
+      },
+      "source": [
+        "# SCC0633/SCC5908 - Processamento de Linguagem Natural\n",
+        "> **Docente:** Thiago Alexandre Salgueiro Pardo \\\n",
+        "> **Estagiário PAE:** Germano Antonio Zani Jorge\n",
+        "\n",
+        "\n",
+        "# Integrantes do Grupo: GPTrouxas\n",
+        "> André Guarnier De Mitri - 11395579 \\\n",
+        "> Daniel Carvalho - 10685702 \\\n",
+        "> Fernando - 11795342 \\\n",
+        "> Lucas Henrique Sant'Anna - 10748521 \\\n",
+        "> Magaly L Fujimoto - 4890582"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pV6WGoBln8id"
+      },
+      "source": [
+        "# New Section"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Abordagem Estatístico\n",
+        "A arquitetura da solução estatística/neural envolve duas abordagens que\n",
+        "serão descritas neste documento. A primeira abordagem envolve utilizar\n",
+        "TF-IDF e Naive Bayes. E a segunda abordagem irá utilizar Word2Vec e um\n",
+        "modelo transformers pré-treinado da família BERT, realizando finetuning do\n",
+        "modelo.\n",
+        "\n",
+        "Na primeira abordagem, utilizaremos o TF-IDF, que leva em consideração a\n",
+        "frequência de ocorrência dos termos em um corpus e gera uma sequência de\n",
+        "vetores que serão fornecidos ao Naive Bayes para classificação da review como\n",
+        "positiva ou negativa.\n",
+        "\n",
+        "\n",
+        "Na segunda abordagem, utilizaremos o Word2Vec para vetorizar as reviews.\n",
+        "Após dividir em treino e teste, faremos o fine tuning de um modelo do tipo BERT\n",
+        "para o nosso problema e dataset específico. Com o BERT adaptado, faremos a\n",
+        "classificação de nossos textos, medindo o seu desempenho com F1 score e\n",
+        "acurácia.\n",
+        "\n",
+        "![alt text](../imagens/BERT_TDIDF.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "vfP54aryxZBg"
+      },
+      "source": [
+        "\n",
+        "## # Etapas da Abordagem Estatística\n",
+        "\n",
+        "1. **Bibliotecas**: Importamos as bibliotecas necessárias, considerando pandas para manipulação de dados, train_test_split para dividir o conjunto de dados em conjuntos de treinamento e teste, TfidfVectorizer para vetorização de texto usando TF-IDF, MultinomialNB para implementar o classificador Naive Bayes Multinomial e algumas métricas de avaliação.\n",
+        "\n",
+        "2. **Conjunto de dados**: Carregar o conjunto de dados e armazená-lo em um dataframe usando pandas.\n",
+        "\n",
+        "3. **Dividir o conjunto de dados**: Usamos `train_test_split` para dividir o DataFrame em conjuntos de treinamento e teste.\n",
+        "\n",
+        "4. **TF-IDF**: Usamos `TfidfVectorizer` para converter as revisões de texto em vetores numéricos usando a técnica TF-IDF. Em seguida, ajustamos e transformamos tanto o conjunto de treinamento quanto o conjunto de teste.\n",
+        "\n",
+        "5. **Naive Bayes**: Treinamos um classificador Naive Bayes Multinomial e usamos o modelo treinado para prever os sentimentos no conjunto de teste usando `predict`.\n",
+        "\n",
+        "6. **Avaliação e Resultados**: Salvamos os resultados em um novo dataframe `results_df` contendo as revisões do conjunto de teste, os sentimentos originais e os sentimentos previstos pelo modelo. Além disso, avaliamos o modelo verificando algumas métricas e a matriz de confusão.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "TbLraa4UhWDJ"
+      },
+      "source": [
+        "\n",
+        "## # Baixando, Carregando os dados e Pré Processamento\n",
+        "\n",
+        "1. Transformar todos os textos em lowercase \\\\\n",
+        "2. Remoção de caracteres especiais \\\\\n",
+        "3. Remoção de stop words \\\\\n",
+        "4. Lematização (Lemmatization) \\\\\n",
+        "5. Tokenização \\\\"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "bIWmIe0qfTbE"
+      },
+      "outputs": [],
+      "source": [
+        "import pandas as pd"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "Wf0n2yPdAn4C",
+        "outputId": "37eb3c4d-40c1-41a0-9b1a-d93ed6e272f3"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>review</th>\n",
+              "      <th>sentiment</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>One of the other reviewers has mentioned that ...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>I thought this was a wonderful way to spend ti...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Basically there's a family where a little boy ...</td>\n",
+              "      <td>negative</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                              review sentiment\n",
+              "0  One of the other reviewers has mentioned that ...  positive\n",
+              "1  A wonderful little production. <br /><br />The...  positive\n",
+              "2  I thought this was a wonderful way to spend ti...  positive\n",
+              "3  Basically there's a family where a little boy ...  negative\n",
+              "4  Petter Mattei's \"Love in the Time of Money\" is...  positive"
+            ]
+          },
+          "execution_count": 2,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "db = pd.read_csv('../data/imdb_reviews.csv')\n",
+        "db.head(5)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6PlfPScGMF1_",
+        "outputId": "2a0bd4a1-e22a-429d-82a4-5984eeab7b9d"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "sentiment\n",
+              "positive    25000\n",
+              "negative    25000\n",
+              "Name: count, dtype: int64"
+            ]
+          },
+          "execution_count": 3,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "db['sentiment'].value_counts()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Kev0EaSmMa4N",
+        "outputId": "eab73a61-ba36-4d72-e4f2-82236f9f2880"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Quantidade de valores faltantes para cada variável do dataset:\n",
+            "review       0\n",
+            "sentiment    0\n",
+            "dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "valores_ausentes = db.isnull().sum(axis=0)\n",
+        "print('Quantidade de valores faltantes para cada variável do dataset:')\n",
+        "print(valores_ausentes)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 276
+        },
+        "id": "1AI3rN0KMuUq",
+        "outputId": "7ea5c91b-362e-49eb-82a7-6e8535f0e591"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "[nltk_data] Downloading package stopwords to\n",
+            "[nltk_data]     C:\\Users\\andre\\AppData\\Roaming\\nltk_data...\n",
+            "[nltk_data]   Package stopwords is already up-to-date!\n",
+            "[nltk_data] Downloading package wordnet to\n",
+            "[nltk_data]     C:\\Users\\andre\\AppData\\Roaming\\nltk_data...\n",
+            "[nltk_data]   Package wordnet is already up-to-date!\n"
+          ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>review</th>\n",
+              "      <th>sentiment</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>one reviewer mentioned watching 1 oz episode h...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>wonderful little production filming technique ...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>thought wonderful way spend time hot summer we...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>basically family little boy jake think zombie ...</td>\n",
+              "      <td>negative</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>petter mattei love time money visually stunnin...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                              review sentiment\n",
+              "0  one reviewer mentioned watching 1 oz episode h...  positive\n",
+              "1  wonderful little production filming technique ...  positive\n",
+              "2  thought wonderful way spend time hot summer we...  positive\n",
+              "3  basically family little boy jake think zombie ...  negative\n",
+              "4  petter mattei love time money visually stunnin...  positive"
+            ]
+          },
+          "execution_count": 5,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import re\n",
+        "import nltk\n",
+        "from nltk.corpus import stopwords\n",
+        "from nltk.stem import PorterStemmer\n",
+        "from nltk.stem import WordNetLemmatizer\n",
+        "\n",
+        "def lowercase_text(text):\n",
+        "    return text.lower()\n",
+        "\n",
+        "def remove_html(text):\n",
+        "    return re.sub(r'<[^<]+?>', '', text)\n",
+        "\n",
+        "def remove_url(text):\n",
+        "    return re.sub(r'http[s]?://\\S+|www\\.\\S+', '', text)\n",
+        "\n",
+        "def remove_punctuations(text):\n",
+        "    tokens_list = '!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'\n",
+        "    for char in text:\n",
+        "        if char in tokens_list:\n",
+        "            text = text.replace(char, ' ')\n",
+        "\n",
+        "    return text\n",
+        "\n",
+        "def remove_emojis(text):\n",
+        "    emojis = re.compile(\"[\"\n",
+        "                        u\"\\U0001F600-\\U0001F64F\"\n",
+        "                        u\"\\U0001F300-\\U0001F5FF\"\n",
+        "                        u\"\\U0001F680-\\U0001F6FF\"\n",
+        "                        u\"\\U0001F1E0-\\U0001F1FF\"\n",
+        "                        u\"\\U00002500-\\U00002BEF\"\n",
+        "                        u\"\\U00002702-\\U000027B0\"\n",
+        "                        u\"\\U00002702-\\U000027B0\"\n",
+        "                        u\"\\U000024C2-\\U0001F251\"\n",
+        "                        u\"\\U0001f926-\\U0001f937\"\n",
+        "                        u\"\\U00010000-\\U0010ffff\"\n",
+        "                        u\"\\u2640-\\u2642\"\n",
+        "                        u\"\\u2600-\\u2B55\"\n",
+        "                        u\"\\u200d\"\n",
+        "                        u\"\\u23cf\"\n",
+        "                        u\"\\u23e9\"\n",
+        "                        u\"\\u231a\"\n",
+        "                        u\"\\ufe0f\"\n",
+        "                        u\"\\u3030\"\n",
+        "                        \"]+\", re.UNICODE)\n",
+        "\n",
+        "    text = re.sub(emojis, '', text)\n",
+        "    return text\n",
+        "\n",
+        "def remove_stop_words(text):\n",
+        "    stop_words = stopwords.words('english')\n",
+        "    new_text = ''\n",
+        "    for word in text.split():\n",
+        "        if word not in stop_words:\n",
+        "            new_text += ''.join(f'{word} ')\n",
+        "\n",
+        "    return new_text.strip()\n",
+        "\n",
+        "def lem_words(text):\n",
+        "    lemma = WordNetLemmatizer()\n",
+        "    new_text = ''\n",
+        "    for word in text.split():\n",
+        "        new_text += ''.join(f'{lemma.lemmatize(word)} ')\n",
+        "\n",
+        "    return new_text\n",
+        "\n",
+        "def preprocess_text(text):\n",
+        "    text = lowercase_text(text)\n",
+        "    text = remove_html(text)\n",
+        "    text = remove_url(text)\n",
+        "    text = remove_punctuations(text)\n",
+        "    text = remove_emojis(text)\n",
+        "    text = remove_stop_words(text)\n",
+        "    text = lem_words(text)\n",
+        "\n",
+        "    return text\n",
+        "\n",
+        "nltk.download('stopwords')\n",
+        "nltk.download('wordnet')\n",
+        "db['review'] = db['review'].apply(preprocess_text)\n",
+        "db.head()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "QgufZpgHnPa4"
+      },
+      "source": [
+        "# **Conjunto de Treino e teste**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "s0lJ6Q0tnPka"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "X= db['review']\n",
+        "y= db['sentiment']\n",
+        "\n",
+        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2, random_state= 12)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "nz4erCEJuD4-",
+        "outputId": "88d57536-66e7-4d9b-e016-bf40183d4c45"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "35235    disagree people saying lousy horror film good ...\n",
+              "36936    husband wife doctor team carole nile nelson mo...\n",
+              "46486    like cast pretty much however story sort unfol...\n",
+              "27160    movie awful bad bear expend anything word avoi...\n",
+              "19490    purchased blood castle dvd ebay buck knowing s...\n",
+              "                               ...                        \n",
+              "36482    strange thing see film scene work rather weakl...\n",
+              "40177    saw cheap dvd release title entity force since...\n",
+              "19709    one peculiar oft used romance movie plot one s...\n",
+              "38555    nothing positive say meandering nonsense huffi...\n",
+              "14155    low moment life bewildered depressed sitting r...\n",
+              "Name: review, Length: 40000, dtype: object"
+            ]
+          },
+          "execution_count": 7,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "X_train"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6LX-6e-QlioJ"
+      },
+      "source": [
+        "# **TD-IDF e Naive Bayes**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "gscB9-obNusA"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import confusion_matrix,classification_report\n",
+        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+        "from sklearn.preprocessing import StandardScaler as encoder\n",
+        "from sklearn.metrics import (\n",
+        "    accuracy_score,\n",
+        "    confusion_matrix,\n",
+        "    ConfusionMatrixDisplay,\n",
+        "    f1_score,\n",
+        ")\n",
+        "\n",
+        "\n",
+        "tfidf = TfidfVectorizer()\n",
+        "tfidf_train = tfidf.fit_transform(X_train)\n",
+        "tfidf_test = tfidf.transform(X_test)\n",
+        "\n",
+        "from sklearn.naive_bayes import MultinomialNB\n",
+        "\n",
+        "naive_bayes = MultinomialNB()\n",
+        "\n",
+        "naive_bayes.fit(tfidf_train, y_train)\n",
+        "y_pred = naive_bayes.predict(tfidf_test)\n",
+        "\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "RfJ7AHMZvAb8",
+        "outputId": "685701e1-b1e8-47fb-9dc5-1bc04dd3894b"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>review</th>\n",
+              "      <th>original sentiment</th>\n",
+              "      <th>predicted sentiment</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>34622</th>\n",
+              "      <td>hard tell noonan marshall trying ape abbott co...</td>\n",
+              "      <td>negative</td>\n",
+              "      <td>negative</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1163</th>\n",
+              "      <td>well start one reviewer said know real treat s...</td>\n",
+              "      <td>positive</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>7637</th>\n",
+              "      <td>wife kid opinion absolute abc classic seen eve...</td>\n",
+              "      <td>positive</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>7045</th>\n",
+              "      <td>surprise basic copycat comedy classic nutty pr...</td>\n",
+              "      <td>positive</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>43847</th>\n",
+              "      <td>josef von sternberg directs magnificent silent...</td>\n",
+              "      <td>positive</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                                  review original sentiment  \\\n",
+              "34622  hard tell noonan marshall trying ape abbott co...           negative   \n",
+              "1163   well start one reviewer said know real treat s...           positive   \n",
+              "7637   wife kid opinion absolute abc classic seen eve...           positive   \n",
+              "7045   surprise basic copycat comedy classic nutty pr...           positive   \n",
+              "43847  josef von sternberg directs magnificent silent...           positive   \n",
+              "\n",
+              "      predicted sentiment  \n",
+              "34622            negative  \n",
+              "1163             positive  \n",
+              "7637             positive  \n",
+              "7045             positive  \n",
+              "43847            positive  "
+            ]
+          },
+          "execution_count": 9,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Criando DataFrame com resultados\n",
+        "results_df = pd.DataFrame({'review': X_test, 'original sentiment': y_test, 'predicted sentiment': y_pred})\n",
+        "results_df.head()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8Xq2ABXYtsjk"
+      },
+      "source": [
+        "## Avaliação"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "id": "3lXqDNhSrhsZ"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import confusion_matrix, classification_report\n",
+        "import seaborn as sns\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "def plot_confusion_matrix(y_true, y_pred, labels, model_name):\n",
+        "    cm = confusion_matrix(y_true, y_pred, labels=labels)\n",
+        "    plt.figure(figsize=(8, 6))\n",
+        "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)\n",
+        "    plt.xlabel('Predicted Labels')\n",
+        "    plt.ylabel('True Labels')\n",
+        "    plt.title(f'Confusion Matrix {model_name}')\n",
+        "    plt.show()\n",
+        "\n",
+        "# Função para calcular e imprimir as métricas de avaliação\n",
+        "def print_evaluation_metrics(y_true, y_pred, model_name):\n",
+        "    print(f\"Classification Report {model_name}:\")\n",
+        "    print(classification_report(y_true, y_pred))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 564
+        },
+        "id": "ybfb_GKDuqmb",
+        "outputId": "3e4c3a98-8962-4ce8-9856-2252f769a1b8"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 800x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "plot_confusion_matrix(y_test, y_pred, ['positive', 'negative'], 'NB')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2580FJCGs_oQ",
+        "outputId": "118f79e2-6b57-4cc0-a631-c2ef8a7e317e"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Classification Report NB:\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "    negative       0.86      0.87      0.86      5017\n",
+            "    positive       0.87      0.86      0.86      4983\n",
+            "\n",
+            "    accuracy                           0.86     10000\n",
+            "   macro avg       0.86      0.86      0.86     10000\n",
+            "weighted avg       0.86      0.86      0.86     10000\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Imprimir as métricas de avaliação\n",
+        "print_evaluation_metrics(y_test, y_pred, 'NB')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "x0JBy6nXvdjC"
+      },
+      "source": [
+        "# Conclusão\n",
+        "\n",
+        "É possível verificar no relatório de classificação que precisão e recall estão variando entre 86 a 87%. A métrica **F1-Score** combina precisão e recall, possui valor de aproximadamente 86%, o que indica um bom equilíbrio entre precisão e recall. A **Acurácia (accuracy)** geral do modelo é de 86%, o que significa que ele classificou corretamente aproximadamente 86% de todos os exemplos no conjunto de teste.\n",
+        "\n",
+        "O modelo Naive Bayes com vetorização TF-IDF conseguiu alcançar uma precisão, recall e F1-Score bastante equilibrados para ambas as classes, com uma acurácia geral de 86%. Podemos afirmar que o modelo é capaz de fazer previsões precisas em relação ao sentimento das revisões. Assim, podemos afirmar que o modelo estatístico possui um desempenho consideravelmente superior em relação à abordagem simbólica.\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.7"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

notebooks_explicativos/Neural_Bert.ipynb

@@ -0,0 +1,1291 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# SCC0633/SCC5908 - Processamento de Linguagem Natural\n",
+        "> **Docente:** Thiago Alexandre Salgueiro Pardo \\\\\n",
+        "> **Estagiário PAE:** Germano Antonio Zani Jorge\n",
+        "\n",
+        "\n",
+        "# Integrantes do Grupo: GPTrouxas\n",
+        "> André Guarnier De Mitri - 11395579 \\\\\n",
+        "> Daniel Carvalho - 10685702 \\\\\n",
+        "> Fernando - 11795342 \\\\\n",
+        "> Lucas Henrique Sant'Anna - 10748521 \\\\\n",
+        "> Magaly L Fujimoto - 4890582 \\\\\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Abordagem Neural usando BERT\n",
+        "![alt text](../imagens/BERT_TDIDF.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "###"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6yecpJR0feeQ"
+      },
+      "source": [
+        "## Importando bibliotecas"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "FAIvyZwodEtm"
+      },
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import math\n",
+        "from tqdm.notebook import tqdm\n",
+        "import pandas as pd"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#!pip install transformers seaborn nltk"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Carregando dados"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "LYgXl3RIfgfo",
+        "outputId": "eb496faf-7826-44f7-fa88-3b21fb6e7cbf"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>review</th>\n",
+              "      <th>sentiment</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>One of the other reviewers has mentioned that ...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>I thought this was a wonderful way to spend ti...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Basically there's a family where a little boy ...</td>\n",
+              "      <td>negative</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
+              "      <td>positive</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                              review sentiment\n",
+              "0  One of the other reviewers has mentioned that ...  positive\n",
+              "1  A wonderful little production. <br /><br />The...  positive\n",
+              "2  I thought this was a wonderful way to spend ti...  positive\n",
+              "3  Basically there's a family where a little boy ...  negative\n",
+              "4  Petter Mattei's \"Love in the Time of Money\" is...  positive"
+            ]
+          },
+          "execution_count": 3,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "df_reviews = pd.read_csv('imdb_reviews.csv')\n",
+        "df_reviews.head()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Mapeando as classes\n",
+        "- Sentimento positivo recebe label 1\n",
+        "- Sentimento negativo recebe label 0"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "D-5n8XzJbWOO",
+        "outputId": "cef630cc-b0cc-4598-c53f-d32636bfcd86"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>review</th>\n",
+              "      <th>sentiment</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>One of the other reviewers has mentioned that ...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>I thought this was a wonderful way to spend ti...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Basically there's a family where a little boy ...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                              review  sentiment\n",
+              "0  One of the other reviewers has mentioned that ...          1\n",
+              "1  A wonderful little production. <br /><br />The...          1\n",
+              "2  I thought this was a wonderful way to spend ti...          1\n",
+              "3  Basically there's a family where a little boy ...          0\n",
+              "4  Petter Mattei's \"Love in the Time of Money\" is...          1"
+            ]
+          },
+          "execution_count": 4,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "def map_sentiments(sentiment):\n",
+        "    if sentiment == 'positive':\n",
+        "        return 1\n",
+        "    return 0\n",
+        "\n",
+        "df_reviews['sentiment'] = df_reviews['sentiment'].apply(map_sentiments)\n",
+        "df_reviews.head()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Funções para limpeza do texto\n",
+        "**lowercase_text(text)** Converte o texto para letras minúsculas para uniformizar o texto.\n",
+        "\n",
+        "\n",
+        "**remove_html(text)**  Remove quaisquer tags HTML do texto para limpar dados provenientes de fontes HTML.\n",
+        "\n",
+        "\n",
+        " **remove_url(text)** Remove URLs do texto para eliminar links que podem não ser relevantes para a análise de texto.\n",
+        "\n",
+        "\n",
+        "**remove_punctuations(text)** Remove pontuações do texto para simplificar a estrutura do texto, mantendo apenas palavras.\n",
+        "\n",
+        "**remove_emojis(text)** Remove emojis do texto para evitar caracteres não verbais que podem interferir na análise textual.\n",
+        "\n",
+        "**remove_stop_words(text)** Remove stop words (palavras comuns como \"e\", \"de\", \"o\") que geralmente não adicionam valor significativo à análise de texto.\n",
+        "\n",
+        "**stem_words(text)**  Aplica stemming nas palavras do texto, reduzindo-as à sua raiz (por exemplo, \"running\" vira \"run\") para normalizar as variações das palavras.\n",
+        "\n",
+        "**preprocess_text(text)**  Aplica todas as funções acima em sequência para pré-processar o texto de forma completa, tornando-o mais adequado para análise de texto ou modelagem.\n",
+        "\n",
+        "\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 241
+        },
+        "id": "PnFHO62rnWn-",
+        "outputId": "17fb6619-fab9-4395-de5d-4c5199e7e45e"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "[nltk_data] Downloading package stopwords to\n",
+            "[nltk_data]     C:\\Users\\andre\\AppData\\Roaming\\nltk_data...\n",
+            "[nltk_data]   Package stopwords is already up-to-date!\n"
+          ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>review</th>\n",
+              "      <th>sentiment</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>one review mention watch 1 oz episod hook righ...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>wonder littl product film techniqu unassum old...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>thought wonder way spend time hot summer weeke...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>basic famili littl boy jake think zombi closet...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>petter mattei love time money visual stun film...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                              review  sentiment\n",
+              "0  one review mention watch 1 oz episod hook righ...          1\n",
+              "1  wonder littl product film techniqu unassum old...          1\n",
+              "2  thought wonder way spend time hot summer weeke...          1\n",
+              "3  basic famili littl boy jake think zombi closet...          0\n",
+              "4  petter mattei love time money visual stun film...          1"
+            ]
+          },
+          "execution_count": 5,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import re\n",
+        "import nltk\n",
+        "from nltk.corpus import stopwords\n",
+        "from nltk.stem import PorterStemmer\n",
+        "\n",
+        "\n",
+        "def lowercase_text(text):\n",
+        "    return text.lower()\n",
+        "\n",
+        "def remove_html(text):\n",
+        "    return re.sub(r'<[^<]+?>', '', text)\n",
+        "\n",
+        "def remove_url(text):\n",
+        "    return re.sub(r'http[s]?://\\S+|www\\.\\S+', '', text)\n",
+        "\n",
+        "def remove_punctuations(text):\n",
+        "    tokens_list = '!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'\n",
+        "    for char in text:\n",
+        "        if char in tokens_list:\n",
+        "            text = text.replace(char, ' ')\n",
+        "\n",
+        "    return text\n",
+        "\n",
+        "def remove_emojis(text):\n",
+        "    emojis = re.compile(\"[\"\n",
+        "                        u\"\\U0001F600-\\U0001F64F\"\n",
+        "                        u\"\\U0001F300-\\U0001F5FF\"\n",
+        "                        u\"\\U0001F680-\\U0001F6FF\"\n",
+        "                        u\"\\U0001F1E0-\\U0001F1FF\"\n",
+        "                        u\"\\U00002500-\\U00002BEF\"\n",
+        "                        u\"\\U00002702-\\U000027B0\"\n",
+        "                        u\"\\U00002702-\\U000027B0\"\n",
+        "                        u\"\\U000024C2-\\U0001F251\"\n",
+        "                        u\"\\U0001f926-\\U0001f937\"\n",
+        "                        u\"\\U00010000-\\U0010ffff\"\n",
+        "                        u\"\\u2640-\\u2642\"\n",
+        "                        u\"\\u2600-\\u2B55\"\n",
+        "                        u\"\\u200d\"\n",
+        "                        u\"\\u23cf\"\n",
+        "                        u\"\\u23e9\"\n",
+        "                        u\"\\u231a\"\n",
+        "                        u\"\\ufe0f\"\n",
+        "                        u\"\\u3030\"\n",
+        "                        \"]+\", re.UNICODE)\n",
+        "\n",
+        "    text = re.sub(emojis, '', text)\n",
+        "    return text\n",
+        "\n",
+        "def remove_stop_words(text):\n",
+        "    stop_words = stopwords.words('english')\n",
+        "    new_text = ''\n",
+        "    for word in text.split():\n",
+        "        if word not in stop_words:\n",
+        "            new_text += ''.join(f'{word} ')\n",
+        "\n",
+        "    return new_text.strip()\n",
+        "\n",
+        "def stem_words(text):\n",
+        "    stemmer = PorterStemmer()\n",
+        "    new_text = ''\n",
+        "    for word in text.split():\n",
+        "        new_text += ''.join(f'{stemmer.stem(word)} ')\n",
+        "\n",
+        "    return new_text\n",
+        "\n",
+        "def preprocess_text(text):\n",
+        "    text = lowercase_text(text)\n",
+        "    text = remove_html(text)\n",
+        "    text = remove_url(text)\n",
+        "    text = remove_punctuations(text)\n",
+        "    text = remove_emojis(text)\n",
+        "    text = remove_stop_words(text)\n",
+        "    text = stem_words(text)\n",
+        "\n",
+        "    return text\n",
+        "\n",
+        "nltk.download('stopwords')\n",
+        "df_reviews['review'] = df_reviews['review'].apply(preprocess_text)\n",
+        "df_reviews.head()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Visualizando balancemento da classes"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "Gdi_L0HWfntv",
+        "outputId": "bce77594-f662-4b3f-c8eb-27d8a188b4f2"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "plt.title('Target value distribution')\n",
+        "plt.hist(df_reviews['sentiment'])\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Modelo BERT"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "EDkjlPDakskM"
+      },
+      "source": [
+        "## Instalando Bibliotecas"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lk7m_1xvmWvz",
+        "outputId": "ce842053-b261-4768-d9d7-fe9c65c9f6aa"
+      },
+      "outputs": [],
+      "source": [
+        "#pip install transformers\n",
+        "#pip install accelerate -U\n",
+        "#pip install transformers[torch]\n",
+        "#pip install datasets evaluate"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Carregando o modelo treinado e tokenizador"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GlyrkK52zMcc",
+        "outputId": "a938653b-92c3-4b4e-802c-eacc3f1b6ecf"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "c:\\Users\\andre\\1JUPYTER\\dt_labs\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+            "  from .autonotebook import tqdm as notebook_tqdm\n"
+          ]
+        }
+      ],
+      "source": [
+        "from transformers import AutoTokenizer\n",
+        "from transformers import BertForSequenceClassification\n",
+        "\n",
+        "pre_trained_base = \"bert-base-uncased\"\n",
+        "tokenizer = AutoTokenizer.from_pretrained(pre_trained_base)\n",
+        "model = BertForSequenceClassification.from_pretrained(pre_trained_base, num_labels = 2, output_attentions=False, output_hidden_states=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Tokenização das Sentenças e Cálculo do Tamanho dos Tokens"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "id": "LKEjDZCHpk4e"
+      },
+      "outputs": [],
+      "source": [
+        "token_lens = []\n",
+        "\n",
+        "for sentence in df_reviews['review']:\n",
+        "    tokens = tokenizer.encode(sentence, max_length=200, truncation=True)\n",
+        "    token_lens.append(len(tokens))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Divisão dos Dados em Conjunto de Treinamento e Validação:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "id": "H7PfXaVVp2uQ"
+      },
+      "outputs": [],
+      "source": [
+        "SEED=42\n",
+        "MAX_LEN = 200\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "df_train, df_val = train_test_split(df_reviews, test_size=0.2, random_state=SEED)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Processando os dados\n",
+        "A função process_data recebe uma linha de um dataframe contendo uma revisão de texto e sua respectiva classificação de sentimento. Ela começa extraindo e limpando o texto da revisão, removendo quaisquer espaços extras. Em seguida, utiliza o tokenizer BERT para tokenizar o texto, aplicando padding e truncamento para garantir que todas as sequências tenham um comprimento fixo definido pela variável MAX_LEN. A função então adiciona a etiqueta de sentimento original e o texto limpo às codificações geradas, retornando um dicionário que contém os tokens do texto, a etiqueta de sentimento e o texto original."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "v7EZ6wd-qDfd"
+      },
+      "outputs": [],
+      "source": [
+        "def process_data(row):\n",
+        "\n",
+        "    text = row['review']\n",
+        "    text = str(text)\n",
+        "    text = ' '.join(text.split())\n",
+        "\n",
+        "    encodings = tokenizer(text, padding=\"max_length\", truncation=True, max_length=MAX_LEN)\n",
+        "\n",
+        "    encodings['label'] = row['sentiment']\n",
+        "    encodings['text'] = text\n",
+        "\n",
+        "    return encodings"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "d9VgrXNSqIYL"
+      },
+      "outputs": [],
+      "source": [
+        "# Treino\n",
+        "processed_data_tr = []\n",
+        "for i in range(df_train.shape[0]):\n",
+        "    processed_data_tr.append(process_data(df_train.iloc[i]))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "p0NLQxoKqJ_k"
+      },
+      "outputs": [],
+      "source": [
+        "# Validação\n",
+        "processed_data_val = []\n",
+        "for i in range(df_val.shape[0]):\n",
+        "    processed_data_val.append(process_data(df_val.iloc[i]))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "id": "ac76Rb6fqP_G"
+      },
+      "outputs": [],
+      "source": [
+        "# Dataframes de Treino e Validação\n",
+        "df_train = pd.DataFrame(processed_data_tr)\n",
+        "df_val = pd.DataFrame(processed_data_val)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "RdbHaVy_fd64",
+        "outputId": "a9aed834-81b7-4223-da42-6289799c2e1e"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>attention_mask</th>\n",
+              "      <th>input_ids</th>\n",
+              "      <th>label</th>\n",
+              "      <th>text</th>\n",
+              "      <th>token_type_ids</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...</td>\n",
+              "      <td>[101, 2921, 3198, 23624, 2954, 6978, 2674, 841...</td>\n",
+              "      <td>0</td>\n",
+              "      <td>kept ask mani fight scream match swear gener m...</td>\n",
+              "      <td>[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...</td>\n",
+              "      <td>[101, 3422, 4372, 3775, 2099, 9587, 5737, 2071...</td>\n",
+              "      <td>0</td>\n",
+              "      <td>watch entir movi could watch entir movi stop d...</td>\n",
+              "      <td>[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...</td>\n",
+              "      <td>[101, 3543, 2293, 2358, 10050, 2128, 25300, 11...</td>\n",
+              "      <td>1</td>\n",
+              "      <td>touch love stori reminisc ‘in mood love draw h...</td>\n",
+              "      <td>[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...</td>\n",
+              "      <td>[101, 3732, 2154, 11865, 15472, 2072, 8040, 73...</td>\n",
+              "      <td>0</td>\n",
+              "      <td>latter day fulci schlocker total abysm concoct...</td>\n",
+              "      <td>[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...</td>\n",
+              "      <td>[101, 2034, 3813, 3669, 19337, 2666, 2615, 504...</td>\n",
+              "      <td>0</td>\n",
+              "      <td>first firmli believ norwegian movi continu get...</td>\n",
+              "      <td>[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                      attention_mask  \\\n",
+              "0  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...   \n",
+              "1  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...   \n",
+              "2  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...   \n",
+              "3  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...   \n",
+              "4  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...   \n",
+              "\n",
+              "                                           input_ids  label  \\\n",
+              "0  [101, 2921, 3198, 23624, 2954, 6978, 2674, 841...      0   \n",
+              "1  [101, 3422, 4372, 3775, 2099, 9587, 5737, 2071...      0   \n",
+              "2  [101, 3543, 2293, 2358, 10050, 2128, 25300, 11...      1   \n",
+              "3  [101, 3732, 2154, 11865, 15472, 2072, 8040, 73...      0   \n",
+              "4  [101, 2034, 3813, 3669, 19337, 2666, 2615, 504...      0   \n",
+              "\n",
+              "                                                text  \\\n",
+              "0  kept ask mani fight scream match swear gener m...   \n",
+              "1  watch entir movi could watch entir movi stop d...   \n",
+              "2  touch love stori reminisc ‘in mood love draw h...   \n",
+              "3  latter day fulci schlocker total abysm concoct...   \n",
+              "4  first firmli believ norwegian movi continu get...   \n",
+              "\n",
+              "                                      token_type_ids  \n",
+              "0  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...  \n",
+              "1  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...  \n",
+              "2  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...  \n",
+              "3  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...  \n",
+              "4  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...  "
+            ]
+          },
+          "execution_count": 20,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "df_train.head()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0lTWT8JwkRic"
+      },
+      "source": [
+        "## Fine Tunning do Modelo\n",
+        "Ajuste fino do BERT para tarefas específica de classificação de sentimento para o dataset do IMDB"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "import pyarrow as pa\n",
+        "from datasets import Dataset\n",
+        "import evaluate\n",
+        "import numpy as np"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kW53p7VQqUDD",
+        "outputId": "8231f3ba-37d5-4546-c4d0-6b4ff317ecf3"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "device(type='cuda', index=0)"
+            ]
+          },
+          "execution_count": 21,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "device"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "id": "68OdbTv5rLrm"
+      },
+      "outputs": [],
+      "source": [
+        "train_hg = Dataset(pa.Table.from_pandas(df_train))\n",
+        "valid_hg = Dataset(pa.Table.from_pandas(df_val))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Metricas de avaliação F1 Score e Acc"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "`compute_metrics` calcula tanto a acurácia quanto o F1-score para avaliar um modelo de classificação. Primeiramente, são carregadas as métricas de acurácia e F1-score usando evaluate.load. Em seguida, a função compute_metrics recebe um par de arrays eval_pred, contendo as previsões do modelo e os rótulos verdadeiros. Utilizando as previsões, a função calcula a acurácia e o F1-score ponderado, onde a acurácia é obtida através da comparação das previsões com os rótulos utilizando a métrica de acurácia previamente carregada, e o F1-score é calculado utilizando a métrica de F1 previamente carregada, com ponderação \"weighted\". Os resultados de ambas as métricas são então combinados em um dicionário e retornados como um único objeto contendo as métricas de avaliação calculadas."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "id": "lUNhDPs0ry4m"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "# Load both accuracy and f1 metrics\n",
+        "accuracy_metric = evaluate.load(\"accuracy\")\n",
+        "f1_metric = evaluate.load(\"f1\")\n",
+        "\n",
+        "# Metric helper method\n",
+        "def compute_metrics(eval_pred):\n",
+        "    predictions, labels = eval_pred\n",
+        "    predictions = np.argmax(predictions, axis=1)\n",
+        "\n",
+        "    # Compute accuracy\n",
+        "    accuracy = accuracy_metric.compute(predictions=predictions, references=labels)\n",
+        "\n",
+        "    # Compute F1 score\n",
+        "    f1 = f1_metric.compute(predictions=predictions, references=labels, average=\"weighted\")\n",
+        "\n",
+        "    # Combine the metrics into a single dictionary\n",
+        "    combined_metrics = {\n",
+        "        'accuracy': accuracy['accuracy'],\n",
+        "        'f1': f1['f1']\n",
+        "    }\n",
+        "\n",
+        "    return combined_metrics"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9jJYTWsHjnEc",
+        "outputId": "fe45691a-4476-4978-89b8-15f36465c37c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Name: accelerateNote: you may need to restart the kernel to use updated packages.\n",
+            "\n",
+            "Version: 0.31.0\n",
+            "Summary: Accelerate\n",
+            "Home-page: https://github.com/huggingface/accelerate\n",
+            "Author: The HuggingFace team\n",
+            "Author-email: zach.mueller@huggingface.co\n",
+            "License: Apache\n",
+            "Location: c:\\Users\\andre\\1JUPYTER\\dt_labs\\.venv\\Lib\\site-packages\n",
+            "Requires: huggingface-hub, numpy, packaging, psutil, pyyaml, safetensors, torch\n",
+            "Required-by: \n",
+            "---\n",
+            "Name: transformers\n",
+            "Version: 4.41.2\n",
+            "Summary: State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow\n",
+            "Home-page: https://github.com/huggingface/transformers\n",
+            "Author: The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors)\n",
+            "Author-email: transformers@huggingface.co\n",
+            "License: Apache 2.0 License\n",
+            "Location: c:\\Users\\andre\\1JUPYTER\\dt_labs\\.venv\\Lib\\site-packages\n",
+            "Requires: filelock, huggingface-hub, numpy, packaging, pyyaml, regex, requests, safetensors, tokenizers, tqdm\n",
+            "Required-by: \n"
+          ]
+        }
+      ],
+      "source": [
+        "pip show accelerate transformers"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Treinamento do modelo"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QlaLCwf7rLtp",
+        "outputId": "7e10e82a-8bc7-478b-851e-c7b628b46c41"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "c:\\Users\\andre\\1JUPYTER\\dt_labs\\.venv\\Lib\\site-packages\\transformers\\training_args.py:1474: FutureWarning: `evaluation_strategy` is deprecated and will be removed in version 4.46 of 🤗 Transformers. Use `eval_strategy` instead\n",
+            "  warnings.warn(\n"
+          ]
+        }
+      ],
+      "source": [
+        "from transformers import TrainingArguments, Trainer\n",
+        "\n",
+        "EPOCHS = 1\n",
+        "\n",
+        "training_args = TrainingArguments(output_dir=\"./result\",\n",
+        "                                  evaluation_strategy=\"epoch\",\n",
+        "                                  num_train_epochs= EPOCHS,\n",
+        "                                  per_device_train_batch_size=16,\n",
+        "                                  per_device_eval_batch_size=8\n",
+        "                                )\n",
+        "\n",
+        "trainer = Trainer(\n",
+        "    model=model,\n",
+        "    args=training_args,\n",
+        "    train_dataset=train_hg,\n",
+        "    eval_dataset=valid_hg,\n",
+        "    tokenizer=tokenizer,\n",
+        "    compute_metrics=compute_metrics\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "CUDA available:  True\n",
+            "CUDA version:  12.1\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"CUDA available: \", torch.cuda.is_available())\n",
+        "print(\"CUDA version: \", torch.version.cuda)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 141
+        },
+        "id": "3s6lVFz_rLwO",
+        "outputId": "ee64e8e9-9c8c-42a8-c355-f51410cc33df"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "  0%|          | 0/2500 [00:00<?, ?it/s]c:\\Users\\andre\\1JUPYTER\\dt_labs\\.venv\\Lib\\site-packages\\transformers\\models\\bert\\modeling_bert.py:435: UserWarning: 1Torch was not compiled with flash attention. (Triggered internally at ..\\aten\\src\\ATen\\native\\transformers\\cuda\\sdp_utils.cpp:263.)\n",
+            "  attn_output = torch.nn.functional.scaled_dot_product_attention(\n",
+            " 20%|██        | 500/2500 [05:35<22:22,  1.49it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'loss': 0.4994, 'grad_norm': 12.613661766052246, 'learning_rate': 4e-05, 'epoch': 0.2}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 40%|████      | 1000/2500 [11:13<16:46,  1.49it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'loss': 0.3898, 'grad_norm': 4.661791801452637, 'learning_rate': 3e-05, 'epoch': 0.4}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 60%|██████    | 1500/2500 [16:47<11:02,  1.51it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'loss': 0.3516, 'grad_norm': 1.5203113555908203, 'learning_rate': 2e-05, 'epoch': 0.6}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 80%|████████  | 2000/2500 [22:25<05:33,  1.50it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'loss': 0.3121, 'grad_norm': 8.331348419189453, 'learning_rate': 1e-05, 'epoch': 0.8}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 2500/2500 [28:04<00:00,  1.50it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'loss': 0.2882, 'grad_norm': 6.287994861602783, 'learning_rate': 0.0, 'epoch': 1.0}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "                                                   \n",
+            "100%|██████████| 2500/2500 [30:45<00:00,  1.35it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'eval_loss': 0.283893883228302, 'eval_accuracy': 0.883, 'eval_f1': 0.8829425082505502, 'eval_runtime': 159.717, 'eval_samples_per_second': 62.611, 'eval_steps_per_second': 7.826, 'epoch': 1.0}\n",
+            "{'train_runtime': 1845.2907, 'train_samples_per_second': 21.677, 'train_steps_per_second': 1.355, 'train_loss': 0.3682089477539062, 'epoch': 1.0}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "TrainOutput(global_step=2500, training_loss=0.3682089477539062, metrics={'train_runtime': 1845.2907, 'train_samples_per_second': 21.677, 'train_steps_per_second': 1.355, 'total_flos': 4111110240000000.0, 'train_loss': 0.3682089477539062, 'epoch': 1.0})"
+            ]
+          },
+          "execution_count": 29,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "trainer.train()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Salvando o modelo"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {
+        "id": "8eO6WDiOBAhg"
+      },
+      "outputs": [],
+      "source": [
+        "torch.save(model.state_dict(), 'model.pth')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FtVZztSa40b3"
+      },
+      "source": [
+        "## Teste de predições individuais"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {
+        "id": "lOHVSyfJJ8zK"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import AutoTokenizer\n",
+        "\n",
+        "new_tokenizer = AutoTokenizer.from_pretrained(pre_trained_base)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "id": "t-T7hDZ2J1Qk"
+      },
+      "outputs": [],
+      "source": [
+        "def get_prediction(text):\n",
+        "    encoding = new_tokenizer(text, return_tensors=\"pt\", padding=\"max_length\", truncation=True, max_length=MAX_LEN)\n",
+        "    encoding = {k: v.to(trainer.model.device) for k,v in encoding.items()}\n",
+        "\n",
+        "    outputs = model(**encoding)\n",
+        "\n",
+        "    logits = outputs.logits\n",
+        "\n",
+        "    sigmoid = torch.nn.Sigmoid()\n",
+        "    probs = sigmoid(logits.squeeze().cpu())\n",
+        "    probs = probs.detach().numpy()\n",
+        "    label = np.argmax(probs, axis=-1)\n",
+        "\n",
+        "    return label"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "y4dxQ4oYJ5C1",
+        "outputId": "d0d77c2d-aff6-412b-e22a-0b721f5b097e"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "0"
+            ]
+          },
+          "execution_count": 36,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "get_prediction(\"This movie is horrible!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "JXAyOu_6AqoO",
+        "outputId": "ffcd019e-4c0c-45eb-f538-d2860c53a0e0"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "1"
+            ]
+          },
+          "execution_count": 37,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "get_prediction(\"This movie is awesome!\")"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "gpuClass": "standard",
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.11"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}