Upload Mini-Projeto3-Deploy.ipynb

Mini-Projeto3-Deploy.ipynb

@@ -0,0 +1,375 @@
+{
+ "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 - Deploy</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": [
+    "# https://pypi.org/project/gradio/\n",
+    "!pip install -q gradio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Imports\n",
+    "import torch\n",
+    "import gradio as gr\n",
+    "from transformers import AutoModelForCausalLM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Author: Data Science Academy\n",
+      "\n",
+      "torch : 2.0.1\n",
+      "gradio: 3.39.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": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Carrega o modelo\n",
+    "modelo_llm = AutoModelForCausalLM.from_pretrained(\"modelos/modelo_final\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cria o objeto\n",
+    "tokenizer = DSATokenizer(13)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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_llm):\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",
+    "    # 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": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'0 8'"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Testa a função\n",
+    "faz_previsao('3 + 5 =', solution_length = 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Função para retornar a função que faz a previsão\n",
+    "def funcsolve(entrada):\n",
+    "    return faz_previsao(entrada, solution_length = 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cria a web app\n",
+    "webapp = gr.Interface(fn = funcsolve, \n",
+    "                      inputs = [gr.Textbox(label = \"Dados de Entrada\", \n",
+    "                                           lines = 1, \n",
+    "                                           info = \"Os dados devem estar na forma: '1 + 2 =' com um único espaço entre cada caractere e apenas números de um dígito são permitidos.\")],\n",
+    "                      outputs = [gr.Textbox(label = \"Resultado (Previsão do Modelo)\", lines = 1)],\n",
+    "                      title = \"Deploy de LLM Após o Fine-Tuning\",\n",
+    "                      description = \"Digite os dados de entrada e clique no botão Submit para o modelo fazer a previsão.\",\n",
+    "                      examples = [\"5 + 3 =\", \"2 + 9 =\"]) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Traceback (most recent call last):\n",
+      "  File \"/Users/dmpm/anaconda3/lib/python3.10/site-packages/gradio/routes.py\", line 442, in run_predict\n",
+      "    output = await app.get_blocks().process_api(\n",
+      "  File \"/Users/dmpm/anaconda3/lib/python3.10/site-packages/gradio/blocks.py\", line 1392, in process_api\n",
+      "    result = await self.call_function(\n",
+      "  File \"/Users/dmpm/anaconda3/lib/python3.10/site-packages/gradio/blocks.py\", line 1097, in call_function\n",
+      "    prediction = await anyio.to_thread.run_sync(\n",
+      "  File \"/Users/dmpm/anaconda3/lib/python3.10/site-packages/anyio/to_thread.py\", line 28, in run_sync\n",
+      "    return await get_asynclib().run_sync_in_worker_thread(func, *args, cancellable=cancellable,\n",
+      "  File \"/Users/dmpm/anaconda3/lib/python3.10/site-packages/anyio/_backends/_asyncio.py\", line 818, in run_sync_in_worker_thread\n",
+      "    return await future\n",
+      "  File \"/Users/dmpm/anaconda3/lib/python3.10/site-packages/anyio/_backends/_asyncio.py\", line 754, in run\n",
+      "    result = context.run(func, *args)\n",
+      "  File \"/Users/dmpm/anaconda3/lib/python3.10/site-packages/gradio/utils.py\", line 703, in wrapper\n",
+      "    response = f(*args, **kwargs)\n",
+      "  File \"/var/folders/dc/lqrc3k5j4438r150cbrdr_000000gn/T/ipykernel_5062/1694334565.py\", line 3, in funcsolve\n",
+      "    return faz_previsao(entrada, solution_length = 2)\n",
+      "  File \"/var/folders/dc/lqrc3k5j4438r150cbrdr_000000gn/T/ipykernel_5062/2965097493.py\", line 9, in faz_previsao\n",
+      "    entrada = torch.tensor(tokenizer(entrada))\n",
+      "  File \"/var/folders/dc/lqrc3k5j4438r150cbrdr_000000gn/T/ipykernel_5062/3426772234.py\", line 32, in __call__\n",
+      "    return [self.encoder[t] for t in text.split()]\n",
+      "  File \"/var/folders/dc/lqrc3k5j4438r150cbrdr_000000gn/T/ipykernel_5062/3426772234.py\", line 32, in <listcomp>\n",
+      "    return [self.encoder[t] for t in text.split()]\n",
+      "KeyError: '122220'\n"
+     ]
+    }
+   ],
+   "source": [
+    "webapp.launch()"
+   ]
+  },
+  {
+   "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
+}