pipeline_com_scikit_learn.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "<img src=\"https://raw.githubusercontent.com/dadosaocubo/classificacao/master/DadosAoCubo.png\" alt=\"drawing\" width=\"500\"/>"
      ],
      "metadata": {
        "id": "j2ObM_zkjP1d"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cqCKVuzdmoTE"
      },
      "source": [
        "# Pipeline SKlearn"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJElcCQ6DwXv"
      },
      "source": [
        "[__D³__](https://dadosaocubo.com/) by [__Tiago Dias__](https://www.linkedin.com/in/diasctiago/) \n",
        "<br/><br/>\n",
        "Objetivo: Construir um modelo de machine learning utilizando o pipeline do pacote scikit-learn. Dessa forma, vamos abordar de forma prática técnicas de NLP para realizar a classificação de produtos.\n",
        "<br/><br/>\n",
        "Tópicos da aula:\n",
        "*   O que é Machine Learning?\n",
        "*   O que são algoritmos de classificação?\n",
        "*   O que é NLP?\n",
        "*   Conhecendo a biblioteca scikit-learn.\n",
        "*   Por que usar pipelines em modelos de ML?\n",
        "*   Pipeline do Scikit-Learn ao Cubo\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s_55fizEpizx"
      },
      "source": [
        "## O que é Machine Learning?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e9__ga2jp0VP"
      },
      "source": [
        "Machine Learning também conhecido como ML, ou em português como Aprendizado de Máquina, é a forma como algoritmos são treinados para reconhecer padrões e generalizar decisões baseadas em dados. É uma parte da inteligência artifical que se baseia na idea onde as máquinas podem gerar uma resposta a partir de uma análise prévia em um grande conjunto de dados. \n",
        "<br/><br/>\n",
        "No aprendizado de máquina, temos alguns tipos de aprendizados, são eles: supervisionado, não supervisionado e por reforço. Onde podemos resolver problemas de regressão, classificação, agrupamento entre outros. \n",
        "<br/><br/>\n",
        "Aqui veremos a resolução de um problema de classificação com NLP!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BfsvuQWRpovw"
      },
      "source": [
        "## O que são algoritmos de classificação?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xliieHRIp2Vs"
      },
      "source": [
        "Os problemas de classificação são comuns e se resumem em uma tarefa de atribuição de classe dada uma observação de dados.\n",
        "<br/><br/>\n",
        "Vejamos, se temos um conjunto de dados, cada exemplo que temos seria uma observação. Já a classe desse exemplo seria a classificação do mesmo. Por exemplo, se temos um conjunto de fotos de gatos e cachorros, e queremos fazer a classificação das fotos que são gatos. Cada foto será uma observação e a nossa classe será gato. Para resolver o nosso problema vamos classificar cada observação em positiva e negativa (O que vai ser positivo e negativo depende da narrativa do problema). Portanto temos uma classificação binária.\n",
        "<br/><br/>\n",
        "Mas poderia ter outro tipo de classificação? Claro, pegamos o mesmo problema acima e acrescentamos fotos de coelho. Assim, podemos ter um novo problema e queremos fazer a classificação por animal. Neste caso temos 3 classes de animais para fazer a classificação, gato, cachorro e coelho. Dessa forma teríamos uma classificação multiclasse."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ocMpURmpqAb"
      },
      "source": [
        "## O que é NLP?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y7nAuP_4qApB"
      },
      "source": [
        "O  processamento de linguagem natural ou NLP é a área de estudo que busca fazer com que a máquina possa compreender e simular a linguagem humana. Em outras palavras, é fazer o computador receber uma frase e ter uma “opinião” sobre ela.<br/><br/>\n",
        "Na ciência de dados e inteligência artificial a NLP tem áreas de estudos específicas, além disso é tratada com muito carinho pois é a chave para resolução de muitos problemas atuais. As soluções vão desde classificação de textos, até soluções mais complexas de análises de sentimentos.\n",
        "<br/><br/>\n",
        "Chatbots e assistentes virtuais são outras soluções que estão em alta relacionadas a NLP. Os chatbots podem ter soluções simples, como respostas prontas relacionadas a um manual técnico de instruções, até soluções mais complexas de interações de diálogos com seres humanos, como o famoso Watson da  IBM. Dessa mesma forma estão os assistentes virtuais com reconhecimento de voz e interações dos mais diversos temas, por exemplo, a Siri do iPhone ou a Alexa da Amazon.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L7ju2616psvY"
      },
      "source": [
        "## Conhecendo a biblioteca scikit-learn.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OlqiPj3lqCIq"
      },
      "source": [
        "É uma lib de Machine Learning para Python e temos a seguinte definição da própria biblioteca: \"Scikit-learn é uma biblioteca de aprendizado de máquina de código aberto que oferece suporte ao aprendizado supervisionado e não supervisionado. Ele também fornece várias ferramentas para ajuste de modelos, pré-processamento de dados, seleção de modelos, avaliação de modelos e muitas outras utilidades.\"\n",
        "<br/><br/>\n",
        "Dessa forma, ela é utilizada por toda a comunidade, seja para estudos ou profissionalmente. Muito bem documentada e com uma vasta quantidade de exemplos na própria documentação. Ela disponibiliza algoritmos de regressão, classificação, clusterização, pré-processamento de dados e ainda construção de modelos de ML com pipelines."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pAYSiWQ5pxGT"
      },
      "source": [
        "## Por que usar pipelines em modelos de ML?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0V4v1OcCqGKV"
      },
      "source": [
        "O objetivo do pipeline é reunir as várias etapas do processo, que podem ser validadas de forma cruzada ao definir parâmetros diferentes. Além de  tornar o código mais simples e otimizar o deploy do modelo. Sendo assim, facilita desde o entendimento da solução, como a manutenção do código no futuro."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t9eSPPRmUEby"
      },
      "source": [
        "## Pipeline do Scikit-Learn ao Cubo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q1kAjsFvXxIb"
      },
      "source": [
        "Criando uma solução de NLP com scikit-learn. A partir de uma base de dados mercadológica onde temos itens classificados por departamento, treinaremos o algoritmo para classificar novos produtos com os departamentos conhecidos. \n",
        "<br/><br/>\n",
        "Para que isso seja possível veremos algumas técnicas que são utilizadas para NLP. Construiremos um processo para chegar a solução desse problema, utilizando a linguagem python. Para finalizar, criaremos um pipeline para deploy do modelo.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4eakEWy_62vS"
      },
      "source": [
        "### Importando bibliotecas"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "F5Tc6cI9Kvpj"
      },
      "outputs": [],
      "source": [
        "# lib para leitura dos dados\n",
        "import pandas as pd\n",
        "# funções transformação dos dados para input do modelo\n",
        "from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer\n",
        "# modelo de classificação\n",
        "from sklearn.svm import LinearSVC\n",
        "# funções para construção do pipeline\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.base import BaseEstimator, TransformerMixin"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_-re6wFx668E"
      },
      "source": [
        "### Carregando dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 112
        },
        "id": "h8giii59K9Aq",
        "outputId": "1f7fe1de-1487-4a0e-8d57-b89a3283ed98"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                descricao            departamento\n",
              "0  PASTA INT VITAPOWER 1,005KG AMEND/SHOT          MERCEARIA DOCE\n",
              "1            ESPONJA BETTANIN BRILHUS C/1  CUIDADOS COM A COZINHA"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-d13a0b53-29b2-49ec-909a-be0093afd53d\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <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>descricao</th>\n",
              "      <th>departamento</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>PASTA INT VITAPOWER 1,005KG AMEND/SHOT</td>\n",
              "      <td>MERCEARIA DOCE</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>ESPONJA BETTANIN BRILHUS C/1</td>\n",
              "      <td>CUIDADOS COM A COZINHA</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-d13a0b53-29b2-49ec-909a-be0093afd53d')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-d13a0b53-29b2-49ec-909a-be0093afd53d button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-d13a0b53-29b2-49ec-909a-be0093afd53d');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ],
      "source": [
        "df = pd.read_csv('https://raw.githubusercontent.com/dadosaocubo/nlp/master/base_mercadologica.csv')\n",
        "df.head(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DiuxPsfziq4-",
        "outputId": "d033b9a0-1349-4e94-a1e3-a9b374e59cd9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 22009 entries, 0 to 22008\n",
            "Data columns (total 2 columns):\n",
            " #   Column        Non-Null Count  Dtype \n",
            "---  ------        --------------  ----- \n",
            " 0   descricao     22009 non-null  object\n",
            " 1   departamento  22009 non-null  object\n",
            "dtypes: object(2)\n",
            "memory usage: 344.0+ KB\n"
          ]
        }
      ],
      "source": [
        "df.info()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Stop Words"
      ],
      "metadata": {
        "id": "5n2SMkC_kCMi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**O que são stop words?** São palavras que podemos remover para facilitar a análise do texto, não existe uma regra universal, vai depender muito de cada problema."
      ],
      "metadata": {
        "id": "ZUb4CjeVkDCd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stop_words = ['em','sao','ao','de','da','do','para','c','kg','un','ml',\n",
        "              'pct','und','das','no','ou','pc','gr','pt','cm','vd','com',\n",
        "              'sem','gfa','jg','la','1','2','3','4','5','6','7','8','9',\n",
        "              '0','a','b','c','d','e','lt','f','g','h','i','j','k','l',\n",
        "              'm','n','o','p','q','r','s','t','u','v','x','w','y','z']"
      ],
      "metadata": {
        "id": "cir3iTTLkDOF"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WWkZxKu3C7Pq"
      },
      "source": [
        "### Criação do Modelo com Pipeline\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MG0aGlOgWwl5"
      },
      "source": [
        "\n",
        "Criação de uma função para utilização no pipeline.\n",
        "*   **BaseEstimator:** Classe base para todos os estimadores no scikit-learn.\n",
        "*   **TransformerMixin:** Classe Mixin para todos os transformadores no scikit-learn."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NKtbZDIQEAbq"
      },
      "source": [
        "#### Criando uma Função de Transformação"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "557S2DE9CT9p"
      },
      "outputs": [],
      "source": [
        "# Um transformador para colunas\n",
        "class TColumns(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self):\n",
        "        print()\n",
        "    # Função de fit ds dados de entrada\n",
        "    def fit(self, X, y=None):\n",
        "        return self\n",
        "    # Função de tranformação dos dados de entrada\n",
        "    def transform(self, X):\n",
        "        # Primeiro realizamos a cópia do DataFrame 'X' de entrada\n",
        "        data = X.copy()\n",
        "        data['descricao'] = data['descricao'].str.replace('[,.:;!?]+', ' ', regex=True).copy()\n",
        "        data['descricao'] = data['descricao'].str.replace('[/<>()|\\+\\-\\$%&#@\\'\\\"]+', ' ', regex=True).copy()\n",
        "        data['descricao'] = data['descricao'].str.replace('[0-9]+', '', regex=True)\n",
        "        # Retornamos um novo dataframe com as colunas\n",
        "        return data.descricao"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pU98XbrINyd8"
      },
      "source": [
        "#### Definindo o Pipeline do Modelo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HHi8BmSYCT_z",
        "outputId": "5b1daaf8-4426-4795-ba09-0d5e34f43266"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "# Criando uma instância do transformador das colunas\n",
        "tco = TColumns()\n",
        "\n",
        "# Criando uma instância do CountVectorizer\n",
        "cvt = CountVectorizer(strip_accents='ascii', lowercase=True, stop_words=stop_words)\n",
        "\n",
        "# Criando uma instância do TfidfTransformer\n",
        "tfi = TfidfTransformer(use_idf=True)\n",
        "\n",
        "# Criando uma instância do modelo LinearSVC\n",
        "clf = LinearSVC()\n",
        "\n",
        "# Criando a Pipeline, adicionando o nosso transformador seguido de um modelo de classificação\n",
        "skl_pipeline = Pipeline(steps=[('Transformer', tco), \n",
        "                               ('CountVectorizer', cvt), \n",
        "                               ('TfidfTransformer', tfi), \n",
        "                               ('Model', clf)])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0tNXO4sN5vD"
      },
      "source": [
        "#### Treinando o Modelo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jb7SuovfCUDV",
        "outputId": "37fc805f-1530-4bb7-95af-4466bbc25158"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Pipeline(steps=[('Transformer', TColumns()),\n",
              "                ('CountVectorizer',\n",
              "                 CountVectorizer(stop_words=['em', 'sao', 'ao', 'de', 'da',\n",
              "                                             'do', 'para', 'c', 'kg', 'un',\n",
              "                                             'ml', 'pct', 'und', 'das', 'no',\n",
              "                                             'ou', 'pc', 'gr', 'pt', 'cm', 'vd',\n",
              "                                             'com', 'sem', 'gfa', 'jg', 'la',\n",
              "                                             '1', '2', '3', '4', ...],\n",
              "                                 strip_accents='ascii')),\n",
              "                ('TfidfTransformer', TfidfTransformer()),\n",
              "                ('Model', LinearSVC())])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ],
      "source": [
        "# Executando Pipeline\n",
        "entrada = df[['descricao']]\n",
        "saida = df['departamento']\n",
        "skl_pipeline.fit(entrada, saida)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D9Z51ETQN9yX"
      },
      "source": [
        "#### Utilizando o Modelo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rvast0ZIXPpz"
      },
      "source": [
        "Para realizar a predição do modelo criado com pipeline, só é necessário fazer um predict no pipeline, passado os dados em forma de dataframe como o seguinte código **skl_pipeline.predict(df_predict)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-cfSNKWVJxW4",
        "outputId": "51ab6fe1-2a97-44d2-dc61-9aaa7fa48f31"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Informe o item para classificar ou -1 para encerrar o programa: CELULAR\n",
            "O item CELULAR está na seção ELETRO\n",
            "\n",
            "Informe o item para classificar ou -1 para encerrar o programa: CADERNO PARA NOTAS\n",
            "O item CADERNO PARA NOTAS está na seção PAPELARIA\n",
            "\n",
            "Informe o item para classificar ou -1 para encerrar o programa: FONEDE OUVIDO\n",
            "O item FONEDE OUVIDO está na seção ELETRO\n",
            "\n",
            "Informe o item para classificar ou -1 para encerrar o programa: RAÇÃO PARA DOG\n",
            "O item RAÇÃO PARA DOG está na seção PET SHOP\n",
            "\n",
            "Informe o item para classificar ou -1 para encerrar o programa: MANGA\n",
            "O item MANGA está na seção HORTIFRUTI\n",
            "\n",
            "Informe o item para classificar ou -1 para encerrar o programa: MANGA PARA MOTO\n",
            "O item MANGA PARA MOTO está na seção HORTIFRUTI\n",
            "\n",
            "Informe o item para classificar ou -1 para encerrar o programa: -1\n",
            "Obrigado! Volte sempre!!!\n"
          ]
        }
      ],
      "source": [
        "# função para utilização do pipeline\n",
        "fim = '0'\n",
        "while (fim != '-1'):\n",
        "  descricao = input('Informe o item para classificar ou -1 para encerrar o programa: ')\n",
        "  fim = descricao\n",
        "  if fim != '-1':\n",
        "    df_predict = pd.DataFrame([descricao], columns=['descricao'])\n",
        "    print('O item {} está na seção {}\\n'.format(descricao.upper(), skl_pipeline.predict(df_predict)[0]))\n",
        "  else:\n",
        "    print('Obrigado! Volte sempre!!!')"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": " Pipeline_SKlearn.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}