Upload Mini-Projeto3-Modelagem.ipynb

Mini-Projeto3-Modelagem.ipynb

@@ -0,0 +1,988 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>Data Science Academy</font>\n",
+    "# <font color='blue'>Deep Learning Para Aplicações de IA com PyTorch e Lightning</font>\n",
+    "\n",
+    "## <font color='blue'>Mini-Projeto 3 - Modelagem</font>\n",
+    "## <font color='blue'>Fine-Tuning de Modelo LLM Para Tarefa Específica e Deploy de Web App com Gradio</font>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![DSA](imagens/MP3.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Instalando e Carregando os Pacotes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Versão da Linguagem Python Usada Neste Jupyter Notebook: 3.10.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Versão da Linguagem Python\n",
+    "from platform import python_version\n",
+    "print('Versão da Linguagem Python Usada Neste Jupyter Notebook:', python_version())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Para atualizar um pacote, execute o comando abaixo no terminal ou prompt de comando:\n",
+    "# pip install -U nome_pacote\n",
+    "\n",
+    "# Para instalar a versão exata de um pacote, execute o comando abaixo no terminal ou prompt de comando:\n",
+    "# !pip install nome_pacote==versão_desejada\n",
+    "\n",
+    "# Depois de instalar ou atualizar o pacote, reinicie o jupyter notebook.\n",
+    "\n",
+    "# Instala o pacote watermark. \n",
+    "# Esse pacote é usado para gravar as versões de outros pacotes usados neste jupyter notebook.\n",
+    "!pip install -q -U watermark"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "env: TF_CPP_MIN_LOG_LEVEL=3\n"
+     ]
+    }
+   ],
+   "source": [
+    "%env TF_CPP_MIN_LOG_LEVEL=3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q torch==2.0.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q transformers==4.31.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q accelerate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Imports\n",
+    "import torch\n",
+    "import transformers\n",
+    "import numpy as np\n",
+    "import torch.nn.functional as F\n",
+    "from accelerate import Accelerator\n",
+    "from torch.utils.data import Dataset\n",
+    "from transformers import AutoConfig, AutoModelForCausalLM, GPT2Tokenizer\n",
+    "from transformers import GPT2Tokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Author: Data Science Academy\n",
+      "\n",
+      "numpy       : 1.23.5\n",
+      "torch       : 2.0.1\n",
+      "transformers: 4.31.0\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Versões dos pacotes usados neste jupyter notebook\n",
+    "%reload_ext watermark\n",
+    "%watermark -a \"Data Science Academy\" --iversions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Carregando o LLM\n",
+    "\n",
+    "https://huggingface.co/gpt2\n",
+    "\n",
+    "O modelo terá a mesma arquitetura do GPT-2, mas com algumas modificações para torná-lo menor. As principais mudanças são o tamanho do vocabulário que é 13 porque só vai lidar com números mais o padding token, o \"+\" e o \"=\". A janela de contexto suportará apenas 6 tokens, pois estamos interessados apenas em realizar a adição de dois dígitos únicos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tamanho do vocabulário\n",
+    "vocab_size = 13"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Comprimento da sequência\n",
+    "sequence_length = 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Comprimento do resultado\n",
+    "result_length = 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Comprimento do contexto\n",
+    "context_length = sequence_length + result_length"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parâmetros de configuração do modelo GPT-2\n",
+    "config = AutoConfig.from_pretrained(\"gpt2\", \n",
+    "                                    vocab_size = vocab_size, \n",
+    "                                    n_ctx = context_length, \n",
+    "                                    n_head = 4, \n",
+    "                                    n_layer = 2) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Carrega o modelo\n",
+    "modelo = AutoModelForCausalLM.from_config(config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Função para calcular o tamanho do modelo\n",
+    "def model_size(model):\n",
+    "    return sum(t.numel() for t in modelo.parameters())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tamanho do Modelo: 15.0M parâmetros\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'Tamanho do Modelo: {model_size(modelo)/1000**2:.1f}M parâmetros')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Este modelo tem 15 milhões de parâmetros em vez dos 111 milhões de parâmetros da configuração padrão \"gpt2\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "transformers.models.gpt2.modeling_gpt2.GPT2LMHeadModel"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(modelo)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Salva o modelo em disco\n",
+    "modelo.save_pretrained(\"modelos/modelo_inicial\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tokenizador Personalizado"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Definindo uma classe chamada NumberTokenizer, que é usada para tokenizar os números\n",
+    "class DSATokenizer:\n",
+    "    \n",
+    "    # Método construtor da classe, que é executado quando um objeto dessa classe é criado\n",
+    "    def __init__(self, numbers_qty = 10):\n",
+    "        \n",
+    "        # Lista de tokens possíveis que o tokenizador pode encontrar\n",
+    "        vocab = ['+', '=', '-1', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
+    "        \n",
+    "        # Definindo a quantidade de números que o tokenizador pode lidar\n",
+    "        self.numbers_qty = numbers_qty\n",
+    "        \n",
+    "        # Definindo o token de preenchimento (padding)\n",
+    "        self.pad_token = '-1'\n",
+    "        \n",
+    "        # Criando um dicionário que mapeia cada token para um índice único\n",
+    "        self.encoder = {str(v):i for i,v in enumerate(vocab)}\n",
+    "        \n",
+    "        # Criando um dicionário que mapeia cada índice único de volta ao token correspondente\n",
+    "        self.decoder = {i:str(v) for i,v in enumerate(vocab)}\n",
+    "        \n",
+    "        # Obtendo o índice do token de preenchimento no encoder\n",
+    "        self.pad_token_id = self.encoder[self.pad_token]\n",
+    "\n",
+    "    # Método para decodificar uma lista de IDs de token de volta para uma string\n",
+    "    def decode(self, token_ids):\n",
+    "        return ' '.join(self.decoder[t] for t in token_ids)\n",
+    "\n",
+    "    # Método que é chamado quando o objeto da classe é invocado como uma função\n",
+    "    def __call__(self, text):\n",
+    "        # Dividindo o texto em tokens individuais e retornando uma lista dos IDs correspondentes\n",
+    "        return [self.encoder[t] for t in text.split()]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> Vamos testar o tokenizador!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cria o objeto do tokenizador\n",
+    "tokenizer = DSATokenizer(vocab_size)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{0: '+',\n",
+       " 1: '=',\n",
+       " 2: '-1',\n",
+       " 3: '0',\n",
+       " 4: '1',\n",
+       " 5: '2',\n",
+       " 6: '3',\n",
+       " 7: '4',\n",
+       " 8: '5',\n",
+       " 9: '6',\n",
+       " 10: '7',\n",
+       " 11: '8',\n",
+       " 12: '9'}"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Decoder do tokenizador\n",
+    "tokenizer.decoder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[4, 0, 4, 1, 5]"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Testando o tokenizador\n",
+    "tokenizer(\"1 + 1 = 2\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Criando o Dataset\n",
+    "\n",
+    "O conjunto de dados deve ser criado neste formato:\n",
+    "\n",
+    "- Entrada: \"2 + 3 = 0\" onde os 4 primeiros caracteres representam a sequência de entrada e o quinto caractere representa o primeiro caracter da saída.\n",
+    "\n",
+    "- Saída: \"+ 3 = 0 5\" onde os 2 últimos dígitos representam o resultado da adição e os 3 primeiros dígitos são ignorados durante o treinamento e preenchidos com o pad.\n",
+    "\n",
+    "O resultado é um conjunto de dados de sequências tokenizadas de números."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Definindo uma classe chamada CriaDataset, que herda da classe Dataset do PyTorch\n",
+    "class CriaDataset(Dataset):\n",
+    "\n",
+    "    # Método construtor da classe, que é executado quando um objeto dessa classe é criado\n",
+    "    def __init__(self, split, length = 6):\n",
+    "        \n",
+    "        # Verificando se a divisão do dataset (split) é 'treino' ou 'teste'\n",
+    "        assert split in {'treino', 'teste'}\n",
+    "        self.split = split\n",
+    "        self.length = length\n",
+    "    \n",
+    "    # Definindo o método len que retorna o tamanho do dataset. \n",
+    "    # Nesse caso, o tamanho é fixo e igual a 1 milhão.\n",
+    "    def __len__(self):\n",
+    "        return 1000000 \n",
+    "\n",
+    "    # Definindo o método getitem que é usado para obter um item específico do dataset\n",
+    "    def __getitem__(self, idx):\n",
+    "\n",
+    "        # Criando uma lista com todos os números disponíveis que não são tokens de padding e são numéricos\n",
+    "        available_numbers = [int(n) for n in tokenizer.decoder.values() if n != tokenizer.pad_token and str(n).isnumeric()]\n",
+    "        \n",
+    "        # Selecionando aleatoriamente números da lista de números disponíveis para criar uma entrada (input)\n",
+    "        inp = torch.tensor(np.random.choice(available_numbers, size = result_length))\n",
+    "        \n",
+    "        # Calculando a soma dos números selecionados e criando um tensor\n",
+    "        sol = torch.tensor([int(i) for i in str(inp.sum().item())])\n",
+    "        \n",
+    "        # Preenchendo o tensor com zeros para que tenha o tamanho desejado\n",
+    "        sol = torch.nn.functional.pad(sol, (1 if sol.size()[0] == 1 else 0,0), 'constant', 0)\n",
+    "\n",
+    "        # Concatenando a entrada e a solução em um tensor\n",
+    "        cat = torch.cat((inp, sol), dim = 0)\n",
+    "\n",
+    "        # Criando os tensores de entrada e alvo para o treinamento do modelo\n",
+    "        x = cat[:-1].clone()\n",
+    "        y = cat[1:].clone()\n",
+    "\n",
+    "        # Definindo o primeiro elemento do tensor alvo como o token de padding\n",
+    "        y[:1] = int(tokenizer.pad_token)\n",
+    "\n",
+    "        # Transformando os tensores x e y em strings\n",
+    "        x = str(x[0].item()) + ' + ' + str(x[1].item()) + ' = ' + str(x[2].item())\n",
+    "        y = '-1 ' + str(y[0].item()) + ' -1 ' + str(y[1].item()) + ' ' + str(y[2].item())\n",
+    "        \n",
+    "        # Tokenizando as strings de entrada e alvo\n",
+    "        tokenized_input = tokenizer(x)\n",
+    "        tokenized_output = tokenizer(y)\n",
+    "        \n",
+    "        # Retornando os tensores de entrada e alvo como itens do dataset\n",
+    "        return torch.tensor(tokenized_input), torch.tensor(tokenized_output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Datasets de Treino e Teste"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset_treino = CriaDataset('treino', length = sequence_length)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset_teste = CriaDataset('teste', length = sequence_length)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x, y = dataset_treino[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([10,  0,  4,  1,  3])"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([ 2,  2,  2,  3, 11])"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7 + 1 = 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(tokenizer.decode(x.numpy()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-1 -1 -1 0 8\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(tokenizer.decode(y.numpy()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loop de Treinamento"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_epochs = 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = torch.optim.Adam(modelo.parameters())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dados = torch.utils.data.DataLoader(dataset_treino, shuffle = True, batch_size = batch_size)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "https://pypi.org/project/accelerate/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import accelerate\n",
+    "from accelerate import Accelerator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "accelerator = Accelerator()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Author: Data Science Academy\n",
+      "\n",
+      "numpy       : 1.23.5\n",
+      "accelerate  : 0.21.0\n",
+      "torch       : 2.0.1\n",
+      "transformers: 4.31.0\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Versões dos pacotes usados neste jupyter notebook\n",
+    "%reload_ext watermark\n",
+    "%watermark -a \"Data Science Academy\" --iversions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "modelo, optimizer, dados = accelerator.prepare(modelo, optimizer, dados)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GPT2LMHeadModel(\n",
+       "  (transformer): GPT2Model(\n",
+       "    (wte): Embedding(13, 768)\n",
+       "    (wpe): Embedding(1024, 768)\n",
+       "    (drop): Dropout(p=0.1, inplace=False)\n",
+       "    (h): ModuleList(\n",
+       "      (0-1): 2 x GPT2Block(\n",
+       "        (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
+       "        (attn): GPT2Attention(\n",
+       "          (c_attn): Conv1D()\n",
+       "          (c_proj): Conv1D()\n",
+       "          (attn_dropout): Dropout(p=0.1, inplace=False)\n",
+       "          (resid_dropout): Dropout(p=0.1, inplace=False)\n",
+       "        )\n",
+       "        (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
+       "        (mlp): GPT2MLP(\n",
+       "          (c_fc): Conv1D()\n",
+       "          (c_proj): Conv1D()\n",
+       "          (act): NewGELUActivation()\n",
+       "          (dropout): Dropout(p=0.1, inplace=False)\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "    (ln_f): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
+       "  )\n",
+       "  (lm_head): Linear(in_features=768, out_features=13, bias=False)\n",
+       ")"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "modelo.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 1/2 --- Erro: 0.10058706998825073\n",
+      "Epoch: 2/2 --- Erro: 0.05222655460238457\n",
+      "CPU times: user 6min 51s, sys: 899 ms, total: 6min 52s\n",
+      "Wall time: 6min 55s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\n",
+    "# Iniciando o loop para as épocas de treinamento\n",
+    "for epoch in range(num_epochs):\n",
+    "\n",
+    "    # Iterando por cada batch (conjunto) de dados de entrada e alvos no dataset de treinamento\n",
+    "    for source, targets in dados:\n",
+    "\n",
+    "        # Resetando os gradientes acumulados no otimizador\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        # Calculando a perda (loss) através da entropia cruzada entre as previsões do modelo e os alvos verdadeiros. \n",
+    "        # Os tensores são \"achatados\" para que possam ser passados para a função de entropia cruzada. \n",
+    "        # O índice do token de preenchimento (pad_token) é ignorado no cálculo da perda.\n",
+    "        loss = F.cross_entropy(modelo(source).logits.flatten(end_dim = 1), \n",
+    "                               targets.flatten(end_dim = 1), \n",
+    "                               ignore_index = tokenizer.pad_token_id)\n",
+    "\n",
+    "        # Calculando os gradientes da perda em relação aos parâmetros do modelo\n",
+    "        accelerator.backward(loss)\n",
+    "\n",
+    "        # Atualizando os parâmetros do modelo utilizando os gradientes calculados\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        # Recalculando a perda após a etapa de otimização. \n",
+    "        loss = F.cross_entropy(modelo(source).logits.flatten(end_dim = 1), \n",
+    "                               targets.flatten(end_dim = 1), \n",
+    "                               ignore_index = tokenizer.pad_token_id)\n",
+    "\n",
+    "    # Imprimindo a época atual e a perda após cada época de treinamento\n",
+    "    print(f'Epoch: {epoch+1}/{num_epochs} --- Erro: {loss.item()}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Avaliação do Modelo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Definindo a função gera_solution com três parâmetros: input, solution_length e model\n",
+    "def faz_previsao(entrada, solution_length = 6, model = modelo):\n",
+    "\n",
+    "    # Colocando o modelo em modo de avaliação. \n",
+    "    model.eval()\n",
+    "\n",
+    "    # Convertendo a entrada (string) em tensor utilizando o tokenizer. \n",
+    "    # O tensor é uma estrutura de dados que o modelo de aprendizado de máquina pode processar.\n",
+    "    entrada = torch.tensor(tokenizer(entrada))\n",
+    "\n",
+    "    # Enviando o tensor de entrada para o dispositivo de cálculo disponível (CPU ou GPU)\n",
+    "    entrada = entrada.to(accelerator.device)\n",
+    "\n",
+    "    # Iniciando uma lista vazia para armazenar a solução\n",
+    "    solution = []\n",
+    "\n",
+    "    # Loop que gera a solução de comprimento solution_length\n",
+    "    for i in range(solution_length):\n",
+    "\n",
+    "        # Alimentando a entrada atual ao modelo e obtendo a saída\n",
+    "        saida = model(entrada)\n",
+    "\n",
+    "        # Pegando o índice do maior valor no último conjunto de logits (log-odds) da saída, \n",
+    "        # que é a previsão do modelo para o próximo token\n",
+    "        predicted = saida.logits[-1].argmax()\n",
+    "\n",
+    "        # Concatenando a previsão atual com a entrada atual. \n",
+    "        # Isso servirá como a nova entrada para a próxima iteração.\n",
+    "        entrada = torch.cat((entrada, predicted.unsqueeze(0)), dim = 0)\n",
+    "\n",
+    "        # Adicionando a previsão atual à lista de soluções e convertendo o tensor em um número Python padrão\n",
+    "        solution.append(predicted.cpu().item())\n",
+    "\n",
+    "    # Decodificando a lista de soluções para obter a string de saída e retornando-a\n",
+    "    return tokenizer.decode(solution)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Definindo a função avalia_modelo com dois parâmetros: num_samples e log\n",
+    "def avalia_modelo(num_samples = 1000, log = False):\n",
+    "\n",
+    "    # Iniciando um contador para as previsões corretas\n",
+    "    correct = 0\n",
+    "\n",
+    "    # Loop que itera num_samples vezes\n",
+    "    for i in range(num_samples):\n",
+    "\n",
+    "        # Obtendo a entrada e o alvo (resposta correta) do i-ésimo exemplo do conjunto de teste\n",
+    "        entrada, target = dataset_teste[i]\n",
+    "\n",
+    "        # Convertendo os tensores de entrada e alvo em arrays numpy para processamento posterior\n",
+    "        entrada = entrada.cpu().numpy()\n",
+    "        target = target.cpu().numpy()\n",
+    "\n",
+    "        # Decodificando a entrada e o alvo utilizando o tokenizer\n",
+    "        entrada = tokenizer.decode(entrada[:sequence_length])\n",
+    "        target = tokenizer.decode(target[sequence_length-1:])\n",
+    "\n",
+    "        # Gerando a previsão utilizando a função faz_previsao\n",
+    "        predicted = faz_previsao(entrada, solution_length = result_length, model = modelo)\n",
+    " \n",
+    "        # Se a previsão for igual ao alvo, incrementa o contador de previsões corretas\n",
+    "        if target == predicted:\n",
+    "            correct += 1\n",
+    "            # Se log for True, imprime detalhes do exemplo e a previsão correta\n",
+    "            if log:\n",
+    "                print(f'Acerto do Modelo: Input: {entrada} Target: {target} Previsão: {predicted}')\n",
+    "        else:\n",
+    "            # Se log for True, imprime detalhes do exemplo e a previsão errada\n",
+    "            if log:\n",
+    "                print(f'Erro do Modelo: Input: {entrada} Target: {target} Previsão: {predicted}')\n",
+    "\n",
+    "    # Ao final do loop, calcula a acurácia (número de previsões corretas dividido pelo número total de exemplos) \n",
+    "    print(f'Acurácia: {correct/num_samples}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Acerto do Modelo: Input: 0 + 1 = Target: 0 1 Previsão: 0 1\n",
+      "Acerto do Modelo: Input: 0 + 3 = Target: 0 3 Previsão: 0 3\n",
+      "Acerto do Modelo: Input: 1 + 8 = Target: 0 9 Previsão: 0 9\n",
+      "Acerto do Modelo: Input: 2 + 4 = Target: 0 6 Previsão: 0 6\n",
+      "Acerto do Modelo: Input: 2 + 4 = Target: 0 6 Previsão: 0 6\n",
+      "Acerto do Modelo: Input: 5 + 8 = Target: 1 3 Previsão: 1 3\n",
+      "Acerto do Modelo: Input: 1 + 4 = Target: 0 5 Previsão: 0 5\n",
+      "Acerto do Modelo: Input: 8 + 9 = Target: 1 7 Previsão: 1 7\n",
+      "Acerto do Modelo: Input: 5 + 9 = Target: 1 4 Previsão: 1 4\n",
+      "Acerto do Modelo: Input: 2 + 4 = Target: 0 6 Previsão: 0 6\n",
+      "Acurácia: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Executa a função\n",
+    "avalia_modelo(num_samples = 10, log = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Acurácia: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Executa a função\n",
+    "avalia_modelo(num_samples = 1000, log = False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "transformers.models.gpt2.modeling_gpt2.GPT2LMHeadModel"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(modelo)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "modelo.save_pretrained(\"modelos/modelo_final\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fim"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "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.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}