projeto_previsao_vendas_rossmann_hypothesis_7.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "authorship_tag": "ABX9TyNeDj7smeraZjvMCnJ/is+p",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Anello92/sales_forecast_project/blob/master/projeto_previsao_vendas_rossmann_hypothesis_7.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Rossmann Pharmacies Sales Forecast Project**\n",
        "Este projeto tem como objetivo desenvolver um sistema de previsão de vendas para a empresa Rossmann, uma rede de mais de 3.000 farmácias operando em 7 países da Europa. A necessidade surgiu após uma reunião de resultados, na qual os gerentes de lojas da Rossmann foram incumbidos de fornecer previsões diárias de vendas para as próximas seis semanas. Com mais de mil gerentes requisitando suas próprias previsões, o desafio é criar uma solução precisa e eficiente que considere as particularidades de cada loja, incluindo fatores como promoções, competição, escolas, feriados, sazonalidade e localidade.\n",
        "\n",
        "### Demand Motivation\n",
        "Antes de começar a elaborar a solução, é essencial entender a motivação por trás dessa demanda. Em vez de simplesmente executar uma solução pronta, é necessário questionar e compreender as razões que levaram à necessidade dessa previsão. O foco deve ser na causa raiz do problema para garantir que a solução atenda adequadamente às expectativas e necessidades dos gerentes.\n",
        "\n",
        "### Solution Format\n",
        "Além disso, é fundamental definir o formato da solução. Para isso, é importante saber se os gerentes precisam de previsões diárias, semanais ou mensais, e se desejam uma granularidade específica, como por loja, produto ou categoria. Também é relevante determinar o tipo de problema, se é uma tarefa de classificação ou previsão, para identificar potenciais métodos adequados para abordar a questão.\n",
        "\n",
        "Uma vez que esses aspectos foram compreendidos, a equipe de dados poderá buscar os dados disponíveis no sistema da Rossmann e explorar outras fontes relevantes, garantindo que todas as informações necessárias estejam disponíveis para desenvolver uma solução precisa e confiável.\n",
        "\n",
        "\n",
        "### Project's goal\n",
        "Este projeto visa fornecer uma previsão curada para cada loja, considerando suas circunstâncias específicas. Ao criar um sistema acessível através de dispositivos móveis, como celulares, os gerentes terão fácil acesso às previsões, possibilitando uma tomada de decisão mais assertiva em relação a promoções, investimentos, e planejamento de estoque.\n",
        "\n",
        "A combinação de técnicas de análise de dados, como regressão e redes neurais, será explorada para encontrar a melhor solução para o problema. O desenvolvimento da solução será feito com o envolvimento dos gerentes, garantindo que suas necessidades sejam atendidas e que a solução final seja efetivamente adotada.\n",
        "\n",
        "Com base nesse contexto e nas informações disponíveis, a equipe buscará aprimorar a eficiência das previsões de vendas da Rossmann, oferecendo insights valiosos para otimizar o desempenho de suas lojas e impulsionar os resultados de negócios."
      ],
      "metadata": {
        "id": "eDk9blo25hko"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **0.0 Import Libraries and Load Data**"
      ],
      "metadata": {
        "id": "qhrKnh7xVK8k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Instalando pacotes necessários\n",
        "!pip install scikit-learn\n",
        "!pip install inflection -q\n",
        "!pip install tabulate -q\n",
        "!pip install seaborn\n",
        "!pip install --upgrade seaborn -q\n",
        "!pip install sklearn\n",
        "!pip install Ipython -q\n",
        "!pip install boruta -q\n",
        "!pip install scipy\n",
        "\n",
        "# Importando bibliotecas\n",
        "import pandas               as pd\n",
        "import numpy                as np\n",
        "import seaborn              as sns\n",
        "import matplotlib.pyplot    as plt\n",
        "import matplotlib.gridspec  as gridspec\n",
        "\n",
        "import inflection\n",
        "import math\n",
        "import datetime\n",
        "import warnings\n",
        "\n",
        "# Suprimindo avisos\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Importando recursos específicos\n",
        "from scipy.stats            import chi2_contingency\n",
        "from IPython.display        import Image, HTML\n",
        "from boruta                 import BorutaPy\n",
        "\n",
        "# Importando modelos e métricas de avaliação\n",
        "from sklearn.ensemble       import RandomForestRegressor\n",
        "from sklearn.metrics        import mean_absolute_error, mean_squared_log_error, mean_squared_error\n",
        "from sklearn.linear_model   import LinearRegression, Lasso\n",
        "from sklearn.preprocessing  import RobustScaler, MinMaxScaler, LabelEncoder"
      ],
      "metadata": {
        "id": "QARguudr6HGG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **0.1 Helper Functions**"
      ],
      "metadata": {
        "id": "L1nwLkRgVQKA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def mean_absolute_percentage_error(y, yhat):\n",
        "    return np.mean(np.abs((y-yhat)/y))\n",
        "\n",
        "#-----------------------------------------------------------------\n",
        "\n",
        "def ml_error(model_name, y, yhat):\n",
        "    \"\"\"\n",
        "    Função para calcular erros comuns em modelos de machine learning.\n",
        "\n",
        "    Argumentos:\n",
        "    model_name (str): O nome do modelo.\n",
        "    y (pd.Series ou np.array): Os valores verdadeiros.\n",
        "    yhat (pd.Series ou np.array): Os valores previstos pelo modelo.\n",
        "\n",
        "    Retorna:\n",
        "    DataFrame pandas com o nome do modelo e os erros calculados.\n",
        "    \"\"\"\n",
        "    # Calcula o Mean Absolute Error\n",
        "    mae = mean_absolute_error(y, yhat)\n",
        "\n",
        "    # Calcula o Mean Absolute Percentage Error\n",
        "    mape = np.mean(np.abs((y - yhat) / y)) * 100\n",
        "\n",
        "    # Calcula o Root Mean Squared Error\n",
        "    rmse = np.sqrt(mean_squared_error(y, yhat))\n",
        "\n",
        "    # Retorna um DataFrame com os resultados\n",
        "    return pd.DataFrame({\n",
        "        'Model Name': [model_name],\n",
        "        'MAE': [mae],\n",
        "        'MAPE': [mape],\n",
        "        'RMSE': [rmse]\n",
        "    })\n",
        "\n",
        "# -----------------------------------------------------------------\n",
        "\n",
        "def cramer_v(x, y):\n",
        "    # Cria a matriz de contigência\n",
        "    contingency_matrix = pd.crosstab(x, y).values\n",
        "    # Cálcula o valor total\n",
        "    n = contingency_matrix.sum()\n",
        "    # Obtem as dimensões da matriz\n",
        "    rows, cols = contingency_matrix.shape\n",
        "\n",
        "    # Realiza o teste qui-quadrado\n",
        "    chi2 = chi2_contingency(contingency_matrix)[0]\n",
        "    # Corrige o valor qui-quadrado pelo bias\n",
        "    chi2corr = max(0, chi2 - (cols-1)*(rows-1)/(n-1))\n",
        "\n",
        "    # Corrige as dimensões da matriz pelo bias\n",
        "    rows_corr = rows - (rows-1)**2/(n-1)\n",
        "    cols_corr = cols - (cols-1)**2/(n-1)\n",
        "\n",
        "    # Cálcula a estatística de Cramér-V\n",
        "    cramerv = np.sqrt((chi2corr/n)/(min(cols_corr-1, rows_corr-1)))\n",
        "\n",
        "    return cramerv\n",
        "\n",
        "# -----------------------------------------------------------------\n",
        "\n",
        "def jupyter_settings():\n",
        "    %matplotlib inline\n",
        "    %pylab inline\n",
        "\n",
        "    # Estilos e tamanho de figuras e fontes\n",
        "    plt.style.use('bmh')\n",
        "    plt.rcParams['figure.figsize'] = [25, 12]\n",
        "    plt.rcParams['font.size'] = 24\n",
        "    plt.rcParams['axes.labelsize'] = 20\n",
        "    plt.rcParams['axes.titlesize'] = 26\n",
        "    plt.rcParams['legend.fontsize'] = 18\n",
        "    plt.rcParams['xtick.labelsize'] = 16\n",
        "    plt.rcParams['ytick.labelsize'] = 16\n",
        "    plt.rcParams['axes.grid'] = True\n",
        "    plt.rcParams['grid.alpha'] = 0.53\n",
        "\n",
        "    # Configurações do Pandas\n",
        "    pd.options.display.max_columns = None\n",
        "    pd.options.display.max_rows = None\n",
        "    pd.options.display.float_format = '{:,.2f}'.format\n",
        "    pd.options.display.precision = 2\n",
        "\n",
        "    # Configurações para exibir todas as colunas e linhas\n",
        "    pd.set_option('display.expand_frame_repr', False)\n",
        "\n",
        "    # Configurações de largura do notebook\n",
        "    display(HTML('<style>.container {width:100% !important;}</style>'))\n",
        "\n",
        "    # Impede a exibição de avisos desnecessários\n",
        "    import warnings\n",
        "    warnings.filterwarnings('ignore')\n"
      ],
      "metadata": {
        "id": "CBAT4SPr67ji"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **0.2 Loading Data**"
      ],
      "metadata": {
        "id": "9IdyYNrtVQ8e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Carregando o arquivo 'train.csv' como DataFrame df_sales_raw, com a opção low_memory=False para evitar problemas de memória\n",
        "df_sales_raw = pd.read_csv('train.csv', low_memory=False)\n",
        "\n",
        "# Carregando o arquivo 'store.csv' como DataFrame df_store_raw, com a opção low_memory=False para evitar problemas de memória\n",
        "df_store_raw = pd.read_csv('store.csv', low_memory=False)"
      ],
      "metadata": {
        "id": "7yuG1stwVW7U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste trecho, utilizaremos a **função read_csv** do **pandas**, que é uma poderosa biblioteca de análise e manipulação de dados em Python. A função **read_csv** é usada para **ler dados tabulares**, como um **arquivo CSV**, e criar um **DataFrame** do **pandas**.\n",
        "\n",
        "O **primeiro argumento** para a função **read_cs** é o **caminho** para o **arquivo** que queremos ler. No nosso caso, o arquivo se chama **'Train.csv'**.\n",
        "\n",
        "O **segundo argumento** é **low_memory**. Neste exemplo, estamos definindo **low_memory** como **False**, o que instrui a função **read_csv** a carregar todo o arquivo na memória de uma vez, em vez de ler o arquivo em pedaços. Se **low_memory** fosse definido como **True**, a função leria o arquivo em pedaços para economizar memória.\n",
        "\n",
        "A decisão de **definir low_memory** como **True** ou **False** depende da **capacidade de memória do computador**. Se tentarmos carregar um arquivo muito grande e o computador tiver memória limitada, pode receber um erro ou aviso.\n"
      ],
      "metadata": {
        "id": "vAW_QU23WD4A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Merge dos DataFrames df_sales_raw e df_store_raw com base na coluna 'Store'\n",
        "df_raw = pd.merge(df_sales_raw, df_store_raw, how='left', on='Store')\n",
        "\n",
        "# Amostra aleatória do DataFrame resultante\n",
        "df_raw.sample()"
      ],
      "metadata": {
        "id": "F90tHgMQvqIQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Após carregarmos os arquivos, realizamos uma operação de **'merge'** (fusão) em dois conjuntos de dados utilizando a função **merge** do **pandas**. Essa operação é semelhante a um **'JOIN' em SQL**, onde os dados de dois (ou mais) DataFrames são combinados com base em uma coluna (ou várias colunas) em comum.\n",
        "\n",
        "Para fazer isso, utilizamos a função **merge** do **pandas**, que aceita vários argumentos:\n",
        "\n",
        "- O **primeiro argumento** é o DataFrame que servirá como referência para a operação de **'merge'**. O **segundo argumento** é o DataFrame que será anexado ao primeiro. O argumento **'how'** especifica o tipo de **'merge'** a ser realizado. No nosso caso, o valor é **'outer'**, o que significa que queremos um **'merge'** que inclua **todas as linhas de ambos** os DataFrames, independentemente de haver uma correspondência entre as colunas.\n",
        "\n",
        "- O argumento **'on'** especifica a coluna(s) que serão usadas como chave para o **'merge'**. No nosso caso, a coluna é **'Store'**, que está presente em ambos os DataFrames.\n",
        "\n",
        "O resultado da operação de **'merge'** é armazenado em uma nova variável chamada **'df'**. Em resumo, a função **merge** é um método da classe pandas usado para combinar dois ou mais DataFrames com base em colunas em comum."
      ],
      "metadata": {
        "id": "n3kg03_iv7Sf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "###   **1.0 Data Description**"
      ],
      "metadata": {
        "id": "WHZNy6AZVUpm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Uma boa prática é fazer cópias do DataFrame sempre que se muda de sessão de análise em um notebook. Essa medida preventiva evita a perda dos dados originais durante a manipulação dos DataFrames em sessões subsequentes.\n",
        "\n",
        "Ao criar cópias, você preserva os dados originais e pode trabalhar com segurança em análises e transformações sem alterar o DataFrame original. Isso é especialmente útil quando se lida com grandes volumes de dados, pois evita a necessidade de reexecutar o notebook do início, economizando tempo de processamento."
      ],
      "metadata": {
        "id": "W5VmCw6g8z6A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criar uma cópia do DataFrame df_raw e armazená-lo em uma nova variável chamada df1\n",
        "df1 = df_raw.copy()"
      ],
      "metadata": {
        "id": "zeQgIY4jz09e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aqui, criamos a cópia do DataFrame **df_raw** e armazenamos em **df1**. Agora, podemos realizar análises e modificações em **df1** sem afetar os dados originais em **df_raw**, garantindo a integridade dos dados durante o processo de manipulação."
      ],
      "metadata": {
        "id": "Df0nmbY61C3a"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "###  **1.1 Rename Columns**"
      ],
      "metadata": {
        "id": "lsVVkrVV2PGx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Obter nomes das colunas presentes em df_raw.\n",
        "df_raw.columns"
      ],
      "metadata": {
        "id": "pLGlqi5BycKr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**É recomendável renomear as colunas para nomes mais intuitivos e fáceis de lembrar**. Isso pode ajudar a acelerar o desenvolvimento posterior, já que **os nomes das colunas serão frequentemente usados para explorar os dados, aplicar algoritmos, fazer gráficos, entre outros**.\n",
        "\n",
        "Embora os nomes das colunas no exemplo atual sejam bastante organizados e estejam no formato 'camel case' (alternando entre letras maiúsculas e minúsculas), **isso pode não ser o caso em um ambiente real, onde os nomes das colunas podem ser muito menos intuitivos**.\n",
        "\n",
        "Portanto, **é uma boa prática revisar e, se necessário, renomear as colunas no início do processo de análise de dados**."
      ],
      "metadata": {
        "id": "eVcARK3JypOf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cols_old = [\n",
        "'Store', 'DayOfWeek', 'Date', 'Sales', 'Customers', 'Open', 'Promo',\n",
        "'StateHoliday', 'SchoolHoliday', 'StoreType', 'Assortment',\n",
        "'CompetitionDistance', 'CompetitionOpenSinceMonth',\n",
        "'CompetitionOpenSinceYear', 'Promo2', 'Promo2SinceWeek',\n",
        "'Promo2SinceYear', 'PromoInterval']"
      ],
      "metadata": {
        "id": "qLwT6CtWyeK9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste código, estamos criando uma lista chamada **cols_old**, que contém os **nomes das colunas originais do DataFrame**. Essas colunas representam diferentes atributos relacionados às lojas e às vendas.\n",
        "\n",
        "- **'Store'**: Número identificador da loja.\n",
        "- **'DayOfWeek'**: Dia da semana (1 a 7).\n",
        "- **'Date'**: Data da venda.\n",
        "- **'Sales'**: Valor total das vendas para aquele dia e loja.\n",
        "- **'Customers'**: Número total de clientes naquela loja naquele dia.\n",
        "- **'Open'**: Indicador se a loja estava aberta (1) ou fechada (0) naquele dia.\n",
        "- **'Promo'**: Indicador se a loja estava realizando uma promoção naquele dia.\n",
        "- **'StateHoliday'**: Indicador de feriado estadual (a, b, c) ou nenhum (0).\n",
        "- **'SchoolHoliday'**: Indicador de feriado escolar (1) ou nenhum (0).\n",
        "- **'StoreType'**: Tipo de loja (a, b, c, d).\n",
        "- **'Assortment'**: Nível de sortimento da loja (a, b, c).\n",
        "- **'CompetitionDistance'**: Distância em metros até a loja mais próxima da concorrência.\n",
        "- **'CompetitionOpenSinceMonth'**: Mês em que o concorrente mais próximo abriu.\n",
        "- **'CompetitionOpenSinceYear'**: Ano em que o concorrente mais próximo abriu.\n",
        "- **'Promo2'**: Indicador de participação em uma promoção contínua (0 ou 1).\n",
        "- **'Promo2SinceWeek'**: Semana em que a promoção contínua começou.\n",
        "- **'Promo2SinceYear'**: Ano em que a promoção contínua começou.\n",
        "- **'PromoInterval'**: Intervalo de frequência da promoção contínua.\n",
        "\n",
        "Essa lista é útil para referência rápida e para facilitar o acesso aos atributos específicos do DataFrame. É uma boa prática ter uma lista organizada das colunas originais, especialmente em projetos com muitos atributos, pois isso pode acelerar o desenvolvimento e a análise dos dados."
      ],
      "metadata": {
        "id": "N0z3xo5UzsoB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definindo a função lambda 'snakecase' que utiliza a biblioteca 'inflection' para converter os nomes para snake_case\n",
        "snakecase = lambda x: inflection.underscore(x)\n",
        "\n",
        "# Aplicando a função 'snakecase' a todos os elementos da lista 'cols_old' usando a função 'map'\n",
        "cols_new = list(map(snakecase, cols_old))"
      ],
      "metadata": {
        "id": "6EaNnseT0On2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Criamos a função **snake_case**. Neste código, a função snakecase é definida como uma função lambda que utiliza a biblioteca **inflection** para converter os nomes das colunas para o estilo **snake_case**. A função **map** é então utilizada para aplicar a função **snakecase** a todos os elementos da lista **cols_old**. O resultado dessa operação é armazenado na lista **cols_new**, que conterá os nomes das colunas no novo estilo de nomenclatura."
      ],
      "metadata": {
        "id": "GkCFhJ_Z1eme"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Renomeando as colunas do DataFrame df1 com os nomes da lista cols_new\n",
        "df1.columns = cols_new\n",
        "\n",
        "# Exibindo os nomes das colunas após o processo de renomeação\n",
        "df1.columns"
      ],
      "metadata": {
        "id": "fhz4OXh217TD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.2 Data Dimensions**\n",
        "Um passo crucial na descrição de nossos dados é determinar as dimensões do nosso DataFrame - o número de linhas e colunas. Para isso, utilizamos o método **shape** que fornece essas informaçõe"
      ],
      "metadata": {
        "id": "qDmF9DHy3Gvc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Imprime o número de linhas (registros) do DataFrame df1\n",
        "print('Número de Linhas: {}'.format(df1.shape[0]))\n",
        "\n",
        "# Imprime o número de colunas (atributos) do DataFrame df1\n",
        "print('Número de Colunas: {}'.format(df1.shape[1]))"
      ],
      "metadata": {
        "id": "D3p18Clj2Uh9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Após executar as instruções, constatamos que o DataFrame possui 1.017.209 linhas e 18 colunas. A quantidade de dados é considerável, mas gerenciável com nossos recursos atuais. Para conjuntos de dados maiores, opções como servidores AWS, Google Cloud ou Kaggle oferecem recursos computacionais robustos, gratuitos ou pagos."
      ],
      "metadata": {
        "id": "4fECaAre3eQT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.3 Data Types**\n",
        "\n",
        "O próximo passo na descrição dos dados é examinar os tipos de dados presentes no DataFrame. Para isso, utilizamos o método **dtypes**, que nos permite visualizar a coluna e o tipo de dado correspondente sem a necessidade de usar parênteses.\n"
      ],
      "metadata": {
        "id": "2U_iQes-4B_a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Verifica os tipos de dados (dtypes) de cada coluna do DataFrame 'df1'\n",
        "df1.dtypes"
      ],
      "metadata": {
        "id": "um5ovOe860sA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Isso nos permite identificar que colunas como 'Store' são do tipo int64 e 'Date' é do tipo objeto.\n",
        "\n",
        "No caso da coluna **'date'**, queremos alterar o formato de dados para que possamos tratá-la como uma data. Isso facilitará a realização de operações e análises temporais em nosso conjunto de dados."
      ],
      "metadata": {
        "id": "120D1sCU7LXQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Convertendo a coluna 'date' para o tipo de dado datetime e forçando erros a se tornarem NaT\n",
        "df1['date'] = pd.to_datetime(df1['date'], errors='coerce')\n",
        "\n",
        "# Exibindo os tipos de dados das colunas do DataFrame df1\n",
        "df1.dtypes"
      ],
      "metadata": {
        "id": "6XCu40UK4DqN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Usamos **pd.to_datetime** no **pandas** para converter a coluna 'Date' para o formato de data correto (datetime64).\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "8il9zZgV7QoE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.4 Check NA**\n",
        "O próximo passo é verificar dados nulos (NaN) para garantir a qualidade dos dados. Usamos o método isna() para identificar linhas com valores ausentes. Em seguida, utilizamos o método sum() para obter a soma de valores nulos por coluna."
      ],
      "metadata": {
        "id": "RYzcsO-O8jzR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Verifica a quantidade de valores ausentes (NaN) em cada coluna do DataFrame 'df1'.\n",
        "df1.isna().sum()"
      ],
      "metadata": {
        "id": "iOMGZiVb8k4l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Após executar os comandos, notamos que algumas colunas não possuem valores ausentes, mas outras têm alguns. Agora, precisamos lidar com esses valores ausentes. Existem três métodos comuns para tratar esse problema:\n",
        "\n",
        "1. **Descartar as linhas**: Simplesmente removemos as linhas que contêm valores ausentes. É rápido e fácil, mas pode resultar na perda de informações importantes para o algoritmo.\n",
        "\n",
        "2. **Usar algoritmos de aprendizado de máquina**: Alguns algoritmos podem preencher os valores ausentes com base no comportamento geral da coluna, como a média, mediana ou moda. Além disso, existem algoritmos mais avançados que podem estimar os valores ausentes com maior precisão.\n",
        "\n",
        "3. **Usar conhecimento de negócio**: Se soubermos a lógica de negócio por trás dos valores ausentes, podemos preenchê-los de acordo e recuperar os dados de forma adequada."
      ],
      "metadata": {
        "id": "vMRHnK-380QZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.5 Fillout NA**\n",
        "Começaremos tratando a coluna '**competition_distance**'. De acordo com a descrição da coluna, ela representa a distância, em metros, do concorrente mais próximo."
      ],
      "metadata": {
        "id": "ckXLqjgX91kJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# competition_distance\n",
        "# competition_open_since_month\n",
        "# competition_open_since_year\n",
        "# promo2_since_week\n",
        "# promo2_since_year\n",
        "# promo_interval"
      ],
      "metadata": {
        "id": "lJLBGcu98n1l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Existem três principais abordagens para lidar com dados ausentes (NaN):\n",
        "\n",
        "1. **Exclusão de dados**: A primeira maneira é simplesmente excluir todas as linhas que contêm dados ausentes. Isso é rápido, mas tem a desvantagem de perder uma quantidade significativa de informações.\n",
        "\n",
        "2. **Preenchimento usando algoritmos**: A segunda abordagem é utilizar algoritmos de aprendizado de máquina para preencher os dados ausentes com base no comportamento das colunas. Por exemplo, podemos calcular a mediana ou a média e substituir os valores ausentes por esses números. Algoritmos mais avançados podem realizar agrupamentos ou até mesmo prever os valores ausentes.\n",
        "\n",
        "3. **Considerar o contexto do negócio**: A terceira abordagem, que será adotada neste tutorial, envolve pensar a partir da perspectiva do negócio. Mesmo que não sejamos especialistas no domínio, esse exercício pode ser útil. Refletir sobre o motivo dos dados estarem ausentes pode oferecer insights valiosos para o tratamento adequado desses casos.\n"
      ],
      "metadata": {
        "id": "xeOIHsyR_ojU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.5.1 Competition Distance**\n",
        "Vamos analisar a coluna **competition_distance**. Uma interpretação plausível para os **dados ausentes** é que a **distância até o concorrente mais próximo é tão grande que, na prática, não há concorrente próximo**."
      ],
      "metadata": {
        "id": "Wjvr2R7LKe2p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Encontrar o valor máximo na coluna 'competition_distance'\n",
        "df1['competition_distance'].max()"
      ],
      "metadata": {
        "id": "M3yuqBdrAjWl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Com a **ausência de valores** em 'competition_distance', iremos **substituí-los por um número extremamente grande**, que chamaremos de 'max_value'. Para definir este 'max_value', vamos primeiro procurar o **valor máximo** existente na coluna 'competition_distance'. No nosso caso, encontramos o **valor de 75.860 metros** como o mais distante concorrente."
      ],
      "metadata": {
        "id": "TKjcLkBZBgL0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Substituindo valores NaN na coluna 'competition_distance' por 200000.0\n",
        "df1['competition_distance'] = df1['competition_distance'].apply(lambda x: 200000.0 if math.isnan(x) else x)"
      ],
      "metadata": {
        "id": "khFPwARuA6U-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Escolhemos 'max_value' como 200.000 metros, um valor **maior** que a distância máxima existente na coluna 'competition_distance'. **Valores ausentes** são substituídos por 'max_value', indicando a ausência de concorrente próximo. Aplicamos essa lógica usando a **função lambda**, que atua somente na coluna 'competition_distance'.\n",
        "\n",
        "O resultado **substitui** a coluna original. Após a operação, verificamos que **não há mais valores ausentes** nessa coluna, demonstrando que tratamos os dados ausentes com sucesso."
      ],
      "metadata": {
        "id": "A71VZsIYBp8N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Verificando a quantidade de valores faltantes (NaN) em cada coluna de df1\n",
        "df1.isna().sum()"
      ],
      "metadata": {
        "id": "tUQhCgpCBMHg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A coluna **competition_distance não possui mais valores ausentes** e o **valor máximo** é **200.000 metros**, conforme definido anteriormente."
      ],
      "metadata": {
        "id": "ugkMBmyPJTJL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Obtendo o valor máximo na coluna 'competition_distance' do DataFrame df1\n",
        "df1['competition_distance'].max()"
      ],
      "metadata": {
        "id": "g0CTReeDIqA_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.5.2 Competition Open Since Month**\n",
        "**Avançando**, vamos analisar a coluna **'competition_open_since'**. Esta coluna indica o **mês** e o **ano** aproximado em que o **concorrente mais próximo** foi **inaugurado**.\n",
        "\n",
        "Podemos supor que os **valores ausentes** nesta coluna podem ser por duas razões: **primeiro**, a loja pode não ter um **concorrente próximo**, logo não existe uma **data de abertura** para tal concorrente. **Segundo**, a loja pode ter um **concorrente próximo**, mas **desconhecemos** a **data de abertura** deste, seja porque o concorrente abriu **antes** da loja ou porque abriu **posteriormente**.\n",
        "\n",
        "Para **substituir os valores ausentes** nesta coluna, **copiaremos** a **data de venda correspondente** na linha em questão para a coluna **'competition_open_since'**."
      ],
      "metadata": {
        "id": "WownTsukKi1V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df1.sample()"
      ],
      "metadata": {
        "id": "erLJ65KVKsZ8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando a função\n",
        "from IPython.display import display\n",
        "\n",
        "# Selecionando a loja 238 na data de '20/05/2014'\n",
        "loja_238_20_05_2014 = df1.loc[(df1['store'] == 283) & (df1['date'] == '2014-05-20')]\n",
        "\n",
        "# Imprimindo o dataframe\n",
        "display(loja_238_20_05_2014)\n"
      ],
      "metadata": {
        "id": "nCCGchXCzJjI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos considerar a coluna **'competition_open_since'** em uma linha de exemplo com uma **venda** realizada pela **loja 283** em **20/05/2014**. Se essa linha apresentar um valor **ausente** em **'competition_open_since'**, substituiremos esse valor pelo da **data da venda**.\n",
        "\n",
        "Extrai-se apenas o **mês** da **data da venda** para preencher os valores **ausentes** na coluna **'competition_open_since_month'**.\n",
        "\n",
        "A **lógica** é que uma **loja sem concorrência** tem um **nível estável de vendas**, que provavelmente **cairá quando um concorrente abrir**. O **tempo desde a abertura de um concorrente** pode influenciar as **flutuações de vendas**.\n",
        "\n",
        "Reconhecemos a **incongruência** de usar a **data da venda** como a **data de abertura do concorrente**, mas prosseguiremos com essa **abordagem** para avaliar seu **impacto no modelo**. Se necessário, **ajustaremos** essa abordagem em **futuras iterações**. A forma como implementaremos essa **substituição** será semelhante ao que fizemos para **competition_distance**."
      ],
      "metadata": {
        "id": "LLTnCMH8KxKc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Preenchendo ausentes em 'competition_open_since_month' com o mês da data correspondente na coluna 'date'\n",
        "df1['competition_open_since_month'] = df1.apply(lambda x: x['date'].month\n",
        "                                                if np.isnan(x['competition_open_since_month'])\n",
        "                                                else x['competition_open_since_month'], axis=1)"
      ],
      "metadata": {
        "id": "1IuE-U2cKthw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Portanto, se a coluna **competition_open_since_month** estiver vazia, iremos preencher com o **mês da coluna date**.\n",
        "\n",
        "Se essa condição não for verdadeira, iremos simplesmente **retornar o valor original**, pois já temos o mês em que a competição foi aberta.\n",
        "\n",
        "Para aplicar essa lógica, vamos usar a função **lambda** novamente. Dentro desta função, podemos substituir **df1** por **x**, já que tudo dentro da função é referido como **x**.\n",
        "\n",
        "Para aplicar isso aos nossos dados, vamos usar a função **apply** e aplicá-la ao longo das colunas. Fazemos isso porque estamos trabalhando com mais de uma coluna - **competition_open_since_month** e **date**. Quando trabalhamos com mais de uma coluna, precisamos explicitamente aplicar a função ao longo das colunas.\n",
        "\n",
        "Finalmente, o resultado dessa função será usado para substituir a coluna original **competition_open_since_month**.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "R7QVSR6bPksl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.5.3 Competition Open Since Year**\n",
        "Vamos **substituir todas as ocorrências de 'month' por 'year'** na linha atual."
      ],
      "metadata": {
        "id": "LYn7UfYpQCU6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criamos competition_open_since_year onde substituímos o valor ausente poro ano da coluna 'date'**.\n",
        "df1['competition_open_since_year'] = df1.apply(lambda x: x['date'].year\n",
        "                                               if np.isnan(x['competition_open_since_year'])\n",
        "                                               else x['competition_open_since_year'], axis=1)"
      ],
      "metadata": {
        "id": "w8uUdTOWPRP6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.5.4 Promo 2 Since Week**\n",
        "A coluna **promo2** indica a participação de uma loja em uma continuação de uma promoção. Se o valor é **zero**, a loja não está participando; se é **um**, a loja está participando. Quando há dados ausentes (**NaN**) para *promo2*, isso significa que a loja não optou por participar da promoção contínua, portanto, não há uma semana de início para essa promoção.\n",
        "\n",
        "Para tratar esses valores ausentes, usaremos uma abordagem semelhante à usada para a coluna **competition_distance**: **substituir os NaNs pelo valor da data naquela linha**. Dessa forma, quando consideramos a distância em tempo, o algoritmo reconhecerá que temos essa promoção ativa desde uma determinada semana.\n",
        "\n",
        "Para implementar essa substituição, utilizaremos um código semelhante ao que usamos para **competition_distance**, mas com **pequenas alterações**: em vez de **competition**, procuramos **promo2**, e em vez de extrair o mês da data, queremos extrair a semana."
      ],
      "metadata": {
        "id": "tLzmRXt4QvcJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Preencher valores ausentes na coluna 'promo2_since_week' com o número da semana da coluna 'date'.\n",
        "df1['promo2_since_week'] = df1.apply(lambda x: x['date'].week\n",
        "                                     if np.isnan(x['promo2_since_week'])\n",
        "                                     else x['promo2_since_week'], axis=1)"
      ],
      "metadata": {
        "id": "BfpgDxccRWDx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.5.5 Promo 2 Since Year**\n",
        "Para implementar essa substituição, duplicamos o código utilizado para a coluna **promo2_since_week**, fazendo pequenas alterações para extrair o **ano** da coluna **date**."
      ],
      "metadata": {
        "id": "1QOm_XT0Rfff"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Extrair o ano da coluna 'date' para as linhas em que o valor de 'promo2_since_year' é NaN.\n",
        "df1['promo2_since_year'] = df1.apply(lambda x: x['date'].year\n",
        "                                     if np.isnan(x['promo2_since_year'])\n",
        "                                     else x['promo2_since_year'], axis=1)"
      ],
      "metadata": {
        "id": "k7XKPl2JRnHh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Esse código realiza o preenchimento de **valores ausentes** na coluna **promo2_since_year**. Ele percorre cada **linha do dataframe** e verifica se o valor dessa coluna é **NaN** (ausente). Caso seja, ele substitui o valor ausente pelo **ano da data** presente nessa linha. Se o valor não for NaN, ele mantém o **valor original da coluna**. Isso é feito usando a função **apply** e uma **função lambda** que realiza essas verificações e substituições linha a linha."
      ],
      "metadata": {
        "id": "CPdBaiRJVBpu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.5.6 Promo Interval**\n",
        "**promo Interval** descreve os **meses** em que uma **promoção** chamada **Promo 2** foi iniciada. Por exemplo, se os valores forem **\"Fevereiro, Maio, Agosto, Novembro\"**, isso indica que a **promoção** foi realizada nesses **meses específicos**."
      ],
      "metadata": {
        "id": "z-OO7QWLSw1R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criando um dicionário month_map para mapear os números dos meses (1 a 12) para suas respectivas abreviações em inglês.\n",
        "month_map = {1: 'Jan', 2: 'Fev', 3: 'Mar',  4: 'Apr',  5: 'May',  6: 'Jun',\n",
        "             7: 'Jul', 8: 'Aug', 9: 'Sep', 10: 'Oct', 11: 'Nov', 12: 'Dez'}\n",
        "\n",
        "# Preenchendo os valores ausentes em 'promo_interval' com 0, caso haja algum.\n",
        "df1['promo_interval'].fillna(0, inplace=True)\n",
        "\n",
        "# Criando a coluna 'month_map' com as abreviações dos meses das promoções.\n",
        "df1['month_map'] = df1['date'].dt.month.map(month_map)\n",
        "\n",
        "# Criando a coluna 'is_promo' para indicar se uma loja está participando de uma promoção naquele mês específico.\n",
        "# Se 'promo_interval' não for igual a 0 e a abreviação do mês estiver presente em 'promo_interval', a loja está participando da promoção (valor 1), caso contrário, não está (valor 0).\n",
        "df1['is_promo'] = df1[['promo_interval', 'month_map']].apply(\n",
        "    lambda x: 1 if x['promo_interval'] != 0 and x['month_map'] in x['promo_interval'].split(',') else 0, axis=1)\n"
      ],
      "metadata": {
        "id": "iRjxVJhO348K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df1.sample(5).T"
      ],
      "metadata": {
        "id": "eLFceY6_4OwV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A primeira etapa consiste em **dividir** a coluna \"Promo Interval\" para criar uma lista com os **meses da promoção**. Em seguida, é criada uma nova coluna chamada \"month_map\" com base na **data da promoção**. Se o **mês da promoção** estiver presente na lista de meses, um **valor indicando que a \"Promo 2\" estava ativa** é inserido nessa coluna.\n",
        "\n",
        "Após a criação da coluna auxiliar, os **meses são convertidos de números para suas representações de texto correspondentes**. Por exemplo, janeiro é representado como \"Jan\". Em seguida, uma **função é aplicada para fazer a substituição direta na coluna**.\n",
        "\n",
        "Em seguida, os **valores da coluna \"Promo Interval\" são substituídos por seus equivalentes numéricos** usando um dicionário que mapeia os meses para seus respectivos números. Isso cria a coluna \"month_map\", que contém o mês em que a promoção ocorreu.\n",
        "\n",
        "Uma **função é então aplicada para verificar se o mês da promoção está na lista de meses da \"Promo 2\"**. Se estiver na lista, é retornado o valor \"1\", indicando que a loja estava participando da promoção nesse mês específico. Se o mês não estiver na lista ou se a loja não participou da \"Promo 2\", é retornado o valor \"0\".\n"
      ],
      "metadata": {
        "id": "2xcRvU9j7gxP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calcula a quantidade de valores ausentes (NaN) em cada coluna do DataFrame df1\n",
        "df1.isna().sum()"
      ],
      "metadata": {
        "id": "m936RIql6CsT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.6 Change Types**\n",
        "Quando trabalhamos com colunas em um conjunto de dados, é **importante verificar os tipos de dados dessas colunas após realizar operações**. Isso ocorre porque as operações podem alterar os tipos de dados originais sem querer.\n",
        "\n",
        "Em alguns casos, podemos precisar **alterar o tipo de dados de uma coluna para outro**. Por exemplo, se quisermos converter o tipo de dados 'float' da coluna 'competition' para 'int' (um número inteiro), podemos usar o método astype(). Essa conversão é útil quando desejamos trabalhar com números inteiros em vez de valores decimais.\n"
      ],
      "metadata": {
        "id": "_L2b5XP08a2V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Alterando o tipo de dado da coluna 'competition_open_since_month' para inteiro\n",
        "df1['competition_open_since_month'] = df1['competition_open_since_month'].astype(int)\n",
        "\n",
        "# Alterando o tipo de dado da coluna 'competition_open_since_year' para inteiro\n",
        "df1['competition_open_since_year'] = df1['competition_open_since_year'].astype(int)\n",
        "\n",
        "# Alterando o tipo de dado da coluna 'promo2_since_week' para inteiro\n",
        "df1['promo2_since_week'] = df1['promo2_since_week'].astype(int)\n",
        "\n",
        "# Alterando o tipo de dado da coluna 'promo2_since_year' para inteiro\n",
        "df1['promo2_since_year'] = df1['promo2_since_year'].astype(int)"
      ],
      "metadata": {
        "id": "abVoaV7b9XcH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.7 Descriptive Statistics**\n",
        "A **estatística descritiva** é como uma lupa para os seus dados. Ela ajuda a ver coisas que você não conseguiria a olho nu. É usada para dois grandes objetivos: **conhecer melhor o seu negócio** e **encontrar possíveis problemas nos dados**.\n",
        "\n",
        "A estatística descritiva tem duas \"ferramentas\" principais: as **métricas de tendência central** e as **métricas de dispersão**.\n",
        "\n",
        "As **métricas de tendência central**, como a média e a mediana, são como uma selfie dos seus dados. Elas dão uma ideia geral de como eles se parecem. Mas assim como uma selfie, elas não mostram tudo. Para ver o cenário completo, precisamos das métricas de dispersão.\n",
        "\n",
        "As **métricas de dispersão**, que incluem coisas como variância, desvio padrão e valores mínimos e máximos, são como um mapa dos seus dados. Elas mostram onde os dados estão, se estão perto ou longe da média. E também temos a \"**assimetria**\" e a \"**curtose**\" que nos dão mais detalhes sobre esse mapa. A assimetria nos diz se os dados estão puxados para um lado ou para outro. A curtose nos diz se os dados estão concentrados em uma área ou espalhados.\n",
        "\n",
        "Ao usar a estatística descritiva, precisamos tratar de maneira diferente os números (**variáveis numéricas**) e as categorias (**variáveis categóricas**). Para selecionar as variáveis numéricas, você pode usar um comando específico na sua ferramenta de análise de dados, como o comando **select_dtypes()** na biblioteca pandas do Python."
      ],
      "metadata": {
        "id": "eVpUCulk9_xd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Seleciona as colunas do DataFrame df1 que têm tipo de dado 'int64' ou 'float64' e armazena na variável num_attributes\n",
        "num_attributes = df1.select_dtypes(include = ['int64', 'float64'])\n",
        "\n",
        "# Seleciona as colunas do DataFrame df1 que não têm tipo de dado 'int64', 'float64' nem 'datetime64[ns]' e armazena na variável cat_attributes\n",
        "cat_attributes = df1.select_dtypes(exclude = ['int64', 'float64', 'datetime64[ns]'])"
      ],
      "metadata": {
        "id": "KFu-fBvEAPi-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A primeira linha está selecionando todas as colunas que têm tipos de dados **int64** ou **float64**. Estes são tipicamente considerados atributos numéricos, pois **int64** representa um número inteiro e **float64** representa um número de ponto flutuante.\n",
        "\n",
        "A segunda linha está selecionando todas as colunas que não são do tipo **int64**, **float64** nem **datetime64[ns]**. Estas são tipicamente consideradas como atributos categóricos, pois excluem os tipos numéricos e de data/hora.\n",
        "\n",
        "O método **.select_dtypes()** é usado para selecionar colunas de um DataFrame com base em seus tipos de dados. O parâmetro **include** é usado para especificar os tipos de dados que você deseja incluir, e o parâmetro **exclude** é usado para especificar os tipos de dados que você deseja excluir."
      ],
      "metadata": {
        "id": "dlp8uKunBUNW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Seleciona duas linhas aleatórias do DataFrame num_attributes.\n",
        "num_attributes.sample(2)\n",
        "\n",
        "# Seleciona duas linhas aleatórias do DataFrame cat_attributes.\n",
        "cat_attributes.sample(2)"
      ],
      "metadata": {
        "id": "zVw777vkAoYv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Depois de dividirmos os dados em **numéricos** e **categóricos**, podemos mergulhar mais profundamente em cada tipo para descobrir informações valiosas. Nos dados numéricos, é possível calcular a **média**, que é a soma de todos os números dividida pela quantidade total, a **mediana**, que é o valor no meio de uma lista de números ordenados, e o **desvio padrão**, que nos mostra o quanto esses números se dispersam em relação à média.\n",
        "\n",
        "Nos dados categóricos, podemos **contar quantas vezes cada categoria aparece**, o que nos permite identificar qual é a mais comum. Então, se tivermos uma coluna \"Cor\" com opções como \"Vermelho\", \"Azul\" e \"Verde\", poderíamos descobrir qual cor aparece com mais frequência. Este **processo de análise** é fundamental para entender melhor nossos dados e extrair **insights significativos** deles."
      ],
      "metadata": {
        "id": "jTvXYD2eBay4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.7.1 Numerical Attributes**\n",
        "Vamos abordar o cálculo de métricas de tendência central para variáveis numéricas. As métricas de tendência central resumem o conjunto de dados em um único valor representativo, fornecendo um 'centro' em torno do qual os dados estão distribuídos. As métricas de tendência central mais comuns são a média e a mediana."
      ],
      "metadata": {
        "id": "rmwAQceICf17"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Measures of Central Tendency**"
      ],
      "metadata": {
        "id": "HXPaWam4hfyN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cria um novo DataFrame com a média de cada coluna\n",
        "ct1 = pd.DataFrame(num_attributes.apply(np.mean)).T\n",
        "\n",
        "# Cria um novo DataFrame com a mediana de cada coluna\n",
        "ct2 = pd.DataFrame(num_attributes.apply(np.median)).T"
      ],
      "metadata": {
        "id": "h5314qpdhK_G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Dispersion Measures**"
      ],
      "metadata": {
        "id": "4qJNRqtPhTKL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Desvio padrão nos dá uma ideia de quão espalhados estão nossos dados\n",
        "d1 = pd.DataFrame(num_attributes.apply(np.std)).T\n",
        "\n",
        "# Mínimo e Máximo nos mostram o menor e maior valor em nossos dados, respectivamente\n",
        "d2 = pd.DataFrame(num_attributes.apply(min)).T\n",
        "d3 = pd.DataFrame(num_attributes.apply(max)).T\n",
        "\n",
        "# Amplitude é a diferença entre o maior e o menor valor em nossos dados\n",
        "d4 = pd.DataFrame(num_attributes.apply(lambda x: x.max() - x.min())).T\n",
        "\n",
        "# Assimetria nos dá uma ideia de como nossos dados são simétricos. Se for zero, os dados são perfeitamente simétricos.\n",
        "d5 = pd.DataFrame(num_attributes.apply(lambda x: x.skew())).T\n",
        "\n",
        "# Curtose nos informa se os dados são leves ou pesados ​​em suas caudas em comparação com uma distribuição normal\n",
        "d6 = pd.DataFrame(num_attributes.apply(lambda x: x.kurtosis())).T"
      ],
      "metadata": {
        "id": "_kJB20RjA8ax"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Depois de calcular todas essas informações importantes, o próximo passo é reunir todas elas em um só lugar para que seja mais fácil analisá-las. Para fazer isso, vamos juntar todos esses conjuntos de dados que criamos em um único conjunto de dados, mais especificamente, um único DataFrame.\n",
        "\n",
        "A biblioteca pandas, que estamos usando para lidar com nossos dados, tem uma função chamada concat(). Esta função nos permite juntar vários DataFrames em um só, e é exatamente isso que vamos fazer a seguir:"
      ],
      "metadata": {
        "id": "NRtwi6muEMxD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Concatenamos todos os DataFrames em um único DataFrame 'measures'\n",
        "measures = pd.concat([d2, d3, d4, ct1, ct2, d1, d5, d6]).T.reset_index()\n",
        "\n",
        "# Renomeamos as colunas para uma melhor compreensão\n",
        "measures.columns = ['Atributos', 'Mínimo', 'Máximo', 'Intervalo', 'Média', 'Mediana', 'Desvio Padrão', 'Assimetria', 'Curtose']\n",
        "\n",
        "# Configuramos a opção de exibição para exibir todos os valores sem truncamento\n",
        "pd.set_option('display.max_columns', None)\n",
        "pd.set_option('display.expand_frame_repr', False)\n",
        "\n",
        "# Exibimos o DataFrame final\n",
        "print(measures)"
      ],
      "metadata": {
        "id": "R8enU_TTEXGx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste estágio, temos o **measures**, que é um DataFrame que reúne todas as métricas que calculamos para cada atributo numérico do nosso conjunto de dados. Agora, cada linha deste DataFrame apresenta uma métrica específica, enquanto cada coluna representa um dos atributos numéricos do nosso conjunto de dados original. Assim, obtemos uma visão clara e concisa das características-chave de cada um dos nossos atributos numéricos.\n",
        "\n",
        "Supondo que temos uma coluna **sales** nos nossos dados. As estatísticas nos mostram que o valor mínimo é zero, indicando que houve dias sem qualquer venda, possivelmente devido à loja estar fechada. Em contraste, o valor máximo é de **41.000**, que representa o maior volume de vendas alcançado em um único dia. A diferença entre esses dois valores, ou seja, a 'variação', é, nesse caso, de **41.000**.\n",
        "\n",
        "Quando a média (o valor médio das vendas) e a mediana (o valor central quando as vendas são ordenadas) são semelhantes, como observado aqui, isso sugere que as vendas estão distribuídas de maneira equilibrada, sem uma prevalência de dias com vendas extremamente altas ou baixas.\n",
        "\n",
        "Adicionalmente, temos dois outros indicadores que nos dão uma visão mais detalhada da distribuição das vendas: o **'skewness'** e a **'kurtosis'**. O 'skewness' indica se a maioria das vendas está acima ou abaixo da média, enquanto a 'kurtosis' fornece uma ideia sobre o grau de concentração das vendas em torno da média. No nosso caso, ambos os valores estão próximos de zero, o que corrobora a ideia de que as vendas são bem distribuídas e não apresentam grandes surpresas."
      ],
      "metadata": {
        "id": "U_Vmniw2EaMz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **1.7.2 Categorical Attributes**\n",
        "Para realizar uma análise descritiva dos dados categóricos, é útil usar gráficos para visualizar as informações. Um tipo de gráfico muito útil para esse propósito é o gráfico de boxplot. Este gráfico permite visualizar diversas medidas estatísticas, como medidas de tendência central e dispersão, em um único lugar, facilitando a comparação entre as categorias.\n",
        "\n",
        "Entretanto, antes de construir o boxplot, pode ser útil verificar a quantidade de níveis ou valores únicos que cada variável categórica possui. Isso pode ser feito com o uso da função nunique do pandas em Python, que retorna o número de elementos distintos em cada coluna de um dataframe. A função nunique pode ser aplicada a todas as colunas de um dataframe utilizando o método apply.\n",
        "\n"
      ],
      "metadata": {
        "id": "gCf5Z5_JJOq6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Contagem do número de categorias únicas em cada atributo categórico.\n",
        "cat_attributes.apply(lambda x: x.unique().shape[0])"
      ],
      "metadata": {
        "id": "JAFG_n9lJrkI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Com certeza, aqui está o texto reformulado com as variáveis em negrito:\n",
        "\n",
        "No exemplo que estamos analisando, temos algumas variáveis categóricas, como **state_holiday**, **store_type**, **assortment**, **promot_interval** e **month_map**. Interessante notar que cada uma dessas variáveis possui três categorias distintas."
      ],
      "metadata": {
        "id": "Yy1rymumJ87E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando as bibliotecas necessárias\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Definindo o tamanho do gráfico\n",
        "plt.figure(figsize=(12, 6))\n",
        "\n",
        "# Criando o boxplot\n",
        "sns.boxplot(x='state_holiday', y='sales', data=df1)\n",
        "\n",
        "# Adicionando um título ao gráfico\n",
        "plt.title('Comparação das vendas em diferentes estados de férias')\n",
        "\n",
        "# Mostrando o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "fqd9TSIKKK-X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Estamos interessados em explorar a dispersão de **sales** em cada nível da variável categórica **state_holiday**. Assim, no gráfico, definimos **state_holiday** como o eixo x (representando as categorias) e **sales** como o eixo y (representando o valor que estamos analisando). Os dados são provenientes do nosso DataFrame **df1**, que contém os dados relevantes.\n",
        "\n",
        "No entanto, ao visualizar o boxplot, podemos nos deparar com uma interpretação difícil ou distorcida dos dados. Uma causa comum para isso é a presença de **valores atípicos** que não contribuem para a nossa análise. Um exemplo pode ser a presença de vendas igual a zero, correspondendo aos dias em que as lojas estavam fechadas.\n",
        "\n",
        "Para contornar essa questão, é possível **filtrar os dados** antes de plotar o gráfico. Por exemplo, podemos desejar visualizar **apenas as vendas que são maiores que zero e que ocorreram em dias que não são feriados**.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "L8N73M1bLEDV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Filtrando o DataFrame para incluir apenas os dias com vendas positivas e que não são feriados normais\n",
        "aux1 = df1[(df1['state_holiday'] != '0') & (df1['sales'] > 0)]\n",
        "\n",
        "# Inicializando a figura para os gráficos\n",
        "plt.figure(figsize=(15, 6))\n",
        "\n",
        "# Adicionando um título global para a figura\n",
        "plt.suptitle('Distribuição de Vendas por Estado de Férias, Tipo de Loja e Variedade de Produtos')\n",
        "\n",
        "# Criando o primeiro subplot para mostrar a distribuição de vendas por estado de férias\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.boxplot(x = 'state_holiday', y = 'sales', data = aux1)\n",
        "plt.title('Estado de Férias')\n",
        "\n",
        "# Criando o segundo subplot para mostrar a distribuição de vendas por tipo de loja\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.boxplot(x = 'store_type', y = 'sales', data = aux1)\n",
        "plt.title('Tipo de Loja')\n",
        "\n",
        "# Criando o terceiro subplot para mostrar a distribuição de vendas por variedade de produtos\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.boxplot(x = 'assortment', y = 'sales', data = aux1)\n",
        "plt.title('Variedade de Produtos')\n",
        "\n",
        "# Ajustando o layout para evitar sobreposição\n",
        "plt.tight_layout()\n",
        "\n",
        "# Exibindo os gráficos\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "0qhJi39tK8NL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Plotly**"
      ],
      "metadata": {
        "id": "Ff72PkwyjlPv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando a biblioteca plotly\n",
        "import plotly.subplots as sp\n",
        "import plotly.graph_objects as go\n",
        "\n",
        "# Criando uma figura com subplots\n",
        "fig = sp.make_subplots(rows=1, cols=3,\n",
        "                       subplot_titles=(\"Estado de Férias\", \"Tipo de Loja\", \"Variedade de Produtos\"))\n",
        "\n",
        "# Filtrando o DataFrame para incluir apenas os dias com vendas positivas e que não são feriados normais\n",
        "aux1 = df1[(df1['state_holiday'] != '0') & (df1['sales'] > 0)]\n",
        "\n",
        "# Adicionando os boxplots ao subplot\n",
        "\n",
        "# Boxplot para estado de férias\n",
        "fig.add_trace(go.Box(x = aux1['state_holiday'], y = aux1['sales'], name = 'Estado de Férias'), row=1, col=1)\n",
        "\n",
        "# Boxplot para tipo de loja\n",
        "fig.add_trace(go.Box(x = aux1['store_type'], y = aux1['sales'], name = 'Tipo de Loja'), row=1, col=2)\n",
        "\n",
        "# Boxplot para variedade de produtos\n",
        "fig.add_trace(go.Box(x = aux1['assortment'], y = aux1['sales'], name = 'Variedade de Produtos'), row=1, col=3)\n",
        "\n",
        "# Atualizando os layouts dos gráficos para exibir os títulos dos eixos\n",
        "fig.update_xaxes(title_text=\"Estado de Férias\", row=1, col=1)\n",
        "fig.update_xaxes(title_text=\"Tipo de Loja\", row=1, col=2)\n",
        "fig.update_xaxes(title_text=\"Variedade de Produtos\", row=1, col=3)\n",
        "fig.update_yaxes(title_text=\"Vendas\", row=1, col=1)\n",
        "fig.update_yaxes(title_text=\"Vendas\", row=1, col=2)\n",
        "fig.update_yaxes(title_text=\"Vendas\", row=1, col=3)\n",
        "\n",
        "# Atualizando o layout da figura para adicionar um título e ajustar o tamanho da figura\n",
        "fig.update_layout(title_text=\"Distribuição de Vendas por Estado de Férias, Tipo de Loja e Variedade de Produtos\",\n",
        "                  autosize=True, height=600)\n",
        "\n",
        "# Exibindo a figura\n",
        "fig.show()"
      ],
      "metadata": {
        "id": "WV52DCu_pwAU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No código acima, utilizamos as bibliotecas **Seaborn** e **Plotly** para explorar a relação entre as vendas e diferentes **variáveis categóricas**, como o **state_holiday** (tipo de feriado) e o **store_type** (tipo de loja). A função **plt.subplot()** nos permite visualizar múltiplos boxplots lado a lado, facilitando uma comparação direta entre as variáveis.\n",
        "\n",
        "O **boxplot** é uma ferramenta gráfica que oferece uma visão visual da **mediana**, dos **quartis** e dos **valores extremos (outliers)** de uma distribuição de dados. A linha que divide a 'caixa' ao meio representa a mediana - o valor central de uma distribuição. As linhas superior e inferior da 'caixa' indicam o primeiro (25º percentil) e o terceiro quartil (75º percentil), respectivamente.\n",
        "\n",
        "Ao analisar os boxplots, observamos que as vendas tendem a ser mais altas quando o **state_holiday** é do tipo 'B'. Na variável **store_type**, notamos que as lojas do tipo 'B' não só possuem uma mediana de vendas mais alta, mas também uma maior quantidade de **outliers**."
      ],
      "metadata": {
        "id": "ytmtAk8_Q_sV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Status Projeto Rossmann**\n",
        "No contexto do nosso projeto **Rossmann de previsão de vendas** por loja para as próximas seis semanas, a abordagem se inicia identificando a causa raiz do problema, que se manifesta na dificuldade do **CEO** em determinar a quantidade de investimento necessário para a reforma das lojas. Por isso, a realização de uma **previsão de vendas** surge como essencial para auxiliar no processo de tomada de decisões.\n",
        "\n",
        "A fase subsequente engloba a **coleta de dados**, que, neste projeto, implica no download dos dados disponíveis na plataforma do **Kaggle**. Contudo, em situações práticas, essa coleta pode abarcar diversas fontes de dados pertinentes para a confecção da tabela final utilizada na análise.\n",
        "\n",
        "Posteriormente, ocorre a **limpeza dos dados**, assegurando a correção e consistência dos tipos de dados, substituindo valores faltantes segundo critérios estabelecidos. É importante, também, realizar um resumo dos dados para obter um entendimento inicial de sua dimensão e características.\n",
        "\n",
        "Atualmente, estamos na fase de **exploração dos dados**, que envolve três tarefas principais. A primeira delas é a criação de **variáveis derivadas**, a partir das já existentes, para aprimorar a representação dos dados e captar informações relevantes.\n",
        "\n",
        "Em seguida, torna-se necessário elaborar uma lista de **hipóteses** que serão testadas durante a exploração dos dados. Essas hipóteses podem se relacionar a padrões de comportamento, correlações entre variáveis ou quaisquer outras suposições relevantes para o problema.\n",
        "\n",
        "Por fim, é crucial **validar as hipóteses** levantadas durante a exploração dos dados, empregando técnicas estatísticas e visuais para confirmar ou refutar cada uma delas. Essa validação colabora na compreensão do conjunto de dados e na orientação das próximas etapas do projeto.\n",
        "\n",
        "Ao finalizar a etapa de exploração dos dados, ainda restarão outras etapas a serem executadas para encerrar o primeiro ciclo da solução proposta. No entanto, com o progresso alcançado até o momento, será possível entregar a **versão inicial desta solução**, fornecendo insights valiosos para o processo de tomada de decisões no setor de varejo."
      ],
      "metadata": {
        "id": "J1pGlsCFj2mi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Mindmap de Hipóteses**\n",
        "O **mapa mental de hipóteses** tem uma função vital na etapa de **análise exploratória de dados**, atuando como um guia claro e específico para a obtenção de insights valiosos de maneira eficiente.\n",
        "\n",
        "Este mapa atua, essencialmente, como um roteiro que direciona quais análises precisam ser feitas para validar as hipóteses estabelecidas. Ele também sinaliza quais variáveis precisam ser derivadas para efetuar essas análises. De forma simplificada, o mapa mental disponibiliza uma estrutura explícita das análises requeridas e das variáveis envolvidas, facilitando a exploração dos dados de modo eficaz.\n",
        "\n",
        "Com o **mapa mental de hipóteses** como nosso guia, temos a capacidade de determinar o nível de detalhe exigido para cada ciclo do projeto. Isso implica que poderemos identificar até que ponto é necessário aprofundar a análise durante a fase inicial. Com essa orientação clara, será possível conduzir a análise de forma mais ágil e direta, gerando insights valiosos para cada etapa do ciclo de desenvolvimento.\n",
        "\n",
        "Antes de avançarmos para a criação do **mapa mental de hipóteses**, é importante destacar os três elementos que compõem esse mapa. Esses componentes são essenciais para entender e aplicar de forma efetiva, assegurando que possamos extrair o máximo desta ferramenta em nosso projeto de previsão de vendas **Rossmann**."
      ],
      "metadata": {
        "id": "ofVuv-8fcQDK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Elementos do Mapa Mental de Hipóteses**\n",
        "O mapa mental é composto por três elementos-chave: o **fenômeno**, os **agentes** e os **atributos dos agentes**. Cada um desses elementos desempenha um papel fundamental na definição das hipóteses a serem exploradas e validadas durante a análise dos dados.\n",
        "\n",
        "O primeiro elemento, o fenômeno, refere-se ao **que estamos tentando medir ou modelar**. No contexto do nosso projeto, esse fenômeno é a **previsão de vendas**. Podemos considerar outros exemplos, como detecção de objetos em uma imagem, classificação de imagens entre gato e cachorro ou clusterização de clientes para criação de personas. **O fenômeno é o aspecto central que desejamos compreender e modelar para ensinar os algoritmos de machine learning**.\n",
        "\n",
        "O segundo elemento do mapa mental são os agentes, ou seja, as **entidades que impactam o fenômeno** de alguma forma. No caso das **vendas**, os agentes podem ser **clientes**, **lojas** e **produtos**. É importante reconhecer que esses agentes influenciam diretamente as vendas, podendo contribuir para o aumento ou diminuição das mesmas. Por exemplo, **um maior número de clientes tende a aumentar as vendas**, enquanto um aumento no **preço do produto pode resultar em vendas menores**. Portanto, é fundamental identificar e compreender todos os agentes relevantes nesse contexto.\n",
        "\n",
        "O terceiro e último elemento são os atributos dos agentes. Cada agente pode ser descrito por uma série de atributos. Por exemplo, no caso dos clientes, podemos considerar atributos como **idade**, **escolaridade**, **estado civil**, **número de filhos**, **frequência de visitas à loja**, **salário**, **educação** e **profissão**. Esses atributos ajudam a descrever as características e peculiaridades de cada agente, fornecendo informações valiosas para análise.\n",
        "\n",
        "O objetivo principal do mapa mental de hipóteses é derivar uma lista de hipóteses a serem testadas e validadas. Com base nessa lista, é possível priorizar as hipóteses e realizar a análise dos dados de forma direcionada.\n",
        "\n",
        "Durante essa análise, é possível gerar insights relevantes para o projeto. Os insights podem ser gerados de duas maneiras: através de surpresas, quando uma informação desconhecida é descoberta, ou por meio da contraposição de crenças, quando uma hipótese é confrontada e os resultados obtidos desafiam as expectativas iniciais.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ororLO8e2hJd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Como escrever as Hipóteses?**\n",
        "No projeto de ciência de dados, nosso objetivo é compreender e prever as vendas diárias das lojas Rossmann, que é o **fenômeno central** em nossa investigação. Diversos **agentes** influenciam essas vendas, como os **clientes**, as **lojas** e os **produtos**.\n",
        "\n",
        "Os clientes são indivíduos que fazem compras nas lojas, enquanto as lojas possuem características próprias, tais como a **localização** e o **tamanho**. Os produtos também são fundamentais, com atributos como **preço**, **estoque**, **promoções** e **disposição na loja**.\n",
        "\n",
        "Consideramos também **aspectos temporais**, como **ano**, **mês**, **dia**, **hora**, **semana do ano**, **feriados** e **promoções especiais**, para compreender a sazonalidade e os padrões temporais das vendas. A **localização das lojas** é relevante, levando em conta a proximidade de outros pontos de interesse.\n",
        "\n",
        "Com esses elementos em mente, podemos elaborar um mapa mental de hipóteses para serem testadas e validadas. Cada ramo do mapa simboliza uma hipótese a ser investigada. Por exemplo, podemos formular que clientes com alto volume de compras influenciam positivamente nas vendas, enquanto clientes com altos salários podem não impactar tanto assim.\n",
        "\n",
        "Esse mapa mental de hipóteses pode ser construído com base no nosso conhecimento prévio ou através de reuniões de brainstorming com indivíduos de diferentes áreas. Cada participante traz suas percepções sobre quais elementos afetam as vendas.\n",
        "\n",
        "O objetivo último desse mapa mental é gerar uma lista de hipóteses a serem testadas durante a análise dos dados. Durante essa análise, buscamos insights relevantes que podem confirmar ou refutar as hipóteses. Esses insights podem surgir de descobertas surpreendentes ou quando os resultados contradizem as suposições iniciais.\n",
        "\n",
        "O mapa mental de hipóteses orienta nosso projeto de ciência de dados, permitindo uma abordagem estruturada e focada para compreender e prever as vendas das lojas Rossmann."
      ],
      "metadata": {
        "id": "XuoYQCD3kgj9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **2.0 Feature Engineering**\n",
        "Ao formulamos hipóteses, é crucial entender que elas funcionam como suposições ou conjecturas acerca do **fenômeno** que pretendemos modelar. Por exemplo, uma hipótese pode ser: \"**Lojas de maior tamanho tendem a vender mais**\". Vamos dissecar essa conjectura. Primeiramente, devemos reconhecer que isso é uma suposição, ainda não sabemos se é de fato verdadeira. Essa hipótese precisa ser **validada com base nos dados disponíveis**.\n",
        "\n",
        "Examinando a hipótese, podemos identificar os elementos chave. No exemplo mencionado, o atributo é o **tamanho da loja**. \"Vender\" é o fenômeno que estamos tentando modelar, neste caso, **as vendas das lojas**. As palavras \"Maior\" e \"Mais\" caracterizam a suposição. Ou seja, estamos conjecturando que **lojas de maior tamanho devem vender mais**.\n",
        "\n",
        "Uma abordagem útil consiste em **relacionar cada atributo do conjunto de dados com o fenômeno** que desejamos modelar, fazendo uma suposição baseada em nossa intuição. Por exemplo, pode-se supor que, se um determinado atributo aumenta, o fenômeno também aumenta, ou se o atributo diminui, o fenômeno também diminui. Essas hipóteses irão nortear nossa investigação, permitindo que façamos suposições sobre os atributos e sua relação com o fenômeno estudado.\n",
        "\n",
        "Contudo, é importante frisar que essa relação entre os atributos e o fenômeno estudado **não se trata de uma relação de causa e efeito**. Por exemplo, não podemos afirmar com certeza que lojas de maior porte vendem mais apenas por serem maiores. As vendas podem aumentar por vários outros fatores, como um **maior número de clientes**, que pode ser influenciado pelo tamanho da loja. Portanto, devemos entender que essas hipóteses estabelecem uma **correlação entre os atributos e o fenômeno**.\n",
        "\n",
        "Agora, vamos apresentar mais exemplos de hipóteses derivadas do mapa mental. Por exemplo:\n",
        "\n",
        "\"**Lojas com maior sortimento tendem a vender mais**\" - Aqui, \"Sortimento\" é um atributo do agente 'loja', \"vender\" é o fenômeno e \"maior\" representa a suposição.\n",
        "\"**Lojas com mais competidores próximos tendem a vender menos**\" - Neste caso, \"Competidores\" é um atributo do agente 'loja', \"vender\" é o fenômeno e \"mais\" e \"menos\" são as suposições."
      ],
      "metadata": {
        "id": "yFRFPeer7Q8s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **2.1 Mapa Mental de Hipóteses**"
      ],
      "metadata": {
        "id": "S3rBEvQB9Z-K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2.1.1 Hipóteses de Loja**\n",
        "Na subseção 2.1.1, que trata das hipóteses relacionadas às lojas, iremos criar nossas hipóteses. Podemos utilizar um formato marcado para facilitar a visualização. A primeira hipótese será sobre o número de funcionários nas lojas. Baseando-se no mapa mental, podemos criar as hipóteses:\n",
        "1. Lojas com **maior quadro de funcionários** vendem mais.\n",
        "2. Lojas com **maior capacidade de estoque** vendem mais.\n",
        "3. Lojas com **maior porte** vendem mais.\n",
        "4. Lojas com **menor porte** vendem menos.\n",
        "5. Lojas com **maior sortimento** vendem mais.\n",
        "6. Lojas com **competidores mais próximos** vendem menos.\n",
        "7. Lojas com **competidores há mais tempo** vendem mais.\n",
        "\n",
        "É importante destacar que essas hipóteses serão validadas durante a etapa de análise exploratória de dados. Cada uma delas será analisada com base nos dados disponíveis, permitindo confirmar ou refutar sua influência nas vendas."
      ],
      "metadata": {
        "id": "sJpFSbjR_6Dz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2.1.2 Hipóteses de Produto**\n",
        "1. Lojas que investem mais em **Marketing** vendem mais.\n",
        "2. Lojas com mais produtos **expostos nas vitrines** vendem mais.\n",
        "3. Lojas com **preços menores** nos produtos vendem mais.\n",
        "4. Lojas que mantêm **preços menores por mais tempo** nos produtos vendem mais.\n",
        "5. Lojas com **promoções mais agressivas** vendem mais.\n",
        "6. Lojas com **promoções ativas por mais tempo** vendem mais.\n",
        "7.  Lojas com mais **dias de promoção** vendem mais.\n",
        "8.  Lojas com mais **promoções consecutivas** vendem mais."
      ],
      "metadata": {
        "id": "2vZhxdZ1Aa3s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2.1.3 Hipóteses de Tempo**\n",
        "\n",
        "1. Lojas abertas durante o feriado de Natal **tendem a vender mais**.\n",
        "2. As vendas das lojas **devem aumentar ao longo dos anos**.\n",
        "3. As vendas das lojas **devem ser maiores no segundo semestre do ano**.\n",
        "4. As vendas das lojas **devem aumentar após o dia 10 de cada mês**.\n",
        "5. As vendas das lojas **devem ser menores nos finais de semana**.\n",
        "6. As vendas das lojas **devem ser menores durante os feriados escolares**."
      ],
      "metadata": {
        "id": "he-fUV5bDarB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2.2 Lista Final de Hipóteses**\n",
        "Uma etapa importante é a **priorização das hipóteses** que iremos utilizar durante a análise de dados. Para isso, utilizamos um critério simples e eficaz: a **disponibilidade dos dados necessários no momento**.\n",
        "\n",
        "Algumas hipóteses podem ser comprovadas ou refutadas utilizando os dados já disponíveis, enquanto outras exigem tempo para coletar, organizar e preparar os dados para análise. Portanto, **priorizamos as hipóteses que podem ser validadas de imediato**, caso sejam relevantes para o modelo em questão:\n",
        "\n",
        "1. Lojas com **maior variedade de produtos** tendem a vender mais.\n",
        "2.  A **proximidade de competidores** impacta negativamente nas vendas das lojas.\n",
        "3. Lojas com **competidores estabelecidos há mais tempo** apresentam maiores vendas.\n",
        "4. **Promoções ativas por mais tempo** tendem a impulsionar as vendas das lojas.\n",
        "5.  Lojas com **maior duração das promoções** têm aumento nas vendas.\n",
        "6.  O **número de dias de promoção** está positivamente relacionado às vendas das lojas.\n",
        "7.  Lojas com **promoções consecutivas** têm incremento nas vendas.\n",
        "8.  Lojas **abertas durante o feriado de Natal** registram aumento nas vendas.\n",
        "9.  As vendas das lojas **tendem a aumentar ao longo dos anos**.\n",
        "10.  As vendas das lojas **são maiores no segundo semestre do ano**.\n",
        "11.  Após o **dia 10 de cada mês**, as vendas das lojas têm acréscimo.\n",
        "12.  As vendas das lojas **são menores nos fins de semana**.\n",
        "13.  As vendas das lojas **são menores durante os feriados escolares**.\n",
        "\n",
        "Entre as **hipóteses relacionadas às lojas**, podemos considerar que **lojas com um maior número de funcionários tendem a ter um maior volume de vendas**. No entanto, essa hipótese depende de dados específicos sobre o número de funcionários, que **não estão disponíveis atualmente**. Da mesma forma, a hipótese de que **lojas com uma capacidade de estoque maior vendem mais** também requer informações sobre o estoque, que não temos no momento. Por outro lado, podemos considerar a hipótese de que **lojas de maior porte tendem a ter um maior volume de vendas**, uma vez que esse atributo já está presente em nosso conjunto de dados.\n",
        "\n",
        "Em relação aos **produtos**, podemos explorar a hipótese de que **lojas que investem mais em marketing têm um maior volume de vendas**, pois o marketing eficaz pode atrair mais clientes. No entanto, não temos informações específicas sobre investimentos em marketing no momento. Além disso, podemos considerar a hipótese de que **lojas que expõem mais seus produtos nas vitrines têm um maior volume de vendas**, pois uma exposição visível pode chamar a atenção dos clientes.\n",
        "\n",
        "Quanto aos **preços dos produtos**, podemos considerar a hipótese de que **lojas com preços mais baixos têm um maior volume de vendas**, refletindo a preferência dos consumidores por preços acessíveis. No entanto, não temos informações específicas sobre os preços dos produtos atualmente. Da mesma forma, a hipótese de que **lojas com promoções mais agressivas e descontos maiores têm um maior volume de vendas** requer dados sobre as promoções, que não estão disponíveis no momento.\n",
        "\n",
        "Por fim, nas hipóteses relacionadas ao **tempo**, podemos considerar a hipótese de que **as lojas têm um maior volume de vendas durante o feriado de Natal**, utilizando os registros dos feriados presentes em nosso conjunto de dados. Além disso, podemos explorar a hipótese de que **as lojas têm um maior volume de vendas no segundo semestre do ano, após o dia 10 de cada mês, durante os finais de semana e períodos escolares**, com base nas informações temporais disponíveis, como a data, o mês e o ano.\n",
        "\n",
        "Essas são as hipóteses que podemos avaliar no momento, considerando a disponibilidade dos dados. Cada uma delas será analisada e testada durante o processo de análise de dados, buscando compreender a correlação e a força dessas relações com o fenômeno das vendas."
      ],
      "metadata": {
        "id": "y3-MNc75GY1S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2.3. Feature Engineering**\n",
        "Após finalizar a lista de **hipóteses**, passamos para a criação das **variáveis** necessárias para o modelo de previsão de vendas. As variáveis incluem informações **temporais** como **ano**, **mês**, **dia**, **semana do ano**, **semana do mês** e **dia da semana**, que serão usadas para análises ao longo do tempo.\n",
        "\n",
        "Também derivaremos **variáveis importantes** como 'promo_since', que indica o **tempo de promoção ativa**, e 'competition_since', que mostra o **tempo desde o início da competição** no mercado. Essas variáveis nos ajudarão a entender o impacto das **promoções** e da **concorrência** nas vendas.\n",
        "\n",
        "Outra **variável relevante** é **state_holiday**, que informará quanto tempo passou desde o último **feriado**, permitindo avaliar como os feriados influenciam nas vendas.\n",
        "\n",
        "Essa etapa é simples, mas **fundamental** para enriquecer os dados e possibilitar análises mais precisas."
      ],
      "metadata": {
        "id": "tVX_ELplInYE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df2 = df1.copy()"
      ],
      "metadata": {
        "id": "_pIWTP_wId2o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2.3.1 Derivação de Datas**\n",
        "Vamos **transformar** a coluna **date** em formato de **data** utilizando o método **to_datetime**. Em seguida, extrairemos o **ano**, **mês** e **semana do ano** usando o método \"dt\" e copiaremos essas informações para as colunas **year\", **month** e **week_of_year**, respectivamente.\n",
        "\n",
        "Também criaremos a coluna **day** para **extrair o dia da semana** utilizando o método **dayofweek** e formatá-lo adequadamente usando o método **strftime**.\n",
        "\n",
        "Após executar essas operações, **verificaremos** os resultados usando a função \"head()\" para visualizar as novas colunas criadas e confirmar se o processo foi realizado corretamente. Essas **novas variáveis** serão úteis para **análises futuras** no projeto de previsão de vendas."
      ],
      "metadata": {
        "id": "jpglL5346sqc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cria uma nova coluna 'year' no dataframe 'df2' com os valores do ano extraídos da coluna 'date'.\n",
        "df2['year'] = df2['date'].dt.year\n",
        "\n",
        "# Cria uma nova coluna 'month' no dataframe 'df2' com os valores dos meses extraídos da coluna 'date'.\n",
        "df2['month'] = df2['date'].dt.month\n",
        "\n",
        "# Cria uma nova coluna 'day' no dataframe 'df2' com os valores dos dias extraídos da coluna 'date'.\n",
        "df2['day'] = df2['date'].dt.day\n",
        "\n",
        "# Cria uma nova coluna 'week_of_year' no dataframe 'df2' com os números da semana do ano extraídos da coluna 'date'.\n",
        "df2['week_of_year'] = df2['date'].dt.weekofyear\n",
        "\n",
        "# Cria uma nova coluna 'year_week' no dataframe 'df2' com a concatenação do ano e número da semana no formato 'AAAA-SS', obtidos a partir da coluna 'date'.\n",
        "df2['year_week'] = df2['date'].dt.strftime('%Y-%W')\n"
      ],
      "metadata": {
        "id": "ak0gWXpfPFVi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **2.3.2 Competition Since**\n",
        "Para **calcular o tempo entre duas datas** no contexto do nosso projeto de previsão de vendas, é importante termos ambas as datas disponíveis. No caso, já possuímos a data da coluna \"**date**\". No entanto, também temos a informação de \"**competition**\", que está dividida em **ano, mês e dia**. Para realizar o cálculo do tempo entre essas duas datas, precisamos **combinar essas informações em uma única data** e, em seguida, realizar a **subtração entre elas**.\n",
        "\n",
        "Para esse propósito, utilizaremos o método \"**datetime**\" da classe correspondente. Vamos extrair os dados de **ano, mês e dia** da coluna \"**competition**\" e criar uma nova coluna chamada \"**competition_open_since...**\" para armazenar essa informação. Utilizaremos o método \"**apply**\" em conjunto com uma **função lambda** para aplicar essa operação em todas as linhas da coluna.\n",
        "\n",
        "O resultado dessa operação será **uma nova data que representa a combinação do ano, mês e dia** da coluna \"**competition_since**\"."
      ],
      "metadata": {
        "id": "BBQ8g7QQ_cdD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cria 'competition_since', que representa a data combinada a partir das colunas 'competition_open_since_year' (ano) e 'competition_open_since_month' (mês), definindo o dia como 1.\n",
        "df2['competition_since'] = df2.apply(lambda x: datetime.datetime(\n",
        "    year=x['competition_open_since_year'], month=x['competition_open_since_month'], day=1,), axis=1)\n"
      ],
      "metadata": {
        "id": "OJiMb14u_g89"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Em seguida, realizaremos uma divisão desse resultado por 30, com o objetivo de mantermos a unidade de tempo em meses. Essa escolha é feita porque buscamos manter a granularidade mensal nesse caso específico.\n",
        "\n",
        "O resultado dessa operação será uma nova data que representa o tempo de competição em meses."
      ],
      "metadata": {
        "id": "ECv0XGmNBLMP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calcula o tempo de competição em meses para cada registro em 'df2' a partir da subtração entre 'date' e 'competition_since',\n",
        "# e armazena o resultado na nova coluna 'competition_time_month' como números inteiros.\n",
        "df2['competition_time_month'] = (\n",
        "    (df2['date'] - df2['competition_since']) / 30).apply(lambda x: x.days).astype(int)"
      ],
      "metadata": {
        "id": "cC-vMNQ16KnJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O valor resultante será armazenado em uma **nova coluna** chamada **competition_time_month**. Essa coluna representará o **tempo transcorrido em meses** desde o início da competição. Para garantir que os valores estejam no **formato numérico**, utilizaremos o método **astype(int)**.\n",
        "\n",
        "Esse é o procedimento utilizado para **calcular o tempo em meses desde o início da competição**, utilizando as informações disponíveis em nosso conjunto de dados."
      ],
      "metadata": {
        "id": "_CfqeecJBN3f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **2.3.3 Promo Since**\n",
        "Primeiramente, criamos uma nova coluna chamada **promo_since** no DataFrame **df2**. Essa coluna é criada pela concatenação das colunas **promo2_since_year** e **promo2_since_week**, que são convertidas para o formato de string. O resultado é uma representação da data de início da promoção."
      ],
      "metadata": {
        "id": "PinmVwwxDRfL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cria a coluna 'promo_since', concatenando 'promo2_since_year' e 'promo2_since_week' como texto.\n",
        "df2['promo_since'] = df2['promo2_since_year'].astype(str) + '-' + df2['promo2_since_week'].astype(str)\n",
        "\n",
        "# Converte 'promo_since' em objetos datetime, considerando o dia da semana como segunda-feira (dia 1) e subtraindo 7 dias.\n",
        "df2['promo_since'] = df2['promo_since'].apply(lambda x: datetime.datetime.strptime(x + '-1', '%Y-%W-%w') - datetime.timedelta(days=7))\n",
        "\n",
        "# Calcula o tempo de promoção em semanas (promo_time_week) para cada registro como números inteiros.\n",
        "df2['promo_time_week'] = ((df2['date'] - df2['promo_since']) / 7).apply(lambda x: x.days).astype(int)"
      ],
      "metadata": {
        "id": "F_3k017nDtZl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Em seguida, utilizamos a função **apply** juntamente com a expressão **lambda** para aplicar uma operação em cada valor da coluna **promo_since**. Essa operação é responsável por transformar a string em uma data válida. É utilizado o método **strptime** da biblioteca **datetime** para realizar essa conversão. A parte **+ '-1'** é adicionada para especificar o primeiro dia da semana correspondente à semana do ano indicada. O resultado é subtraído de um período de sete dias (**datetime.timedelta(days=7)**) para ajustar corretamente a data.\n",
        "\n",
        "Por fim, criamos uma nova coluna chamada **promo_time_week** no DataFrame **df2**. Essa coluna é obtida calculando a diferença em semanas entre a coluna **date** (data da venda) e a coluna **promo_since** (data de início da promoção).\n",
        "\n",
        "Primeiro, subtraímos as duas datas e dividimos o resultado por sete para obter o número de semanas. Em seguida, utilizamos a função **apply** com a expressão lambda para extrair o número de dias a partir do objeto timedelta resultante. Por fim, convertemos o resultado para o tipo inteiro (**int**) e armazenamos na coluna **promo_time_week**."
      ],
      "metadata": {
        "id": "DFRJyvbrFACC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df2.head().T"
      ],
      "metadata": {
        "id": "PcPjAdiUEnng"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **2.3.4 Assortment**"
      ],
      "metadata": {
        "id": "5ORlKejtEqQa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Utilizamos a função **apply** com uma expressão lambda para aplicar uma lógica condicional em cada valor da coluna **assortment**. Essa lógica condicional verifica o valor de cada elemento: se for **a**, atribuímos **basic**; se for **b**, atribuímos **extra**; caso contrário, atribuímos **extended**.\n",
        "\n",
        "Dessa forma, estamos mapeando os diferentes valores da coluna **assortment** para categorias mais descritivas e compreensíveis: **basic**, **extra** e **extended**."
      ],
      "metadata": {
        "id": "r5pPNJ4QGBKj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Atualiza a coluna 'assortment', mapeando 'a' como 'basic', 'b' como 'extra' e outros valores como 'extended'.\n",
        "df2['assortment'] = df2['assortment'].apply(lambda x: 'basic' if x == 'a'\n",
        "                                            else 'extra' if x == 'b'\n",
        "                                            else 'extended')"
      ],
      "metadata": {
        "id": "lIp0mdAFFh15"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **2.3.5 State Holiday**"
      ],
      "metadata": {
        "id": "xOyGIcmpGJ2W"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aqui aplicamos a mesma lógica anterior de Assortment para State Holiday:"
      ],
      "metadata": {
        "id": "uty4pkORGl9h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Atualiza a coluna 'state_holiday', mapeando 'a' como 'public_holiday', 'b' como 'easter_holiday', 'c' como 'christmas' e outros valores como 'regular_day'.\n",
        "df2['state_holiday'] = df2['state_holiday'].apply(lambda x: 'public_holiday' if x == 'a'\n",
        "                                            else 'easter_holiday' if x == 'b'\n",
        "                                            else 'christmas' if x == 'c'\n",
        "                                            else 'regular_day')"
      ],
      "metadata": {
        "id": "ZeYqJw8gGN8z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Rossmann Project Status**\n",
        "Vamos recapitular brevemente o que já foi realizado até agora.\n",
        "\n",
        "No primeiro passo, realizamos a **descrição dos dados**, resumindo as informações por meio de medidas de **análise descritiva**. Além disso, **substituímos valores ausentes** e trabalhamos com diferentes **formas de dados**.\n",
        "\n",
        "Em seguida, no segundo passo, trabalhamos na **identificação das características relevantes**, criando o **mapa mental de hipóteses**. Definimos o **fenômeno que queremos modelar**, identificamos os **agentes envolvidos e seus atributos**, e elaboramos uma **lista de hipóteses**. **Priorizamos essas hipóteses** com base nos dados disponíveis no momento.\n",
        "\n",
        "Agora, estamos adentrando o **terceiro passo**, que trata da **filtragem de variáveis**. É importante entender a diferença entre **filtrar** e **selecionar variáveis**.\n",
        "\n",
        "A **filtragem de variáveis** envolve a **exclusão ou retenção de variáveis** com base em critérios específicos, como relevância, qualidade dos dados, correlações, entre outros. Por outro lado, a **seleção de variáveis** refere-se à escolha das variáveis mais importantes para a análise ou modelo preditivo, visando a redução da dimensionalidade e o aumento da eficiência computacional.\n",
        "\n",
        "Nas etapas anteriores, realizamos o **treinamento com os dados**, fazendo o download dos mesmos da plataforma do Kaggle. Em seguida, passamos pela **etapa de limpeza dos dados**, onde fizemos a descrição dos dados e tratamos possíveis problemas de qualidade. Prosseguindo, chegamos à **etapa de exploração dos dados**, que realizamos no **passo 2**, passaremos ainda pelas etapas de **Modelagem dos Dados, Algoritmos de Machine Learning, Avaliação do algoritmo e finalmente colocar o Modelo Em Produção**."
      ],
      "metadata": {
        "id": "-_PWLcTaIEVX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **3.0 Variable Filtering**\n",
        "\n",
        "### **Filtering**\n",
        "A motivação por trás da **filtragem de variáveis** é lidar com as **restrições impostas pelo contexto de negócio**, garantindo que o **modelo desenvolvido possa ser implementado com sucesso** e atender às **necessidades da empresa**.\n",
        "\n",
        "Muitas vezes, ao iniciar um projeto de ciência de dados, todas as etapas são realizadas, mas no final, descobre-se que o **modelo não pode ser colocado em produção**. Isso ocorre **principalmente quando as restrições de negócio não foram consideradas desde o início do projeto**.\n",
        "\n",
        "Uma **solução para evitar essa situação é pensar nas restrições de negócio logo no início do projeto**, antes mesmo de começar a explorar os dados. É por isso que **incluímos essa etapa em nosso processo**.\n",
        "\n",
        "### **Selecting**\n",
        "A **seleção de variáveis** está relacionada às **variáveis mais relevantes para o modelo**. Nesse processo, o algoritmo analisa as **correlações entre as variáveis de entrada e a variável resposta**, bem como as **relações entre as próprias variáveis de entrada**. Com base nessa análise, o algoritmo decide quais variáveis são mais relevantes para o modelo.\n",
        "\n",
        "No entanto, é importante destacar que a **seleção de variáveis não leva em consideração as restrições do negócio**. Essa responsabilidade cabe ao **cientista de dados**, que deve compreender os processos e as restrições enfrentadas pelas equipes de negócio. É fundamental identificar quais restrições e problemas de dados são relevantes para o contexto específico e incorporá-los no modelo.\n",
        "\n",
        "Portanto, a **filtragem de variáveis** neste projeto de **previsão de vendas Rossmann**, considera tanto a **seleção de variáveis relevantes para o modelo** quanto as **restrições e problemas específicos enfrentados pelas equipes de negócio**. Essa abordagem permite desenvolver um **modelo mais preciso e alinhado às necessidades da empresa**."
      ],
      "metadata": {
        "id": "yzImNT6EJB9d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df3 = df2.copy()"
      ],
      "metadata": {
        "id": "i4N4WvCmLCuu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **3.1 Filtering Lines**\n",
        "A coluna **\"Customers\"** indica o número de clientes presentes na loja no dia das vendas registradas. No entanto, para o nosso projeto, essa informação não está disponível para as próximas seis semanas, pois não sabemos a quantidade de clientes que estarão presentes nesse período. Portanto, não podemos **usar essa coluna como variável de entrada** na previsão de vendas.\n",
        "\n",
        "Outra coluna relevante é a **\"Open\"**, que indica se a loja estava aberta ou fechada no dia correspondente. Quando a loja está fechada, as vendas são registradas como zero. Nesse caso, não há aprendizado relevante, pois é esperado que as vendas sejam zero quando a loja está fechada. Por isso, **optamos por excluir as linhas em que a coluna \"Open\" é igual a zero**, indicando que a loja estava fechada. Dessa forma, estamos **filtrando apenas as vendas em que as lojas estavam abertas**, eliminando as vendas registradas quando a loja estava fechada.\n",
        "\n",
        "Com essas considerações, **selecionamos as colunas relevantes para o nosso modelo de previsão de vendas**, excluindo as informações não disponíveis no momento da predição e **filtrando apenas as vendas ocorridas quando as lojas estavam abertas**. Essa abordagem garante que estamos utilizando os dados disponíveis de maneira adequada e alinhada às restrições de negócio do projeto."
      ],
      "metadata": {
        "id": "PdRrKT0ELNjh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Selecionar apenas as vendas realizadas quando as lojas estavam abertas e as vendas foram positivas.\n",
        "df3 = df3[(df3['open'] != 0)  & (df3['sales'] > 0)]"
      ],
      "metadata": {
        "id": "X8rwiCX3I_iK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aqui estamos **filtrando o DataFrame df3**. Estamos selecionando apenas as linhas em que a coluna **\"open\" é diferente de zero** (ou seja, apenas as linhas em que a loja estava aberta) e a coluna **\"sales\" é maior que zero** (ou seja, apenas as linhas em que as vendas foram registradas). Dessa forma, estamos **removendo as linhas em que a loja estava fechada ou as vendas foram igual a zero**.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "lHN3DFGZNEn4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **3.2 Filtering Columns**\n",
        "Criamos uma lista chamada **cols_drop** contendo os nomes das colunas que desejamos remover, tais como **customers**, **open**, **promo_interval** e **month_map**.\n",
        "\n",
        "Em seguida, utilizamos o método **drop** do pandas no DataFrame **df3**, passando como parâmetros a lista de colunas a serem excluídas (**cols_drop**) e o argumento **axis=1** para indicar que estamos excluindo colunas.\n"
      ],
      "metadata": {
        "id": "uadjH7F1LQSm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Removendo as colunas 'customers', 'open', 'promo_interval' e 'month_map'.\n",
        "cols_drop = ['customers','open', 'promo_interval', 'month_map']\n",
        "df3 = df3.drop(cols_drop, axis=1)\n",
        "\n",
        "print(df3.columns)"
      ],
      "metadata": {
        "id": "U7ygEz7ALTfr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **4.0 Exploratory Data Analysis**\n",
        "\n",
        "### **• 3 Objectives of EDA**\n",
        "\n",
        "O objetivo de uma Análise Exploratória de Dados pode ser resumido em três pontos principais. Primeiramente, busca-se **obter experiência sobre o negócio**, compreendendo o seu funcionamento e comportamento por meio dos dados. Isso é importante para adquirir habilidades que permitam dialogar e trocar informações com a equipe de negócios, compreendendo suas métricas e medidas.\n",
        "\n",
        "Em segundo lugar, a EDA tem como objetivo **validar as hipóteses de negócio criadas** anteriormente. Utilizando o mapa de hipóteses, busca-se **gerar insights e surpresas** a partir dos dados analisados. Essa etapa envolve fornecer informações que as pessoas ainda não sabiam, causando surpresa, ou **desafiar crenças já existentes**. Ao apresentar resultados que contrariam expectativas ou quebram crenças, cria-se um ambiente propício para a geração de insights.\n",
        "\n",
        "Por fim, a terceira finalidade da EDA é **identificar as variáveis relevantes para o modelo** de análise. Durante a análise, desenvolve-se uma sensibilidade para compreender quais variáveis impactam o fenômeno em estudo. No treinamento, será apresentado um passo em que um algoritmo é utilizado para identificar as variáveis mais relevantes. No entanto, é importante ressaltar que esse algoritmo não é suficiente por si só, sendo **necessário o conhecimento prévio obtido durante a análise para complementar** as sugestões do algoritmo.\n",
        "\n",
        "Em resumo, a EDA busca proporcionar uma compreensão aprofundada do negócio por meio dos dados, validar hipóteses, gerar insights surpreendentes e identificar as variáveis mais relevantes para o modelo de análise. Essa abordagem é fundamental para embasar decisões estratégicas e obter resultados mais precisos e significativos.\n",
        "\n",
        "### **• 3 Types of Analysis**\n",
        "A **análise exploratória é composta por três tipos de análise**: univariada, bivariada e multivariada.\n",
        "\n",
        "**Na análise univariada**, nos concentramos em **uma única variável**, buscando compreender suas características, como valores mínimo e máximo, distribuição e variação. É uma forma de estudar **isoladamente cada variável**, compreendendo seu comportamento e características.\n",
        "\n",
        "**A análise bivariada** explora **o impacto de uma variável sobre outra**. Nesse caso, estamos interessados em entender **a relação entre duas variáveis** e avaliar se existe correlação ou se é possível validar hipóteses. Utilizamos **gráficos e medidas de correlação** para descrever o impacto e avaliar sua força.\n",
        "\n",
        "**Por fim, na análise multivariada**, consideramos **a relação entre múltiplas variáveis em relação à variável resposta**. Aqui, estamos interessados em compreender como **diferentes variáveis se relacionam entre si e com a variável resposta**. Em algumas situações, **a combinação de variáveis pode resultar em um impacto maior** do que quando analisadas individualmente. Portanto, na análise multivariada, buscamos compreender **essas interações e seus efeitos**.\n",
        "\n",
        "Em resumo, a **EDA abrange a análise univariada** para entender cada variável isoladamente, **a análise bivariada** para avaliar o impacto de uma variável sobre outra e **a análise multivariada** para investigar as relações entre múltiplas variáveis em relação à variável resposta. Essas análises são fundamentais para obter insights valiosos dos dados e auxiliar na tomada de decisões informadas em um projeto de ciência de dados."
      ],
      "metadata": {
        "id": "WbRjjinjPUGB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **4.1 Univariate Analysis**"
      ],
      "metadata": {
        "id": "ZPJ1IwU6XchR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df4 = df3.copy()"
      ],
      "metadata": {
        "id": "32wOLT6dXONr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **4.1.1 Response Variable**\n",
        "Em nossa análise univariada, o **foco é a variável sales**. Utilizaremos o método **distplot** da biblioteca **Seaborn**, ou sns, para **visualizar a distribuição** dessa variável.\n",
        "\n",
        "No código, ajustamos o estilo do gráfico para **whitegrid**, definimos seu tamanho para 10x6 e criamos um **histograma** da variável **sales** sem a curva de densidade do kernel e com 50 barras de cor azul. Em seguida, **adicionamos um título ao gráfico e rótulos aos eixos**. Finalmente, exibimos o gráfico na tela."
      ],
      "metadata": {
        "id": "yitwBiN-XlXI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configura o estilo do gráfico\n",
        "sns.set_style('whitegrid')\n",
        "\n",
        "# Define o tamanho do gráfico\n",
        "plt.figure(figsize=(10, 6))\n",
        "\n",
        "# Gera o histograma da variável 'sales' com 50 barras na cor azul\n",
        "sns.distplot(df4['sales'], kde=False, bins=50, color='blue')\n",
        "\n",
        "# Adiciona título e rótulos aos eixos\n",
        "plt.title('Distribuição de Vendas')\n",
        "plt.xlabel('Vendas')\n",
        "plt.ylabel('Frequência')\n",
        "\n",
        "# Exibe o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "wsHcq4UyX3ux"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Quando executamos este método, o resultado esperado é um **gráfico de distribuição** que revela a estrutura dos nossos dados. Este gráfico nos permite avaliar características cruciais como a **curtose e a assimetria da distribuição**. Neste exemplo específico, a distribuição tem uma assimetria positiva, indicada pela inclinação maior da cauda da distribuição para a esquerda. Mesmo que a distribuição não seja completamente simétrica ou normal, ela está suficientemente próxima para ser compatível com a maioria das técnicas de machine learning.\n",
        "\n",
        "A conformidade dos dados com uma **distribuição normal** é fundamental, pois numerosos **algoritmos de machine learning são projetados sob a suposição de que os dados são independentes e seguem uma distribuição normal**. Quanto mais a nossa variável resposta se assemelha a uma distribuição normal, **melhor será o desempenho dos modelos de machine learning**. Em determinadas situações, pode ser necessário aplicar técnicas de transformação, como a **transformação logarítmica**, para fazer a distribuição da variável resposta se aproximar de uma normal.\n"
      ],
      "metadata": {
        "id": "6Eny-oSlZNhU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importa a biblioteca necessária\n",
        "import numpy as np\n",
        "\n",
        "# Configura o estilo do gráfico\n",
        "sns.set_style('whitegrid')\n",
        "\n",
        "# Cria uma figura para conter os subplots\n",
        "plt.figure(figsize=(20, 6))\n",
        "\n",
        "# Cria o primeiro subplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.distplot(df4['sales'], kde=False, bins=50, color='blue')\n",
        "plt.title('Distribuição de Vendas')\n",
        "plt.xlabel('Vendas')\n",
        "plt.ylabel('Frequência')\n",
        "\n",
        "# Cria o segundo subplot\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(np.log1p(df4['sales']), kde=False, bins=50, color='blue')\n",
        "plt.title('Distribuição de Vendas (log1p transformada)')\n",
        "plt.xlabel('Vendas')\n",
        "plt.ylabel('Frequência')\n",
        "\n",
        "# Exibe os gráficos\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "45nBe629mBAY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Plotly**"
      ],
      "metadata": {
        "id": "rAh6q5LJndjm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importa as bibliotecas necessárias\n",
        "import plotly.graph_objects as go\n",
        "from plotly.subplots import make_subplots\n",
        "\n",
        "# Cria uma figura com 2 subplots (1 linha, 2 colunas)\n",
        "fig = make_subplots(rows=1, cols=2)\n",
        "\n",
        "# Adiciona o primeiro histograma à figura\n",
        "fig.add_trace(\n",
        "    go.Histogram(x=df4['sales'], nbinsx=50, name='Vendas'),\n",
        "    row=1, col=1\n",
        ")\n",
        "\n",
        "# Adiciona o segundo histograma à figura\n",
        "fig.add_trace(\n",
        "    go.Histogram(x=np.log1p(df4['sales']), nbinsx=50, name='Vendas (log1p transformada)'),\n",
        "    row=1, col=2\n",
        ")\n",
        "\n",
        "# Atualiza o layout da figura\n",
        "fig.update_layout(\n",
        "    title_text=\"Distribuição de Vendas\",\n",
        "    xaxis_title_text='Vendas',\n",
        "    yaxis_title_text='Frequência',\n",
        "    bargap=0.2,\n",
        "    bargroupgap=0.1\n",
        ")\n",
        "\n",
        "# Mostra a figura\n",
        "fig.show()"
      ],
      "metadata": {
        "id": "rXwUcJeQnYR0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Estamos plotando a **distribuição da variável sales** após aplicar a **transformação logarítmica (np.log1p)**, que ajuda a corrigir assimetria. Esta transformação visa aproximar a distribuição de uma **distribuição normal**, favorecendo o desempenho de muitos modelos de análise de dados e machine learning. O gráfico resultante facilita a compreensão da forma da distribuição transformada, **auxiliando na escolha de técnicas de modelagem apropriadas**."
      ],
      "metadata": {
        "id": "_7cn_uHOZXtI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **4.1.2 Numerical Variable**\n",
        "Neste trecho, está sendo realizada uma análise das variáveis numéricas presentes no conjunto de dados. É feita a seleção de todas as colunas numéricas disponíveis em num_attributes e,  em seguida,  é utilizado o método chamado \"hist\" para plotar um histograma dessas variáveis.\n",
        "\n",
        "O histograma é uma representação gráfica que mostra a distribuição dos valores de uma variável numérica. Ele é dividido em intervalos (bins) e em cada intervalo é contabilizada a quantidade de ocorrências dos valores da variável. Assim, é possível observar a concentração ou dispersão dos valores, bem como identificar padrões ou tendências na distribuição.\n",
        "\n",
        "Ao plotar o histograma das variáveis numéricas, podemos ter uma visão geral das características dessas variáveis, como a presença de valores atípicos (outliers), a simetria da distribuição e a concentração dos valores em determinados intervalos. Essa análise ajuda a compreender a natureza dos dados e a identificar possíveis padrões ou tendências que podem ser relevantes para a análise ou modelagem dos dados."
      ],
      "metadata": {
        "id": "zXGhHV2iXuqI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Seaborn**"
      ],
      "metadata": {
        "id": "fN7Z0eEepUtB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configura o tamanho dos gráficos\n",
        "fig = plt.figure(figsize=(20, 15))\n",
        "\n",
        "# Plota o histograma com as configurações especificadas\n",
        "ax = num_attributes.hist(bins=25, grid=False, color='blue', edgecolor='black', alpha=0.7,\n",
        "                         layout=(5, 3), figsize=(20, 15))\n",
        "\n",
        "# Adiciona um título ao gráfico e ajusta o tamanho da fonte\n",
        "fig.suptitle('Histogramas dos Atributos Numéricos', fontsize=20, y=0.92)\n",
        "\n",
        "# Itera através de cada subplot para ajustar o tamanho da fonte dos rótulos dos eixos x e y\n",
        "for subplot in ax.flatten():\n",
        "    subplot.set_xlabel('Valores', fontsize=12)\n",
        "    subplot.set_ylabel('Frequência', fontsize=12)\n",
        "\n",
        "# Ajusta o espaçamento entre os subplots\n",
        "plt.subplots_adjust(hspace=0.5)\n",
        "\n",
        "# Exibe o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "1ELhhKE4oUp9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A análise da variável **competition_distance** revela que há uma maior concentração de competidores próximos em termos de localização. Isso sugere que a maioria dos competidores estão situados em regiões semelhantes.\n",
        "\n",
        "A variável temporal que indica quando os competidores começaram a atuar revela um panorama interessante. Há competidores que se estabeleceram há apenas um mês, outros há dois, três meses e assim por diante. Curiosamente, as vendas atingem um pico quando consideramos competidores que iniciaram suas atividades há quatro meses. Posteriormente, ocorre uma queda, seguida por um crescimento no sétimo mês. Essa **flutuação de vendas ao longo do tempo é uma informação valiosa**, já que quanto mais variável é um dado, mais pode contribuir para compreender o fenômeno em estudo.\n",
        "\n",
        "Em contraste, a variável **day_of_week** possui variação quase nula. Isto é, as **vendas se mantêm consistentes, independentemente do dia da semana**. Dessa forma, esse dado não traz muitas informações relevantes para a aprendizagem do modelo, a menos que seja analisado em relação a outras variáveis.\n",
        "\n",
        "Outro dado importante é a variável **is_promo**. Nela, é possível verificar que as vendas são significativamente maiores quando não há promoção **0.0** do que quando há promoção **1.0**. Essa **tendência contra-intuitiva** requer uma exploração adicional para entendermos melhor sua lógica.\n",
        "\n",
        "Quando observamos a variável **promo2_since_year**, é possível constatar que houve um **pico de vendas em 2013**, seguido por um declínio subsequente.\n",
        "\n",
        "*Em resumo, a análise dessas variáveis nos proporciona insights valiosos sobre o comportamento das vendas. Esses padrões e tendências podem ser úteis para aprimorar a previsibilidade do nosso modelo de previsão de vendas.\n"
      ],
      "metadata": {
        "id": "-naaGTUxkuff"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **4.1.3 Categorical Variable**"
      ],
      "metadata": {
        "id": "kroCJagRX0GX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste trecho, estamos realizando uma análise das variáveis categóricas relacionadas a feriados. A ideia é transformar essas variáveis categóricas em numéricas para que possamos analisá-las de forma mais completa.\n"
      ],
      "metadata": {
        "id": "RKFyPqTBpRtJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cria um DataFrame para a variável 'state_holiday'\n",
        "state_holiday_unique = pd.DataFrame(df4['state_holiday'].drop_duplicates())\n",
        "\n",
        "# Redefine o índice do DataFrame\n",
        "state_holiday_unique.reset_index(drop=True, inplace=True)\n",
        "\n",
        "# Mostra o DataFrame\n",
        "print(state_holiday_unique)\n"
      ],
      "metadata": {
        "id": "zhqwI5uPreBk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste código, estamos trabalhando com a coluna **state_holiday**. A função **drop_duplicates()** é aplicada a esta coluna, que tem como objetivo identificar e **remover quaisquer valores duplicados, deixando apenas os valores únicos**."
      ],
      "metadata": {
        "id": "SiiU5ejCr_6w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Níveis da variável 'state_holiday'\n",
        "df4['state_holiday'].drop_duplicates()"
      ],
      "metadata": {
        "id": "oCl2TFXhX4h7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Seaborn**"
      ],
      "metadata": {
        "id": "DRxWg73PswMI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Define o estilo do gráfico como um fundo branco\n",
        "sns.set_style('white')\n",
        "\n",
        "# Cria uma figura para conter os subplots\n",
        "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 8))\n",
        "\n",
        "# Cria o primeiro subplot que é um gráfico de barras da coluna 'state_holiday' excluindo os 'regular_day'\n",
        "ax1 = sns.countplot(x='state_holiday', data=df4[df4['state_holiday'] != 'regular_day'], ax=axes[0])\n",
        "ax1.set_title('Contagem de Dias por Tipo de Feriado', fontsize=16)\n",
        "ax1.set_xlabel('Tipo de Feriado', fontsize=14)\n",
        "ax1.set_ylabel('Contagem', fontsize=14)\n",
        "\n",
        "# Adiciona rótulos em cada barra\n",
        "for p in ax1.patches:\n",
        "    ax1.annotate(format(p.get_height()), (p.get_x() + p.get_width() / 2., p.get_height()), ha='center', va='center', xytext=(0, 10), textcoords='offset points', fontsize=12)\n",
        "\n",
        "# Cria o segundo subplot que é um gráfico de densidade de 'sales' para cada tipo de 'state_holiday'\n",
        "ax2 = axes[1]\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'public_holiday']['sales'], label='Public Holiday', shade=True, ax=ax2)\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'easter_holiday']['sales'], label='Easter Holiday', shade=True, ax=ax2)\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'christmas']['sales'], label='Christmas', shade=True, ax=ax2)\n",
        "\n",
        "ax2.set_title('Distribuição de Vendas por Tipo de Feriado', fontsize=16)\n",
        "ax2.set_xlabel('Vendas', fontsize=14)\n",
        "ax2.set_ylabel('Densidade', fontsize=14)\n",
        "ax2.legend(title='Tipo de Feriado', fontsize=12)\n",
        "\n",
        "# Ajusta o layout para melhor visualização dos gráficos\n",
        "plt.tight_layout(pad=3.0)\n",
        "\n",
        "# Exibe os gráficos\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "NciEnUjOos9X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste código, analisamos o impacto dos diferentes tipos de feriados - **public_holiday**, **easter_holiday** e **christmas** - nas vendas.\n",
        "\n",
        "No primeiro gráfico, utilizamos o **countplot** do Seaborn para visualizar a quantidade de ocorrências de cada tipo de feriado, **excluindo o regular_day**. Este gráfico nos mostra a frequência de cada tipo de feriado em nossa base de dados.\n",
        "\n",
        "Nos outros gráficos, usamos a função **kdeplot** do Seaborn para traçar a distribuição das vendas durante cada tipo específico de feriado. Esses gráficos mostram como as vendas se comportam durante diferentes tipos de feriados.\n",
        "\n",
        "Temos que o **public_holiday** tem um volume muito maior de vendas, seguido de **christmas** e **easter_holiday**. Aqui conseguimos extrair uma informação interessante, onde ao tentar prever no modelo, se estivermos passando em um período de christmas ou easter, o modelo saberá dimensionar esse volume.\n",
        "\n",
        "A variável **state_holiday** será muito importante para as nossas análises e para o aprendizado do modelo."
      ],
      "metadata": {
        "id": "TsLmZIBfptHf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Store Type**"
      ],
      "metadata": {
        "id": "d97hoAPzp6D8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Níveis da variável 'store_type'\n",
        "df4['store_type'].drop_duplicates()"
      ],
      "metadata": {
        "id": "kT14Y7bgwZbg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Definindo o tamanho da figura\n",
        "plt.figure(figsize=(20, 15))\n",
        "\n",
        "# Gráfico 1 - state_holiday\n",
        "plt.subplot(2, 2, 1)  # Define o primeiro subplot numa matriz 2x2\n",
        "a = df4[df4['state_holiday'] != 'regular_day']  # Filtra o dataframe para excluir os dias regulares\n",
        "ax1 = sns.countplot(x='state_holiday', data=a, palette='viridis')  # Cria um gráfico de barras com a contagem dos diferentes tipos de feriados\n",
        "plt.title('Contagem de Dias por Tipo de Feriado', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Tipo de Feriado', fontsize=12)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Contagem', fontsize=12)  # Define o rótulo do eixo y\n",
        "ax1.grid(False)  # Remove a grade do gráfico\n",
        "\n",
        "# Anotação de texto para cada barra do gráfico\n",
        "for p in ax1.patches:\n",
        "    ax1.annotate(format(p.get_height()),\n",
        "                (p.get_x() + p.get_width() / 2., p.get_height()),\n",
        "                ha = 'center',\n",
        "                va = 'center',\n",
        "                xytext = (0, 10),\n",
        "                textcoords = 'offset points',\n",
        "                fontsize=10)\n",
        "\n",
        "# Gráfico 2 - state_holiday\n",
        "plt.subplot(2, 2, 2)  # Define o segundo subplot numa matriz 2x2\n",
        "# Cria gráficos de densidade para as vendas durante diferentes tipos de feriados\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'public_holiday']['sales'], label='Feriado público', shade=True)\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'easter_holiday']['sales'], label='Páscoa', shade=True)\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'christmas']['sales'], label='Natal', shade=True)\n",
        "plt.title('Distribuição de Vendas por Tipo de Feriado', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Vendas', fontsize=12)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Densidade', fontsize=12)  # Define o rótulo do eixo y\n",
        "plt.legend(title='Feriado')  # Adiciona a legenda ao gráfico\n",
        "plt.grid(False)  # Remove a grade do gráfico\n",
        "\n",
        "# Gráfico 3 - store_type\n",
        "plt.subplot(2, 2, 3)  # Define o terceiro subplot numa matriz 2x2\n",
        "# Cria um gráfico de barras com a contagem dos diferentes tipos de lojas, ordenado conforme lista ['a', 'b', 'c', 'd']\n",
        "ax2 = sns.countplot(x='store_type', data=df4, palette='viridis', order=['a', 'b', 'c', 'd'])\n",
        "plt.title('Contagem de Lojas por Tipo', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Tipo de Loja', fontsize=12)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Contagem', fontsize=12)  # Define o rótulo do eixo y\n",
        "ax2.grid(False)  # Remove a grade do gráfico\n",
        "\n",
        "# Anotação de texto para cada barra do gráfico\n",
        "for p in ax2.patches:\n",
        "    ax2.annotate(format(p.get_height()),\n",
        "                (p.get_x() + p.get_width() / 2., p.get_height()),\n",
        "                ha = 'center',\n",
        "                va = 'center',\n",
        "                xytext = (0, 10),\n",
        "                textcoords = 'offset points',\n",
        "                fontsize=10)\n",
        "\n",
        "# Gráfico 4 - store_type\n",
        "plt.subplot(2, 2, 4)  # Define o quarto subplot numa matriz 2x2\n",
        "# Cria gráficos de densidade para as vendas em diferentes tipos de lojas\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'a']['sales'], label='Loja a', shade=True)\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'b']['sales'], label='Loja b', shade=True)\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'c']['sales'], label='Loja c', shade=True)\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'd']['sales'], label='Loja d', shade=True)\n",
        "plt.title('Distribuição de Vendas por Tipo de Loja', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Vendas', fontsize=12)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Densidade', fontsize=12)  # Define o rótulo do eixo y\n",
        "plt.legend(title='Tipo de Loja')  # Adiciona a legenda ao gráfico\n",
        "plt.grid(False)  # Remove a grade do gráfico\n",
        "\n",
        "plt.tight_layout(pad=3.0)  # Ajusta o layout para melhor visualização dos gráficos\n",
        "\n",
        "plt.show()  # Exibe os gráficos"
      ],
      "metadata": {
        "id": "v3fuYuP7yMV_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nesta visualização, estamos analisando o volume de vendas associado a diferentes categorias de lojas. Nota-se que as lojas do tipo **a** exibem um volume de vendas consideravelmente alto, embora não apresentem um pico de vendas tão marcante quanto as lojas do tipo **d**. Em contraste, as lojas do tipo **b**, apesar de registrarem um volume de vendas substancial, não alcançam um ápice de vendas tão expressivo."
      ],
      "metadata": {
        "id": "mvDwROoQxUx4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Assortment**"
      ],
      "metadata": {
        "id": "n1pSIJVhp8I3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Níveis da variável 'assortment'\n",
        "df4['assortment'].drop_duplicates()"
      ],
      "metadata": {
        "id": "M080TX2ZyFbh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "plt.figure(figsize=(18, 24))  # Cria uma nova figura com o tamanho definido\n",
        "\n",
        "# Cria o primeiro subplot na figura\n",
        "plt.subplot(3, 2, 1)\n",
        "# Plota o gráfico de barras com a contagem de observações para cada categoria de 'state_holiday'\n",
        "sns.countplot(data=df4[df4['state_holiday'] != 'regular_day'], x='state_holiday')\n",
        "plt.title('Contagem de Feriados', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Tipo de Feriado', fontsize=14)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Contagem', fontsize=14)  # Define o rótulo do eixo y\n",
        "\n",
        "# Cria o segundo subplot na figura\n",
        "plt.subplot(3, 2, 2)\n",
        "# Plota os gráficos de densidade de probabilidade para as vendas nos diferentes tipos de feriados\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'public_holiday']['sales'], label='Feriado Público', shade=True)\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'easter_holiday']['sales'], label='Páscoa', shade=True)\n",
        "sns.kdeplot(data=df4[df4['state_holiday'] == 'christmas']['sales'], label='Natal', shade=True)\n",
        "plt.title('Distribuição de Vendas por Tipo de Feriado', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Vendas', fontsize=14)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Densidade', fontsize=14)  # Define o rótulo do eixo y\n",
        "plt.legend()  # Adiciona a legenda ao gráfico\n",
        "\n",
        "# Cria o terceiro subplot na figura\n",
        "plt.subplot(3, 2, 3)\n",
        "# Plota o gráfico de barras com a contagem de observações para cada categoria de 'store_type'\n",
        "sns.countplot(data=df4, x='store_type', order=['a', 'b', 'c', 'd'])\n",
        "plt.title('Contagem de Tipos de Loja', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Tipo de Loja', fontsize=14)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Contagem', fontsize=14)  # Define o rótulo do eixo y\n",
        "\n",
        "# Cria o quarto subplot na figura\n",
        "plt.subplot(3, 2, 4)\n",
        "# Plota os gráficos de densidade de probabilidade para as vendas nos diferentes tipos de lojas\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'a']['sales'], label='a', shade=True)\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'b']['sales'], label='b', shade=True)\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'c']['sales'], label='c', shade=True)\n",
        "sns.kdeplot(data=df4[df4['store_type'] == 'd']['sales'], label='d', shade=True)\n",
        "plt.title('Distribuição de Vendas por Tipo de Loja', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Vendas', fontsize=14)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Densidade', fontsize=14)  # Define o rótulo do eixo y\n",
        "plt.legend()  # Adiciona a legenda ao gráfico\n",
        "\n",
        "# Cria o quinto subplot na figura\n",
        "plt.subplot(3, 2, 5)\n",
        "# Plota o gráfico de barras com a contagem de observações para cada categoria de 'assortment'\n",
        "sns.countplot(data=df4, x='assortment')\n",
        "plt.title('Contagem de Sortimentos', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Tipo de Sortimento', fontsize=14)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Contagem', fontsize=14)  # Define o rótulo do eixo y\n",
        "\n",
        "# Cria o sexto subplot na figura\n",
        "plt.subplot(3, 2, 6)\n",
        "# Plota os gráficos de densidade de probabilidade para as vendas nos diferentes tipos de sortimentos\n",
        "sns.kdeplot(data=df4[df4['assortment'] == 'extended']['sales'], label='Estendido', shade=True)\n",
        "sns.kdeplot(data=df4[df4['assortment'] == 'basic']['sales'], label='Básico', shade=True)\n",
        "sns.kdeplot(data=df4[df4['assortment'] == 'extra']['sales'], label='Extra', shade=True)\n",
        "plt.title('Distribuição de Vendas por Tipo de Sortimento', fontsize=16)  # Define o título do gráfico\n",
        "plt.xlabel('Vendas', fontsize=14)  # Define o rótulo do eixo x\n",
        "plt.ylabel('Densidade', fontsize=14)  # Define o rótulo do eixo y\n",
        "plt.legend()  # Adiciona a legenda ao gráfico\n",
        "\n",
        "plt.tight_layout()  # Ajusta o layout para evitar sobreposição de gráficos\n",
        "plt.show()  # Exibe a figura com todos os gráficos"
      ],
      "metadata": {
        "id": "wJYadbz3qFyB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Os tipos de sortimento que registram as maiores vendas são **básico**, **extended** e **extra**. Apesar do sortimento **extra** apresentar um pico de vendas menor, ele se destaca por sua distribuição de vendas ampla e consistente."
      ],
      "metadata": {
        "id": "zgAzP5s7zQtI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **4.2 Análise Bivariada**\n",
        "Nesta seção, iremos conduzir uma análise bivariada com o objetivo de **validar as hipóteses** estabelecidas durante a fase de **feature engineering**, especificamente no Passo 2. Faremos uma revisão das hipóteses selecionadas, utilizando os dados disponíveis até o momento, e procederemos com uma avaliação detalhada das mesmas."
      ],
      "metadata": {
        "id": "nha68NyEXfzO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **H1. Lojas com maior sortimento vendem mais**\n",
        "A primeira hipótese a ser validada é a de que lojas com maior sortimento tendem a ter um volume de vendas superior. Para explorar essa relação, vamos investigar a variável resposta em relação ao tamanho do sortimento das lojas."
      ],
      "metadata": {
        "id": "F5WElWJgrKTF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Agrupando e redefinindo o índice\n",
        "aux1 = df4[['assortment', 'sales']].groupby('assortment').sum().reset_index()\n",
        "\n",
        "# Configurando o tamanho do gráfico para ocupar a área do notebook\n",
        "plt.figure(figsize=(12, 6))\n",
        "\n",
        "# Criando o gráfico de barras com Seaborn\n",
        "sns.barplot(x = 'assortment', y = 'sales', data = aux1, palette=\"viridis\")\n",
        "\n",
        "# Definindo o título do gráfico e dos eixos\n",
        "plt.title('Vendas Totais por Tipo de Sortimento', fontsize=16)\n",
        "plt.xlabel('Tipo de Sortimento', fontsize=14)\n",
        "plt.ylabel('Vendas Totais', fontsize=14)\n",
        "\n",
        "# Removendo as bordas do gráfico\n",
        "sns.despine()\n",
        "\n",
        "# Exibindo o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "BR-If1_gG4hd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Em busca de entender o impacto do mix de produtos nas vendas das lojas, iniciamos uma análise detalhada centrada em duas colunas de nossos dados: **assortment** (Sortimento) e **sales** (Vendas).\n",
        "\n",
        "### **O Passo a Passo da Nossa Análise**\n",
        "- **Agrupamento por Sortimento**: Os dados foram organizados em grupos conforme a categoria de sortimento de cada loja. Isso é crucial para entendermos como cada tipo de mix de produtos se comporta.\n",
        "- **Soma das Vendas**: Para cada tipo de sortimento, somamos todas as vendas. Esse cálculo nos dá uma visão clara do desempenho de vendas de cada grupo.\n",
        "\n",
        "### **O Que Descobrimos?**\n",
        "\n",
        "Ao observar as vendas totais por tipo de sortimento, notamos algo interessante: as lojas com sortimento **Extra**, apesar de aparentemente possuírem um mix de produtos maior, **apresentam vendas inferiores quando comparadas às outras categorias**. Isso contradiz nossa hipótese inicial de que um maior sortimento resultaria em maiores vendas.\n",
        "\n",
        "### **Possíveis Explicações e Próximos Passos**\n",
        "Surge uma questão importante: este cenário **sempre foi assim ou houve uma mudança de comportamento ao longo do tempo?** Talvez o sortimento **Extra** tenha sido mais popular no passado, porém agora está em queda.\n",
        "Para responder a isso, **precisamos analisar as vendas totais por dia** e não apenas por categoria de sortimento.\n",
        "\n",
        "A partir disso, podemos investigar se houve mudanças significativas nas vendas ao longo do tempo e validar nossa hipótese.\n",
        "\n",
        "Nossa próxima etapa é expandir nossa análise: faremos uma cópia dos dados, incluindo a variável **year_week** (Semana do Ano). Assim, faremos uma nova soma das vendas, considerando também a categoria de sortimento e a semana do ano.\n",
        "\n",
        "Após essas etapas, vamos ilustrar as tendências identificadas por meio de gráficos. Dessa maneira, continuaremos a validar nossas hipóteses e a obter insights valiosos para a tomada de decisões mais informadas.\n",
        "\n",
        "Essa análise nos ajuda a entender a relação entre o mix de produtos das lojas e as vendas, proporcionando uma visão mais completa do desempenho do negócio ao longo do tempo."
      ],
      "metadata": {
        "id": "mjxw-6e-HmEh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando as bibliotecas necessárias\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Definindo um esquema de cores mais suave\n",
        "sns.set_palette('Set2')\n",
        "\n",
        "# Ajustando o tamanho da figura para preencher uma área maior\n",
        "fig, ax = plt.subplots(figsize=(20, 12))\n",
        "\n",
        "# Criando um DataFrame agrupado por 'assortment' e 'year_week' e somando as 'sales'\n",
        "aux2 = df4[['year_week','assortment', 'sales']].groupby(['assortment', 'year_week']).sum().reset_index()\n",
        "\n",
        "# Criando um gráfico de linhas a partir do DataFrame pivot\n",
        "pivot_df = aux2.pivot(index = 'year_week', columns = 'assortment', values = 'sales')\n",
        "pivot_df.plot(ax=ax)\n",
        "\n",
        "# Removendo os grids\n",
        "ax.grid(False)\n",
        "\n",
        "# Adicionando título ao gráfico e aos eixos\n",
        "ax.set_title('Vendas Semanais Segmentadas por Sortimento', fontsize=20, pad=20)\n",
        "ax.set_xlabel('Semana do Ano', fontsize=16)\n",
        "ax.set_ylabel('Vendas', fontsize=16)\n",
        "\n",
        "# Ajustando a legenda\n",
        "ax.legend(title='Tipo de Sortimento', title_fontsize='15', fontsize='14')\n",
        "\n",
        "# Exibindo o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "yVNbmc6S7lmS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Comportamento Paralelo: As categorias **basic** e **extended** apresentam trajetórias de vendas semelhantes. Mesmo que a categoria **basic** demonstre um volume de vendas ligeiramente superior, ambas as categorias seguem uma tendência de vendas bastante similar ao longo do tempo.\n",
        "\n",
        "Contraste: Em contrapartida, a categoria **extra** se destaca por seu volume de vendas significativamente mais baixo. Isto é, as vendas nas categorias **basic** e **extended** são tão expressivas que, ao serem apresentadas na mesma escala de gráfico, fazem com que as vendas da categoria **extra** pareçam insignificantes em comparação.\"\n",
        "\n"
      ],
      "metadata": {
        "id": "4lzCXUGYKbUA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Aumentando o tamanho do gráfico\n",
        "plt.figure(figsize=(20, 10))\n",
        "\n",
        "# Selecionando apenas os dados da categoria 'extra'\n",
        "aux3 = aux2[aux2['assortment'] == 'extra']\n",
        "\n",
        "# Criando o gráfico\n",
        "ax = sns.lineplot(x = 'year_week', y = 'sales', data = aux3, color = 'royalblue')\n",
        "\n",
        "# Ajustando as legendas e os rótulos dos eixos\n",
        "ax.set_title('Vendas Semanais da Categoria Extra ao Longo do Tempo', fontsize=16)\n",
        "ax.set_xlabel('Semana do Ano', fontsize=14)\n",
        "ax.set_ylabel('Vendas', fontsize=14)\n",
        "\n",
        "# Rotacionando os rótulos do eixo x e mostrando apenas um rótulo a cada 20 rótulos\n",
        "for ind, label in enumerate(ax.get_xticklabels()):\n",
        "    if ind % 20 == 0:  # ajuste este número conforme necessário\n",
        "        label.set_visible(True)\n",
        "        label.set_rotation(45)\n",
        "    else:\n",
        "        label.set_visible(False)\n",
        "\n",
        "# Removendo a grade do gráfico\n",
        "sns.despine()\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "muKqgx1k9ujr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Iniciamos nossa análise com um foco particular na categoria de sortimento **Extra**. Nesse contexto, procuramos entender as características únicas e os padrões de vendas específicos dessa categoria. Isso nos permitiu isolar e analisar a performance de vendas do sortimento **Extra** de maneira detalhada e criteriosa.\n",
        "\n",
        "A investigação revelou um **padrão de vendas não linear** para a categoria **Extra**, conforme ilustrado no gráfico. Cabe ressaltar a importância de prestar especial atenção ao eixo Y do gráfico. A variação nas vendas pode ser substancial, e, em situações em que alguns valores são muito mais prevalentes que outros, a representação visual precisa ser adaptada para garantir a clareza e a precisão da informação exibida.\n",
        "\n",
        "A análise dos dados nos levou a **conclusões surpreendentes**, desafiando a suposição inicial. Descobrimos que as lojas com uma variedade mais ampla de produtos, aqui representadas pela categoria **Extra**, na verdade apresentam vendas menores. Esta conclusão intrigante aponta para um comportamento de vendas na categoria **Extra** que é nitidamente diferente das outras categorias.\n",
        "\n",
        "Essas observações, por fim, confirmam a conclusão de que a variedade de produtos disponíveis em uma loja não se traduz necessariamente em **maiores vendas**. Contrariando a suposição comum de que um sortimento mais amplo atrairia uma base de clientes mais diversificada e, consequentemente, levaria a um aumento nas vendas, percebemos que a categoria **Extra**, com a maior diversidade de produtos, apresenta um desempenho pior em vendas em relação às outras categorias."
      ],
      "metadata": {
        "id": "NQQkzbDwLykH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **H2. Lojas com concorrentes mais próximos vendem menos**\n",
        "Com o objetivo de validar a hipótese, procederemos com uma análise das vendas em relação à **distância dos competidores**.\n",
        "\n",
        "Para esta análise, selecionamos as colunas de interesse, que são \"**competition_distance**\" e \"**sales**\", pois são essenciais para nosso estudo.\n",
        "\n",
        "Em seguida, realizamos o **agrupamento dos dados** com base na **distância dos concorrentes**, agregando as vendas correspondentes a cada grupo de distância.\n",
        "\n",
        "Dessa forma, obteremos insights sobre como as vendas estão relacionadas à proximidade dos competidores, permitindo uma compreensão mais profunda do comportamento do mercado em relação a esse aspecto específico."
      ],
      "metadata": {
        "id": "pKHsN0fhrOb5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configuração do tamanho da figura\n",
        "plt.figure(figsize=(14, 8))\n",
        "\n",
        "# Agrupamento dos dados pela distância dos competidores e soma das vendas correspondentes\n",
        "aux1 = df4[['competition_distance', 'sales']].groupby('competition_distance').sum().reset_index()\n",
        "\n",
        "# Definindo cores de contraste\n",
        "bar_color = 'steelblue'\n",
        "bg_color = 'white'\n",
        "label_color = 'black'\n",
        "\n",
        "# Gráfico de barras\n",
        "sns.barplot(x='competition_distance', y='sales', data=aux1, color=bar_color)\n",
        "\n",
        "# Configuração do fundo e das cores dos rótulos\n",
        "sns.set(style='whitegrid', rc={'axes.facecolor': bg_color, 'grid.color': label_color})\n",
        "plt.rcParams['text.color'] = label_color\n",
        "\n",
        "# Configuração dos rótulos e títulos\n",
        "plt.title('Vendas por Distância dos Competidores', fontsize=16, color=label_color)\n",
        "plt.xlabel('Distância dos Competidores', fontsize=14, color=label_color)\n",
        "plt.ylabel('Vendas', fontsize=14, color=label_color)\n",
        "\n",
        "# Configuração das cores dos ticks dos eixos x e y\n",
        "plt.xticks(color=label_color)\n",
        "plt.yticks(color=label_color)\n",
        "\n",
        "# Ajusta o layout para evitar sobreposições\n",
        "plt.tight_layout()\n",
        "\n",
        "# Exibe o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "o5aUSoUhNDe8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao analisarmos, notamos que a granularidade dos dados dificulta a identificação de padrões. Para melhorar a visualização, seria recomendável criar grupos de distância, por exemplo, agrupando em intervalos de 10 unidades, a fim de agregar as vendas em cada grupo de distância. Isso permitirá uma visão mais clara das tendências e facilitará a análise das relações entre a distância dos competidores e as vendas."
      ],
      "metadata": {
        "id": "SiQqLOhYNO-8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Seleciona as colunas relevantes para a análise\n",
        "aux1 = df4[['competition_distance', 'sales']].groupby('competition_distance').sum().reset_index()\n",
        "\n",
        "# Define os intervalos para agrupar a distância dos competidores\n",
        "bins = list(np.arange(0, 20000, 1000))\n",
        "\n",
        "# Agrupa os dados pela distância dos competidores em intervalos\n",
        "aux1['competition_distance_binned'] = pd.cut(aux1['competition_distance'], bins=bins)\n",
        "\n",
        "# Exibe uma amostra de 5 linhas da tabela\n",
        "aux1.sample(5)"
      ],
      "metadata": {
        "id": "d-9H5zdZcCqG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Por vezes, necessitamos categorizar variáveis contínuas em intervalos distintos, processo conhecido como **binning**. No exemplo mencionado, o binning será aplicado em uma variável chamada **competition_distance**.\n",
        "\n",
        "Primeiramente, é necessário definir os intervalos ou **bins** que serão utilizados. Neste caso, optou-se por um array que varia de 0 a 20.000, com um **passo de 1.000**. Ou seja, os dados serão divididos em grupos de 1.000.\n",
        "\n",
        "O resultado desse processo é uma nova variável que indica a que grupo (ou bin) cada valor original pertence. No exemplo citado, a nova variável será chamada **competition_distance_binned**. Assim, em vez de termos a distância exata em **competition_distance**, agora temos em qual grupo de 1.000 essa distância se encaixa na nova coluna **competition_distance_binned**.\n",
        "\n",
        "Por exemplo, se o valor da **competition_distance** original é 20, ele é categorizado dentro do grupo de 0 a 1.000 na nova variável **competition_distance_binned**. Isso se repete para outros valores. Se temos um valor de 14.600 na competição original, ele é mapeado para o grupo de 14.000 a 15.000 na nova variável. Do mesmo modo, um valor original de 18.010 é mapeado para o grupo de 18.000 a 19.000, e assim por diante."
      ],
      "metadata": {
        "id": "YzfYtNelcaNy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "# Cria um DataFrame com a soma das vendas por grupo de distância\n",
        "aux1 = df4[['competition_distance', 'sales']].groupby('competition_distance').sum().reset_index()\n",
        "bins = list(np.arange(0, 20000, 1000))\n",
        "aux1['competition_distance_binned'] = pd.cut(aux1['competition_distance'], bins=bins)\n",
        "aux2 = aux1[['competition_distance_binned', 'sales']].groupby('competition_distance_binned').sum().reset_index()\n",
        "\n",
        "# Configura o estilo do gráfico para um fundo branco sem linhas de grade\n",
        "sns.set_style('whitegrid')\n",
        "\n",
        "# Cria uma figura para conter o gráfico\n",
        "plt.figure(figsize=(14, 8))\n",
        "\n",
        "# Plota o gráfico de barras com o DataFrame aux2\n",
        "sns.barplot(x=aux2['competition_distance_binned'].astype(str), y='sales', data=aux2, palette='viridis')\n",
        "\n",
        "# Adiciona título aos eixos x e y\n",
        "plt.xlabel('Distância dos Competidores Agrupada (em unidades de 1000)', fontsize=14)\n",
        "plt.ylabel('Vendas Totais', fontsize=14)\n",
        "\n",
        "# Adiciona título ao gráfico\n",
        "plt.title('Vendas Totais em Relação à Distância dos Competidores', fontsize=16)\n",
        "\n",
        "# Rotaciona os rótulos do eixo x para melhor legibilidade\n",
        "plt.xticks(rotation=45, ha='right', fontsize=12)\n",
        "\n",
        "# Exibe o gráfico\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "-9AP2m8yCLuR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao avaliarmos os dados pós método de binning, identificamos que o **maior volume de vendas** para a variável **competition_distance** encontra-se no **intervalo de 0 a 1.000 metros**.\n",
        "\n",
        "Essa observação desafia uma hipótese amplamente aceita: a de que lojas situadas próximas aos seus concorrentes possuiriam um volume de vendas inferior, uma vez que enfrentariam uma concorrência mais acirrada. Contudo, as informações obtidas indicam uma realidade inversa. **As lojas com concorrentes nas proximidades parecem registrar um volume maior de vendas.**\n",
        "\n",
        "Essa tendência pode ser influenciada por diversos fatores macroeconômicos, tais como:\n",
        "\n",
        "- **Concorrência de Preços**: Em áreas onde os concorrentes estão agrupados, é comum uma **competição de preços mais intensa**. Isso pode levar a **preços mais baixo**, atraindo um maior número de consumidores e, por consequência, elevando o volume de vendas.\n",
        "\n",
        "- **Variedade de Produtos**: A proximidade de múltiplos competidores pode resultar em uma maior diversidade de produtos ofertados aos consumidores. Isso pode cativar um público mais amplo, elevando assim as vendas.\n",
        "\n",
        "- **Conveniência**: Com uma grande quantidade de lojas em uma área limitada, os consumidores têm a vantagem de poder comparar produtos e preços sem a necessidade de percorrer grandes distâncias. Essa facilidade pode estimular mais compras e, consequentemente, ampliar as vendas.\n",
        "\n",
        "- **Serviço ao Cliente**: A presença de competidores nas proximidades pode incentivar cada loja a aprimorar o seu atendimento ao cliente, de forma a se destacar das demais. Um atendimento superior pode impulsionar as vendas.\n",
        "\n",
        "- **Estratégias de Marketing**: Em cenários com uma alta concentração de concorrentes, é comum que as lojas invistam mais em estratégias de marketing para atrair a clientela. Isso também pode acarretar no aumento do volume de vendas.\n",
        "\n",
        "- **Efeito de Aglomeração**: Em determinadas regiões, a concentração de várias lojas em uma mesma área pode criar um \"ponto de compras\", atraindo mais consumidores e potencializando as vendas de todas as lojas no local.\n",
        "\n"
      ],
      "metadata": {
        "id": "rcGLgW7PfV7n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "# Prepara os dados\n",
        "aux1 = df4[['competition_distance', 'sales']].groupby('competition_distance').sum().reset_index()\n",
        "\n",
        "# Configura o estilo do gráfico para um fundo branco sem linhas de grade\n",
        "sns.set_style('whitegrid')\n",
        "\n",
        "# Cria uma figura para conter o gráfico\n",
        "plt.figure(figsize=(14, 8))\n",
        "\n",
        "# Plota o gráfico de dispersão com o DataFrame aux1\n",
        "sns.scatterplot(x = 'competition_distance', y = 'sales', data = aux1, palette='viridis')\n",
        "\n",
        "# Adiciona título aos eixos x e y\n",
        "plt.xlabel('Distância dos Competidores', fontsize=14)\n",
        "plt.ylabel('Vendas Totais', fontsize=14)\n",
        "\n",
        "# Adiciona título ao gráfico\n",
        "plt.title('Vendas Totais em Relação à Distância dos Competidores', fontsize=16)\n",
        "\n",
        "# Configura os ticks do eixo x para melhor legibilidade\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Configura o limites dos eixos x e y\n",
        "plt.xlim(0, aux1['competition_distance'].max() + 1000)  # adiciona uma margem de 1000 para o valor máximo do eixo x\n",
        "plt.ylim(0, aux1['sales'].max() + 1000)  # adiciona uma margem de 1000 para o valor máximo do eixo y\n",
        "\n",
        "# Exibe o gráfico\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "-5blIkrL8HNx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Através da análise do nosso **scatter plot**, conseguimos observar uma tendência interessante: as lojas que têm **concorrentes mais próximos vendem mais**. Temos também um caso curioso de uma loja cujo competidor mais próximo está a uma distância de 200 mil metros - essa é a substituição que aplicamos na nossa análise descritiva, mas a maioria das nossas vendas está bem ali, nas lojas com os competidores ao lado.\n",
        "\n",
        "Para aprofundar nossa análise, vamos montar uma grade com um trio de gráficos. No primeiro sublot, vamos colocar nosso scatter plot. No segundo subplot, um **gráfico de barras**, usando os dados do scatter plot.\n",
        "\n",
        "Agora, guardamos o melhor para o final. No último subplot, vamos criar um mapa de calor, ou **heatmap**, que vai nos mostrar a força da relação entre as variáveis. Para isso, vamos aplicar o método **corr** no nosso dataframe **aux1**, que vai calcular essa correlação. Em seguida, usamos o método **heatmap** para transformar essas correlações em um gráfico visualmente impactante. Como queremos ver os valores dessa correlação, vamos acrescentar a opção **annot=True** na função **heatmap**.\n",
        "\n",
        "Com esses gráficos, conseguimos nos aprofundar na relação entre a proximidade da concorrência e o volume de vendas das lojas."
      ],
      "metadata": {
        "id": "WwRKeNAciGuf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Aumentar o tamanho da fonte\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Configura o estilo do gráfico para um fundo branco sem linhas de grade\n",
        "sns.set_style('whitegrid')\n",
        "\n",
        "# Define o tamanho da figura\n",
        "plt.figure(figsize=(20, 10))\n",
        "\n",
        "aux1 = df4[['competition_distance', 'sales']].groupby('competition_distance').sum().reset_index()\n",
        "\n",
        "# Subplot 1\n",
        "plt.subplot(2, 2, 1)\n",
        "sns.scatterplot(x = 'competition_distance', y = 'sales', data = aux1)\n",
        "plt.title('Scatterplot: Distância da Competição vs Vendas', fontsize=16)\n",
        "plt.xlabel('Distância da Competição', fontsize=14)\n",
        "plt.ylabel('Vendas', fontsize=14)\n",
        "\n",
        "# Cria 'bins' para a distância da competição\n",
        "bins = list(np.arange(0, 20000, 1000))\n",
        "aux1['competition_distance_binned'] = pd.cut(aux1['competition_distance'], bins = bins)\n",
        "\n",
        "# Agrupa os dados de acordo com os bins\n",
        "aux2 = aux1[['competition_distance_binned', 'sales']].groupby('competition_distance_binned').sum().reset_index()\n",
        "\n",
        "# Subplot 2\n",
        "plt.subplot(2, 2, 2)\n",
        "sns.barplot(x = 'competition_distance_binned', y = 'sales', data = aux2, palette='viridis')\n",
        "plt.title('Barplot: Bins da Distância da Competição vs Vendas', fontsize=16)\n",
        "plt.xlabel('Bins de Distância da Competição', fontsize=14)\n",
        "plt.ylabel('Vendas', fontsize=14)\n",
        "plt.xticks(rotation=45, ha='right')\n",
        "\n",
        "# Subplot 3\n",
        "plt.subplot(2, 2, 3)\n",
        "sns.heatmap(aux1.corr(method = 'pearson'), annot = True, cmap='coolwarm', fmt=\".2f\")\n",
        "plt.title('Heatmap: Correlação de Pearson', fontsize=16)\n",
        "\n",
        "# Ajusta os subplots para evitar sobreposição\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "tbn7yhJpANFS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Validação da Hipótese**\n",
        "A nossa investigação apontou uma **correlação de -0.23**. Embora este valor não se destaque por sua magnitude, ele demonstra uma relação inversa de grau moderado entre as duas variáveis em questão. Isto significa que, contrariamente ao que se poderia esperar, **as vendas tendem a diminuir conforme a distância para o concorrente mais próximo aumenta**.\n",
        "\n",
        "Esta descoberta pode parecer contra-intuitiva à primeira vista. De forma geral, **é comum pensar que a proximidade de concorrentes levaria a uma queda nas vendas**, uma vez que os clientes teriam mais opções à disposição. No entanto, os nossos dados sugerem o contrário, reforçando que a realidade do mercado pode ser mais complexa do que as suposições iniciais."
      ],
      "metadata": {
        "id": "SgizDIRUnHDH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **H3. Lojas com concorrente há mais tempo tendem a apresentar um maior volume de vendas.**\n",
        "Nossa intenção é compreender a correlação entre o período que uma loja tem enfrentado a competição e o impacto que isso exerce sobre as vendas. Para realizar essa análise, recorremos a duas colunas do nosso conjunto de dados: **competition_open_since_month** (início da competição) e **sales** (vendas).\n",
        "\n",
        "Inicialmente, realizamos uma **categorização de todas as vendas com base na data de início da competição**, somando todos os respectivos valores para cada período específico."
      ],
      "metadata": {
        "id": "S-3Gabs5rTV8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configura o estilo do Seaborn para um fundo branco sem linhas de grade\n",
        "sns.set_style('white')\n",
        "\n",
        "# Aumenta o tamanho da fonte padrão\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Cria um DataFrame com a soma das vendas por mês de início da competição\n",
        "aux1 = df4[['competition_open_since_month', 'sales']].groupby('competition_open_since_month').sum().reset_index()\n",
        "\n",
        "# Cria uma figura para conter o gráfico\n",
        "plt.figure(figsize=(14, 8))\n",
        "\n",
        "# Plota o gráfico de barras com o DataFrame aux1 e guarda o gráfico numa variável\n",
        "# Nota: as vendas são convertidas para milhões para facilitar a visualização\n",
        "barplot = sns.barplot(x='competition_open_since_month', y=aux1['sales'] / 1_000_000, data=aux1, palette='viridis')\n",
        "\n",
        "# Adiciona título aos eixos x e y\n",
        "plt.xlabel('Mês de Início da Competição', fontsize=14)\n",
        "plt.ylabel('Vendas Totais (em milhões)', fontsize=14)\n",
        "\n",
        "# Adiciona título ao gráfico\n",
        "plt.title('Vendas Totais em Relação ao Mês de Início da Competição', fontsize=16)\n",
        "\n",
        "# Rotaciona os rótulos do eixo x para melhor legibilidade\n",
        "plt.xticks(rotation=45, ha='right', fontsize=12)\n",
        "\n",
        "# Adiciona rótulos a cada barra, convertidos para milhões e com três casas decimais\n",
        "for p in barplot.patches:\n",
        "    height = p.get_height()\n",
        "    barplot.text(p.get_x()+p.get_width()/2.,\n",
        "            height,\n",
        "            '{:1.3f}'.format(height),\n",
        "            ha=\"center\", va='bottom')\n",
        "\n",
        "# Exibe o gráfico\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "H7Bsi_zuXXuj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Por exemplo, as lojas onde a **concorrência começou no mês 9 apresentam o maior volume de vendas**. Contudo, esta visão inicial não fornece os esclarecimentos que procuramos, pois nosso objetivo é **compreender a influência do período de tempo** em que a concorrência esteve ativa sobre as vendas.\n",
        "\n",
        "Assim, precisamos levar em conta a **duração da competição**, que se refere ao número de meses durante os quais a competição está ativa. Por exemplo, se a competição foi iniciada no mês 9 e estamos analisando as vendas no mês 10, isso implica que a competição está ativa há apenas um mês."
      ],
      "metadata": {
        "id": "0DIgEZB-pfAW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(14, 8))\n",
        "\n",
        "# Plotar o gráfico de barras\n",
        "sns.barplot(x = 'competition_time_month', y = 'sales', data = aux2, palette='viridis')\n",
        "\n",
        "# Adicionar título ao gráfico e aos eixos\n",
        "plt.title('Vendas Totais em Relação ao Tempo de Competição (em meses)', fontsize=16)\n",
        "plt.xlabel('Tempo de Competição (em meses)', fontsize=14)\n",
        "plt.ylabel('Vendas Totais', fontsize=14)\n",
        "\n",
        "# Rotacionar os rótulos do eixo x para melhor visualização e ajustar para aparecer a cada 10 intervalos\n",
        "plt.xticks(np.arange(0, len(aux2), 10), aux2['competition_time_month'][::10], rotation=45, ha='right', fontsize=12)\n",
        "\n",
        "# Exibir o gráfico\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "9amE0wh_qbk7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aqui nos concentramos nos primeiros 120 meses de competição. Do nosso conjunto de dados inicial, selecionamos apenas as linhas que representam este período.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "2EIBwQ1KrSvS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nesta análise, resolvemos **focar nos primeiros 120 meses após a abertura da concorrência**.\n",
        "\n",
        "Ao montar a variável **competition_time_month**, fizemos uma espécie de linha do tempo das vendas, onde subtraímos a data de cada venda da data de inauguração do competidor. Quando a venda aconteceu depois da chegada do competidor, o resultado foi positivo. Já se a venda foi antes, o resultado ficou negativo.\n",
        "\n",
        "Ficou evidente uma certa tendência: **quanto mais os valores de \"competition_time_month\" se aproximam de zero, ou seja, quanto mais recentee é a competição, o volume de vendas parece crescer**. O senso comum diria que a chegada de novos concorrentes gera uma movimentação no mercado, com clientes experimentando novas lojas, o que tenderia a derrubar as vendas.\n",
        "\n",
        "A tendência geral seria esperar uma queda inicial nas vendas com a entrada de novos competidores, seguida de uma estabilização à medida que os clientes vão se acostumando com as novas opções de lojas. Mas os nossos dados apontam para uma realidade diferente. Segundo eles, **quanto mais novo o competidor, mais as vendas sobem**."
      ],
      "metadata": {
        "id": "yphlbFA0sWiu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define o estilo dos gráficos para um fundo branco sem linhas de grade\n",
        "sns.set_style('white')\n",
        "\n",
        "# Define o tamanho da figura para que ocupe toda a largura do notebook\n",
        "plt.figure(figsize=(30, 10))\n",
        "\n",
        "# Primeiro gráfico: um gráfico de barras mostrando vendas por mês de competição\n",
        "plt.subplot(1, 3, 1)\n",
        "aux1 = df4[['competition_time_month', 'sales']].groupby('competition_time_month').sum().reset_index()\n",
        "aux2 = aux1[(aux1['competition_time_month'] < 120) & (aux1['competition_time_month'] != 0)]\n",
        "bp = sns.barplot(x = 'competition_time_month', y = 'sales', data = aux2)\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Meses de Competição', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.title('Vendas vs. Meses de Competição', fontsize=14)\n",
        "\n",
        "# Controla os rótulos do eixo x, mantendo apenas a cada 10 meses\n",
        "labels = bp.get_xticklabels()\n",
        "plt.xticks([i for i in range(0, len(labels), 10)], [l.get_text() for l in labels[::10]], rotation=45, ha='right')\n",
        "\n",
        "# Segundo gráfico: uma regressão linear entre meses de competição e vendas\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x = 'competition_time_month', y = 'sales', data = aux2, scatter_kws={'s': 5})\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Meses de Competição', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.title('Regressão Linear: Vendas vs. Meses de Competição', fontsize=14)\n",
        "\n",
        "# Ajusta os subplots para evitar sobreposição\n",
        "plt.tight_layout()\n",
        "\n",
        "# Mostra o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "b7rkOWtLuXBQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Recorremos à função **regplot** para delinear uma linha de tendência, dando-nos uma perspectiva mais clara sobre a relação entre as variáveis.\n",
        "\n",
        "O **regplot**, que além de ilustrar cada ponto individualmente, também desenha uma **linha de tendência para realçar o padrão global** dos dados.\n",
        "\n",
        "Para concluir nossa análise, montamos um **heatmap de correlação**. Esta etapa é vital para compreender a intensidade e a direção da associação entre as variáveis. Este panorama nos permite tirar conclusões mais informadas e precisas sobre os nossos dados.\n",
        "\n"
      ],
      "metadata": {
        "id": "us5_xjoYpM29"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define o estilo dos gráficos para um fundo branco sem linhas de grade\n",
        "sns.set_style('white')\n",
        "\n",
        "# Define o tamanho da figura para que ocupe toda a largura do notebook\n",
        "plt.figure(figsize=(30, 10))\n",
        "\n",
        "# Primeiro gráfico: um gráfico de barras mostrando vendas por mês de competição\n",
        "plt.subplot(1, 3, 1)\n",
        "aux1 = df4[['competition_time_month', 'sales']].groupby('competition_time_month').sum().reset_index()\n",
        "aux2 = aux1[(aux1['competition_time_month'] < 120) & (aux1['competition_time_month'] != 0)]\n",
        "bp = sns.barplot(x = 'competition_time_month', y = 'sales', data = aux2)\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Meses de Competição', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.title('Vendas vs. Meses de Competição', fontsize=14)\n",
        "\n",
        "# Controla os rótulos do eixo x, mantendo apenas a cada 10 meses\n",
        "labels = bp.get_xticklabels()\n",
        "plt.xticks([i for i in range(0, len(labels), 10)], [l.get_text() for l in labels[::10]], rotation=45, ha='right')\n",
        "\n",
        "# Segundo gráfico: uma regressão linear entre meses de competição e vendas\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x = 'competition_time_month', y = 'sales', data = aux2, scatter_kws={'s': 5})\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Meses de Competição', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.title('Regressão Linear: Vendas vs. Meses de Competição', fontsize=14)\n",
        "\n",
        "# Terceiro gráfico: mapa de calor das correlações\n",
        "plt.subplot(1, 3, 3)\n",
        "hm = sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='coolwarm')\n",
        "\n",
        "# Ajusta o mapa de calor para corrigir problemas de recorte da imagem\n",
        "bottom, top = hm.get_ylim()\n",
        "hm.set_ylim(bottom+0.5, top-0.5)\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Variáveis', fontsize=12)\n",
        "plt.ylabel('Variáveis', fontsize=12)\n",
        "plt.title('Mapa de Calor das Correlações', fontsize=14)\n",
        "\n",
        "# Ajusta os subplots para evitar sobreposição\n",
        "plt.tight_layout()\n",
        "\n",
        "# Mostra o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "BmkzQcbTwiF7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Validação Hipótese**\n",
        "A correlação entre o tempo de **início da competição (em meses)** e a variável resposta é de **-0,1**. Embora isso indique uma correlação fraca, está bem longe de -1, indicando uma correlação negativa perfeita. Isso leva a duas conclusões significativas.\n",
        "\n",
        "Assim, a hipótese de que uma competição mais duradoura resulta em mais vendas é, na verdade, falsa. **As lojas que enfrentam concorrência há mais tempo apresentam, conforme indicado pelos nossos dados, menores volumes de vendas**."
      ],
      "metadata": {
        "id": "3NBt-sNdy9It"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **4. Lojas com Promoções de Longa Duração Exibem um Volume de Vendas Maior**\n",
        "Temos a intenção de validar a **hipótese de que lojas que mantêm promoções por períodos extensos apresentam um aumento no volume de vendas**. A análise busca o impacto que a duração de uma promoção - uma variável obtida a partir da diferença entre a data da venda e o início do período promocional - exerce sobre as vendas."
      ],
      "metadata": {
        "id": "270Xj0CQ0FQl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define o estilo dos gráficos para um fundo branco sem linhas de grade\n",
        "sns.set_style('white')\n",
        "\n",
        "# Define o tamanho da figura para que ocupe toda a largura do notebook\n",
        "plt.figure(figsize=(30, 20))\n",
        "\n",
        "# Prepara os dados para o gráfico\n",
        "aux1 = df4[['promo_time_week', 'sales']].groupby('promo_time_week').sum().reset_index()\n",
        "aux2 = aux1[aux1['promo_time_week'] > 0] # promoção estendida\n",
        "aux3 = aux1[aux1['promo_time_week'] < 0] # promoção regular\n",
        "\n",
        "# Primeiro gráfico de barras mostrando vendas por semana de promoção estendida\n",
        "plt.subplot(2, 1, 1)\n",
        "bp1 = sns.barplot(x = 'promo_time_week', y = 'sales', data = aux2)\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Semanas de Promoção Estendida', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.title('Vendas vs. Semanas de Promoção Estendida', fontsize=14)\n",
        "\n",
        "# Controla os rótulos do eixo x, mantendo apenas a cada 10 semanas\n",
        "labels1 = bp1.get_xticklabels()\n",
        "plt.xticks([i for i in range(0, len(labels1), 10)], [l.get_text() for l in labels1[::10]], rotation=45, ha='right')\n",
        "\n",
        "# Segundo gráfico de barras mostrando vendas por semana de promoção regular\n",
        "plt.subplot(2, 1, 2)\n",
        "bp2 = sns.barplot(x = 'promo_time_week', y = 'sales', data = aux3)\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Semanas de Promoção Regular', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.title('Vendas vs. Semanas de Promoção Regular', fontsize=14)\n",
        "\n",
        "# Controla os rótulos do eixo x, mantendo apenas a cada 10 semanas\n",
        "labels2 = bp2.get_xticklabels()\n",
        "plt.xticks([i for i in range(0, len(labels2), 10)], [l.get_text() for l in labels2[::10]], rotation=45, ha='right')\n",
        "\n",
        "# Ajusta os subplots para evitar sobreposição\n",
        "plt.tight_layout()\n",
        "\n",
        "# Mostra o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "PyaRnGjx8_48"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Estamos aqui para entender **como as vendas são afetadas pelas promoções regulares e estendidas**. Olhamos para as vendas passadas e futuras baseadas no início das promoções, mas muita informação pode dificultar o entendimento.\n",
        "\n",
        "O gráfico superior mostra as **vendas durante promoções estendidas**. Aqui, vemos que as **vendas permanecem estáveis por um tempo e depois começam a cair**. Isso indica que o efeito de uma promoção estendida não dura para sempre.\n",
        "\n",
        "O gráfico inferior mostra as **vendas durante promoções regulares**. Quando a promoção ainda está distante, as vendas são baixas. Porém, **à medida que a promoção se aproxima, as vendas começam a aumentar**. Isso sugere que os **consumidores podem estar antecipando suas compras devido às promoções anunciadas**.\n",
        "\n",
        "**Nossa hipótese inicial era que lojas com promoções ativas por mais tempo deveriam vender mais**.\n",
        "\n",
        "Isso se provou parcialmente verdadeiro. As vendas são afetadas pela duração da promoção, mas não de uma forma linear. As vendas permanecem estáveis e depois caem durante promoções estendidas, e aumentam à medida que a promoção se aproxima nas promoções regulares. Portanto, **o tempo de duração da promoção afeta as vendas, mas de forma mais complexa do que imaginávamos.**"
      ],
      "metadata": {
        "id": "BHBptdMx8V5P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define o estilo dos gráficos para um fundo branco sem linhas de grade\n",
        "sns.set_style('white')\n",
        "\n",
        "# Define o tamanho da figura para que ocupe toda a largura do notebook\n",
        "plt.figure(figsize=(30, 20))\n",
        "\n",
        "# Primeiro gráfico: um gráfico de barras mostrando vendas por semana de promoção estendida\n",
        "plt.subplot(2, 2, 1)\n",
        "aux2 = aux1[aux1['promo_time_week'] > 0] # promoção extendida\n",
        "bp = sns.barplot(x = 'promo_time_week', y = 'sales', data = aux2)\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Semanas de Promoção Estendida', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Vendas vs. Semanas de Promoção Estendida', fontsize=18)\n",
        "\n",
        "# Controla os rótulos do eixo x, mantendo apenas a cada 10 semanas\n",
        "labels = bp.get_xticklabels()\n",
        "plt.xticks([i for i in range(0, len(labels), 10)], [l.get_text() for l in labels[::10]], rotation=90)\n",
        "\n",
        "# Segundo gráfico: uma regressão linear entre semanas de promoção estendida e vendas\n",
        "plt.subplot(2, 2, 2)\n",
        "sns.regplot(x = 'promo_time_week', y = 'sales', data = aux2, scatter_kws={'s': 5})\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Semanas de Promoção Estendida', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Regressão Linear: Vendas vs. Semanas de Promoção Estendida', fontsize=18)\n",
        "\n",
        "# Terceiro gráfico: um gráfico de barras mostrando vendas por semana de promoção regular\n",
        "plt.subplot(2, 2, 3)\n",
        "aux3 = aux1[aux1['promo_time_week'] < 0] # promoção regular\n",
        "bp = sns.barplot(x = 'promo_time_week', y = 'sales', data = aux3)\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Semanas de Promoção Regular', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Vendas vs. Semanas de Promoção Regular', fontsize=18)\n",
        "\n",
        "# Controla os rótulos do eixo x, mantendo apenas a cada 10 semanas\n",
        "labels = bp.get_xticklabels()\n",
        "plt.xticks([i for i in range(0, len(labels), 10)], [l.get_text() for l in labels[::10]], rotation=90)\n",
        "\n",
        "# Quarto gráfico: uma regressão linear entre semanas de promoção regular e vendas\n",
        "plt.subplot(2, 2, 4)\n",
        "sns.regplot(x = 'promo_time_week', y = 'sales', data = aux3, scatter_kws={'s': 5})\n",
        "\n",
        "# Adiciona rótulos aos eixos e título ao gráfico\n",
        "plt.xlabel('Semanas de Promoção Regular', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Regressão Linear: Vendas vs. Semanas de Promoção Regular', fontsize=18)\n",
        "\n",
        "# Ajusta os subplots para evitar sobreposição\n",
        "plt.tight_layout()\n",
        "\n",
        "# Mostra o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "7g9JZsxr_xQT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A análise do gráfico revela um insight importante: existe uma clara tendência decrescente, possivelmente impulsionada por um período de queda significativo. Simultaneamente, observamos uma tendência ascendente com picos bem marcados.\n",
        "\n",
        "Para aprofundar nosso entendimento sobre o relacionamento entre essas tendências, no próximo passo utilizaremos um Heatmap. Esse método de visualização de dados nos permitirá explorar as correlações de maneira clara, dando uma visão quantitativa da força dessas relações."
      ],
      "metadata": {
        "id": "36VvzfrvA2h2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definindo os dados\n",
        "aux1 = df4[['promo_time_week', 'sales']].groupby('promo_time_week').sum().reset_index()\n",
        "\n",
        "# Configurando o estilo e tamanho da figura\n",
        "sns.set_style('white')\n",
        "plt.figure(figsize=(30, 20))\n",
        "\n",
        "# Definindo a grid para os subplots\n",
        "gs = gridspec.GridSpec(2, 3)\n",
        "\n",
        "# Configurando o espaço entre os plots\n",
        "plt.subplots_adjust(hspace=0.4, wspace=0.4)\n",
        "\n",
        "# Primeiro gráfico: vendas durante promoções estendidas\n",
        "plt.subplot(gs[0, 0])\n",
        "aux2 = aux1[aux1['promo_time_week'] > 0] # promoção extendida\n",
        "bp = sns.barplot(x = 'promo_time_week', y = 'sales', data = aux2)\n",
        "bp.set_xticklabels(bp.get_xticklabels(), rotation=45, horizontalalignment='right', fontsize=10)\n",
        "plt.xlabel('Tempo da Promoção Estendida (semanas)', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Vendas durante Promoções Estendidas', fontsize=18)\n",
        "\n",
        "# Segundo gráfico: regressão linear para promoções estendidas\n",
        "plt.subplot(gs[0, 1])\n",
        "sns.regplot(x = 'promo_time_week', y = 'sales', data = aux2, scatter_kws={'s': 5})\n",
        "plt.xlabel('Tempo da Promoção Estendida (semanas)', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Regressão Linear: Promoções Estendidas', fontsize=18)\n",
        "\n",
        "# Terceiro gráfico: vendas durante promoções regulares\n",
        "plt.subplot(gs[1, 0])\n",
        "aux3 = aux1[aux1['promo_time_week'] < 0] # promoção regular\n",
        "bp = sns.barplot(x = 'promo_time_week', y = 'sales', data = aux3)\n",
        "bp.set_xticklabels(bp.get_xticklabels(), rotation=45, horizontalalignment='right', fontsize=10)\n",
        "plt.xlabel('Tempo até a Próxima Promoção Regular (semanas)', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Vendas durante Promoções Regulares', fontsize=18)\n",
        "\n",
        "# Quarto gráfico: regressão linear para promoções regulares\n",
        "plt.subplot(gs[1, 1])\n",
        "sns.regplot(x = 'promo_time_week', y = 'sales', data = aux3, scatter_kws={'s': 5})\n",
        "plt.xlabel('Tempo até a Próxima Promoção Regular (semanas)', fontsize=16)\n",
        "plt.ylabel('Vendas', fontsize=16)\n",
        "plt.title('Regressão Linear: Promoções Regulares', fontsize=18)\n",
        "\n",
        "# Quinto gráfico: mapa de calor das correlações\n",
        "plt.subplot(gs[:, 2])\n",
        "hm = sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='coolwarm', fmt=\".2f\", linewidths=.5)\n",
        "plt.xlabel('Variáveis', fontsize=16)\n",
        "plt.ylabel('Variáveis', fontsize=16)\n",
        "plt.title('Mapa de Calor das Correlações', fontsize=18)\n",
        "\n",
        "# Ajuste para corrigir problemas de recorte do mapa de calor\n",
        "bottom, top = hm.get_ylim()\n",
        "hm.set_ylim(bottom+0.5, top-0.5)\n",
        "\n",
        "# Exibindo o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "uZIiJam4BU7Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Conclusões da Análise**\n",
        "O Heatmap revela uma **correlação de 0,02**, que é extremamente baixa, provavelmente porque o período de estabilidade é muito maior do que o período de declínio. Isso significa que **a força da correlação é fraca**, não havendo um comportamento de subida acentuada. Portanto, no nosso modelo de previsão, essa característica **pode não ter muita relevância e talvez nem seja considerada**.\n",
        "\n",
        "No entanto, é importante notar que **este fator pode ter relevância quando combinado com outros**. Em análises de dados, não olhamos apenas para as variáveis isoladamente, mas também como elas interagem entre si.\n",
        "\n",
        "Quando treinamos modelos de aprendizado de máquina, normalmente não dividimos as variáveis como feito com **aux**. Em vez disso, **o modelo percebe a variável como um todo promo_time_week**. A divisão foi realizada nesse caso **apenas para nos permitir visualizar melhor os dados** e identificar tendências ou padrões específicos.\n",
        "\n",
        "Portanto, a hipótese inicial de que **lojas com promoções ativas por mais tempo vendem mais foi invalidada**. Na verdade, os dados sugerem o contrário: **depois de um certo período de promoção, as vendas tendem a diminuir**. Portanto, esta hipótese é considerada falsa."
      ],
      "metadata": {
        "id": "oHuGAb4nA-g9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **6. Promoções consecutivas geram mais vendas**\n",
        "Definimos **promoção consecutiva** como a ocorrência de um período no qual a loja realiza **promoções contínuas**.\n",
        "\n",
        "Para esta análise, utilizamos duas variáveis: **promo**, que indica se a loja está em um **período tradicional de promoções**, e **promo2**, que sinaliza se a loja **participa de uma promoção estendida**. Nosso objetivo é comparar as vendas das lojas que realizam promoções consecutivas com as que não o fazem.\n",
        "\n",
        "Primeiro, **agrupamos nossos dados por promo e promo2**, permitindo-nos analisar a média das vendas para cada combinação de estados de promoção. Em seguida, ordenamos essas médias do menor para o maior valor de vendas."
      ],
      "metadata": {
        "id": "IsqAornbeLeM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Agrupe os dados e redefina o índice\n",
        "df_grouped = df4[['promo', 'promo2', 'sales']].groupby(['promo', 'promo2']).sum().reset_index()\n",
        "\n",
        "# Remodele os dados para a forma adequada\n",
        "df_pivot = df_grouped.pivot(\"promo\", \"promo2\", \"sales\")\n",
        "print(df_pivot)\n"
      ],
      "metadata": {
        "id": "0S1u2tzGRry8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "As lojas que participaram apenas da promoção estendida (promo2) registraram o menor volume de vendas. Surpreendentemente, as lojas que participaram de ambas as promoções - tradicional e estendida - não obtiveram um desempenho significativamente melhor. No entanto, as que se saíram melhor foram as lojas que participaram somente da promoção tradicional \"promo\".\n",
        "\n",
        "Esses resultados sugerem que a participação na promoção estendida não apresenta uma vantagem substancial em termos de vendas.\n",
        "\n",
        "Esse padrão se manteve constante ao longo do tempo? Em outras palavras, houve alguma mudança de comportamento nas vendas das lojas que apenas participaram da promoção tradicional quando começaram a participar da promoção estendida? Para explorar isso, vamos criar um gráfico para visualizar esses dados ao longo do tempo."
      ],
      "metadata": {
        "id": "Ld8_GbnJfZCq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[(df4['promo'] == 1) & (df4['promo2'] == 1)][['year_week', 'sales']].groupby('year_week').sum().reset_index()\n",
        "aux1.plot()"
      ],
      "metadata": {
        "id": "OHH3mSXogHKE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Os dados mostram que as lojas que participaram exclusivamente da **promoção estendida (promo2)** tiveram as menores vendas.\n",
        "\n",
        "Curiosamente, o desempenho das lojas que se envolveram em ambas as promoções - tradicional e estendida - não foi significativamente superior. No entanto, as vendas que performaram melhor foram em  lojas que apenas participaram da **promoção tradicional \"promo\"**, registrando os volumes de vendas mais altos.\n",
        "\n",
        "Esses achados indicam que **a adesão à promoção estendida pode não trazer uma vantagem expressiva em termos de vendas**. Ou seja, estender a promoção não necessariamente resulta em um aumento correspondente no volume de vendas.\n",
        "\n",
        "A questão que permanece é: esse padrão se manteve estável ao longo do tempo? Existe uma mudança no comportamento de vendas para lojas que inicialmente apenas realizaram a promoção tradicional e posteriormente aderiram à promoção estendida? Para decifrar isso, **precisamos explorar os dados em uma perspectiva temporal**, o que faremos na próxima etapa, criando um gráfico para visualizar essas tendências ao longo do tempo.\n"
      ],
      "metadata": {
        "id": "1fDRkUHlgmJP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configurações do gráfico\n",
        "plt.figure(figsize=(15, 8))\n",
        "\n",
        "# Criando o primeiro gráfico de linha\n",
        "ax = sns.lineplot(x='year_week', y='sales', data=aux1, label='Tradicional & Extendida', linewidth=2.5)\n",
        "\n",
        "# Adicionando o segundo gráfico de linha\n",
        "sns.lineplot(x='year_week', y='sales', data=aux2, label='Tradicional', linewidth=2.5, ax=ax)\n",
        "\n",
        "# Configurações adicionais\n",
        "plt.title('Vendas ao Longo do Tempo: Promoções Tradicional e Extendida', fontsize=20)\n",
        "plt.xlabel('Semana do Ano', fontsize=15)\n",
        "plt.ylabel('Vendas', fontsize=15)\n",
        "plt.legend(fontsize=12)\n",
        "\n",
        "# Ajustando a visibilidade e orientação dos rótulos do eixo x\n",
        "ax.set_xticks(ax.get_xticks()[::5])  # Mostra um rótulo a cada 5 ticks\n",
        "plt.xticks(rotation=45, fontsize=12)  # Rotaciona os rótulos e ajusta o tamanho da fonte\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Removendo o grid\n",
        "ax.grid(False)\n",
        "\n",
        " # Fazendo o gráfico preencher a área completa\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "FoAxZxjgSkXc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A análise do gráfico, que compara as vendas de lojas com promoção estendida às lojas que participaram tanto de promoções tradicionais quanto estendidas, nos traz conclusões relevantes. **As linhas de comportamento das vendas são similares, mas com volumes distintos**. Nota-se um declínio pontual para as lojas que realizaram as duas promoções, mas mesmo assim, o volume de vendas ainda supera o das lojas com apenas a promoção estendida.\n",
        "\n",
        "Desta maneira, nossa hipótese inicial, que indicava que lojas com promoções consecutivas teriam maior volume de vendas, não se verifica. O declínio observado é circunstancial e não altera o panorama geral: **lojas com apenas a promoção estendida têm um volume de vendas inferior**. Portanto, **essa variável pode não ter grande impacto em nosso modelo de previsão**.\n"
      ],
      "metadata": {
        "id": "s2V_KOXpiRY3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **7. Lojas abertas durante o feriado de Natal geram mais vendas**"
      ],
      "metadata": {
        "id": "X67SBC974a14"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12, 8))  # Configurando o tamanho da figura\n",
        "sns.set_style(\"white\")  # Define o estilo do fundo para branco, removendo o grid\n",
        "\n",
        "# Criar o gráfico de barras\n",
        "sns.barplot(x = 'state_holiday', y = 'sales', data = aux1)\n",
        "\n",
        "plt.xlabel('Feriados')  # Define o título do eixo x\n",
        "plt.ylabel('Vendas')  # Define o título do eixo y\n",
        "plt.title('Vendas Durante os Feriados')  # Define o título principal\n",
        "\n",
        "# Função para remover as bordas do gráfico\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "plt.tight_layout()  # Ajusta automaticamente os parâmetros da subplot para preencher a figura\n",
        "plt.show()  # Mostra o gráfico\n",
        "\n"
      ],
      "metadata": {
        "id": "lU_6Nk8bUkE2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Na busca de verificar a hipótese de que as vendas aumentam significativamente durante o período natalino, concentramos nossa análise nas variáveis **state_holiday** e **sales**. Elas nos permitem identificar a ocorrência de feriados e a respectiva performance de vendas.\n",
        "\n",
        "No entanto, nossa análise inicial revelou que **o volume de vendas em dias normais excede grandemente os dias de feriado**. A explicação é simples: **o número de dias normais no ano é substancialmente maior do que o de feriados**.\n",
        "\n",
        "Para refinar nossa análise, geramos um novo conjunto de dados, **aux1**, que **exclui os dias normais**, focando exclusivamente nos dias de feriado. Ao recalcular e visualizar os dados, obteremos uma compreensão mais precisa do impacto dos feriados nas vendas."
      ],
      "metadata": {
        "id": "s5dlMyXS8nuz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definir o estilo do gráfico\n",
        "sns.set_style(\"white\")\n",
        "\n",
        "# Filtrar os dados para excluir os dias regulares\n",
        "aux = df4[df4['state_holiday'] != 'regular_day']\n",
        "\n",
        "# Agrupar os dados pelos feriados e calcular a soma das vendas\n",
        "aux1 = aux[['state_holiday', 'sales']].groupby('state_holiday').sum().reset_index()\n",
        "\n",
        "# Criar o plot\n",
        "plt.figure(figsize=(12,8))\n",
        "sns.barplot(x = 'state_holiday', y = 'sales', data = aux1)\n",
        "\n",
        "# Definir os títulos e labels\n",
        "plt.title('Vendas Durante Feriados', fontsize=20)\n",
        "plt.xlabel('Tipo de Feriado', fontsize=15)\n",
        "plt.ylabel('Vendas', fontsize=15)\n",
        "\n",
        "# Remover as bordas do gráfico\n",
        "sns.despine()\n",
        "\n",
        "# Mostrar o plot\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "GijrwU4F9HI9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Na visualização, fica evidente que **as vendas durante o Natal não superam as dos demais feriados**. Observamos padrões distintos de vendas para o feriado de Natal, Páscoa e feriados públicos. Portanto, a princípio, podemos concluir que a hipótese original é falsa: **as lojas não vendem mais durante o Natal**.\n",
        "\n",
        "Agora, surge a questão de investigar se já houve um momento em que as vendas durante o Natal ultrapassaram as de outros feriados. Esse processo envolve a **análise de mudanças nas vendas ao longo do tempo**, conhecida como \"shift\" em ciência de dados. Para isso, precisamos realizar uma análise mais detalhada para entender melhor os padrões de vendas durante os feriados."
      ],
      "metadata": {
        "id": "39te0wbS9rhs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux = df4[df4['state_holiday'] != 'regular_day']\n",
        "\n",
        "plt.subplot(1, 2, 1)\n",
        "aux1 = aux[['state_holiday', 'sales']].groupby('state_holiday').sum().reset_index()\n",
        "sns.barplot(x = 'state_holiday', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "aux2 = aux[['year', 'state_holiday', 'sales']].groupby(['year', 'state_holiday']).sum().reset_index()\n",
        "sns.barplot(x = 'year', y = 'sales', hue = 'state_holiday', data = aux2)"
      ],
      "metadata": {
        "id": "d1Zm0Hj3-UGH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Focamos em três feriados principais: Natal (\"Christmas\"), Páscoa (\"Easter\") e feriados públicos (\"Public Holiday\").\n",
        "\n",
        "Em todos os anos analisados (2013-2015), as vendas durante o Natal foram consistentemente mais baixas em comparação aos outros feriados. Esta observação contradiz nossa hipótese inicial de que as vendas seriam mais altas durante o Natal.\n",
        "\n",
        "Deve-se notar que os dados para 2015 ainda estão incompletos (até agosto), portanto, não há informações sobre as vendas de Natal para esse ano.\n",
        "\n",
        "### • Validação Hipótese\n",
        "\n",
        "Portanto, a partir desta análise, podemos concluir que nossa hipótese inicial era falsa: as lojas não vendem mais durante o feriado de Natal. Este resultado é importante para informar nossas estratégias futuras e ajustar nossas expectativas para as vendas de feriados.\n"
      ],
      "metadata": {
        "id": "Ki6H8For_W9P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "gEaONsIz_kmp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 8. Lojas registram mais vendas ao londo dos anos\n",
        "Estamos interessados em analisar como as vendas se comportaram ao longo dos anos. Para fazer isso, selecionamos as colunas 'Year' e 'Sales' do nosso dataframe. Em seguida, agrupamos as vendas por ano e somamos todos os valores de venda para cada ano. Essas etapas nos fornecem a soma total das vendas para cada ano."
      ],
      "metadata": {
        "id": "TzoZF_R6_m5z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[['year', 'sales']].groupby('year').sum().reset_index()\n",
        "sns.barplot(x = 'year', y = 'sales', data = aux1)"
      ],
      "metadata": {
        "id": "ZVPqjpjF_v-w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para identificar a tendência, substituímos o gráfico de barras por um gráfico de regressão. Este gráfico nos ajuda a visualizar se há uma tendência geral de aumento ou diminuição nas vendas ao longo do tempo.\n",
        "\n",
        "Em seguida, usamos o método 'heatmap' para calcular e visualizar a correlação. Para este cálculo, usamos o método de Pearson, que é um método padrão para calcular a correlação linear entre variáveis."
      ],
      "metadata": {
        "id": "g6KwIEBKAunz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[['year', 'sales']].groupby('year').sum().reset_index()\n",
        "\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x = 'year', y = 'sales', data = aux1);\n",
        "\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x = 'year', y = 'sales', data = aux1);\n",
        "\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr(method = 'pearson'), annot = True);"
      ],
      "metadata": {
        "id": "IJfZuLfPAvF3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        " Observamos uma tendência decrescente nas vendas ao longo do tempo, como mostrado pelo gráfico de regressão. Este decréscimo está fortemente correlacionado com o passar dos anos, com um coeficiente de correlação de -0.92, o que é bastante significativo. Isso indica que à medida que os anos avançam, as vendas tendem a diminuir.\n",
        "\n",
        "Vale ressaltar que a análise do ano de 2015 pode estar distorcida, já que os dados estão incompletos para esse ano, chegando apenas até meados do ano. Na prática, ao fazer uma análise como esta, é importante usar períodos fechados (anos completos, meses completos, etc.) para evitar distorções.\n",
        "\n",
        "Embora a correlação seja forte, é possível que a variável 'year' não seja surpreendente para muitos, pois é comum as empresas acompanharem as métricas de crescimento ao longo do tempo. Assim, mesmo que essa seja uma descoberta importante, não necessariamente representa um insight novo ou inesperado.\n",
        "\n",
        "### • Validação Hipótese (FALSA)\n",
        "Com base nesses resultados, podemos concluir que a hipótese de que \"lojas deveriam vender mais ao longo dos anos\" é falsa, já que observamos que as vendas tendem a diminuir ao longo do tempo."
      ],
      "metadata": {
        "id": "bIKR-g8pCzRS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "AxpEUBZkCpm9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 9. Lojas Registram Mais Vendas no 2° Semestre do Ano\n",
        "Nossa análise dos dados mensais revelou que as vendas são relativamente altas do mês 1 (janeiro) ao mês 6 (junho), com uma queda significativa observada a partir do mês 7 (julho).\n"
      ],
      "metadata": {
        "id": "dL0RE0GvCYvV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[['month', 'sales']].groupby('month').sum().reset_index()\n",
        "\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x = 'month', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x = 'month', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr(method = 'pearson'), annot = True)"
      ],
      "metadata": {
        "id": "LfBhHnMNDnCj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "A tendência de queda é confirmada pelo gráfico de tendências e a força dessa relação é confirmada pela análise de correlação, que revela uma correlação negativa muito forte de -0.75. Portanto, no segundo semestre de cada ano, as vendas diminuem.\n",
        "\n",
        "Isso indica que o 'mês' é uma variável importante para nosso modelo. O modelo irá reconhecer que se as vendas estão ocorrendo no segundo semestre de um determinado ano, a previsão é de que as vendas serão menores.\n",
        "\n",
        "### • Validação Hipótese\n",
        "Com base nesses resultados, podemos refutar a hipótese de que \"lojas deveriam vender mais no segundo semestre do ano\". A análise mostra o contrário - as lojas vendem menos no segundo semestre do ano. Vamos então passar para a próxima hipótese."
      ],
      "metadata": {
        "id": "pUTahKyaE77_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "6R79P3XoFFnc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 10. Lojas registram mais vendas depois do dia 10 de cada mês.\n",
        "Buscamos avaliar se \"Lojas deveriam vender mais depois do dia 10 de cada mês\". Para isso, vamos usar a mesma abordagem analítica usada anteriormente para os anos e meses.\n",
        "\n",
        "Substituimos a variável 'year' pela variável 'day' no nosso código para gerar um novo conjunto de três gráficos. Vamos analisar os resultados obtidos para verificar se as vendas realmente aumentam após o dia 10 de cada mês."
      ],
      "metadata": {
        "id": "6pPo400gFPY2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[['day', 'sales']].groupby('day').sum().reset_index()\n",
        "\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x = 'day', y  = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x = 'day', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr('pearson'), annot = True)"
      ],
      "metadata": {
        "id": "ipgyOdjHFngA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para nos aprofundarmos na hipótese, precisamos segmentar nossos dados em dois grupos: os dias antes e depois do dia 10 de cada mês. Usamos a função 'apply' no conjunto de dados, com uma função lambda para criar uma nova coluna chamada 'before_after' classificando aos dias em 'before_10_days' e 'after_10_days.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "9Eei80fhIk40"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1['before_after'] = aux1['day'].apply(lambda x: 'before_10_days' if x <= 10 else 'after_10_days')"
      ],
      "metadata": {
        "id": "oRE_vBpuIFqo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dessa forma, estamos segmentando nossos dados de acordo com a hipótese que queremos testar. A seguir, vamos avaliar o comportamento das vendas para esses dois grupos de dias.\n"
      ],
      "metadata": {
        "id": "5hWc1HqpI5-b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux2 = aux1[['before_after', 'sales']].groupby('before_after').sum().reset_index()\n",
        "\n",
        "plt.subplot(2, 2, 1)\n",
        "sns.barplot(x = 'day', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(2, 2, 2)\n",
        "sns.regplot(x = 'day', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(2, 2, 3)\n",
        "sns.heatmap(aux1.corr(method = 'pearson'), annot = True)\n",
        "\n",
        "plt.subplot(2, 2, 4)\n",
        "sns.barplot(x = 'before_after', y = 'sales', data = aux2)"
      ],
      "metadata": {
        "id": "hnZSmOL_I_ge"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Isso pode ser uma informação valiosa, pois contraria a crença comum de que as pessoas gastam mais nos primeiros dias após receberem seus salários. Essa informação pode ser utilizada para implementar estratégias de marketing mais eficazes, por exemplo, ao programar promoções e campanhas publicitárias para o período do mês em que se espera um maior volume de vendas.\n",
        "\n",
        "### • Validação Hipótese\n",
        "a hipótese de que as lojas venderiam mais depois do dia 10 de cada mês é verdadeira. Apesar de haver um maior número de dias no segmento \"After10\", a análise dos dados sugere que há de fato um aumento nas vendas nesse período.\n"
      ],
      "metadata": {
        "id": "poRH4_OdL1H2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "3PmYHEx5L9qs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 11. Lojas registram menos vendas aos finais de semana (VERDADEIRA)\n",
        "Estamos explorando a hipótese de que as lojas têm menor volume de vendas nos finais de semana. Para tanto, analisamos a distribuição das vendas por dia da semana.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "wkX_cQOwMEbf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[['day_of_week', 'sales']].groupby('day_of_week').sum().reset_index()\n",
        "\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x = 'day_of_week', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x = 'day_of_week', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr(method = 'pearson'), annot = True)"
      ],
      "metadata": {
        "id": "RF_oFEd5MkV7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### • Validação Hipótese\n",
        "\n",
        "Os resultados da análise mostraram que a hipótese é verdadeira. Os volumes de venda são significativamente menores no final de semana, especialmente aos domingos. Observamos também uma correlação negativa, indicando que à medida que avançamos na semana, as vendas tendem a diminuir.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "VoAo5TZ8ODYp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "1MAANKBLPoAh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 12. Lojas registram menos vendas durante os feriados escolares (VERDADEIRA)\n",
        "A próxima hipótese que investigamos está relacionada às férias escolares e o impacto que elas podem ter sobre o volume de vendas. Para isso, utilizamos a coluna 'school_holiday' de nosso conjunto de dados."
      ],
      "metadata": {
        "id": "cnvkkNfsPqAE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[['school_holiday', 'sales']].groupby('school_holiday').sum().reset_index()\n",
        "\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x = 'school_holiday', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x = 'school_holiday', y = 'sales', data = aux1)\n",
        "\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr(method = 'pearson'), annot = True)"
      ],
      "metadata": {
        "id": "Byk34v-mPv7K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notamos que o volume de vendas é consideravelmente maior nos dias que não são férias escolares 'school_holiday' = 0, comparativamente aos dias de férias escolares 'school_holiday' = 1. Isso pode parecer óbvio, uma vez que há mais dias disponíveis para vendas que não são férias escolares.\n",
        "\n",
        "Para isso, acrescentamos o mês 'month' como uma segunda variável. Essa análise permitirá ver se existem meses específicos onde as vendas durante as férias escolares se equiparam ou superam as vendas em dias regulares de aula."
      ],
      "metadata": {
        "id": "5aA3bAz4TAtF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aux1 = df4[['school_holiday', 'sales']].groupby('school_holiday').sum().reset_index()\n",
        "\n",
        "plt.subplot(2, 1, 1)\n",
        "sns.barplot(x = 'school_holiday', y = 'sales', data = aux1)\n",
        "\n",
        "aux2 = df4[['month', 'school_holiday', 'sales']].groupby(['month', 'school_holiday']).sum().reset_index()\n",
        "\n",
        "plt.subplot(2, 1, 2)\n",
        "sns.barplot(x = 'month', y = 'sales', hue = 'school_holiday', data = aux2)"
      ],
      "metadata": {
        "id": "Q2VDFMULR2In"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### • Validação Hipótese\n",
        "Observamos uma interessante mudança de comportamento das vendas ao longo do ano em relação aos feriados escolares. Inicialmente, nos primeiros meses do ano as vendas em dias não-escolares eram substancialmente mais altas do que nos dias de férias escolares. Esta tendência permaneceu constante até chegarmos ao mês de julho.\n",
        "\n",
        "Em julho, uma mudança significativa ocorre: as vendas durante os feriados escolares quase se equiparam às vendas em dias regulares de aula. Esta alteração pode ser atribuída ao fato de que julho é um mês de férias escolares, o que faz com que praticamente todas as vendas ocorram durante este período.\n",
        "\n",
        "No entanto, o ponto mais interessante foi observado em agosto. Neste mês, as vendas durante os feriados superaram significativamente as vendas em dias regulares de aula. Após agosto, o padrão de vendas retornou ao normal, com vendas em dias regulares novamente superando os feriados."
      ],
      "metadata": {
        "id": "b98uP2C1UQYF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "bmpnk7B1V9bR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Resumo Hipóteses Analisadas\n",
        "Lojas com maior sortimento deveriam vender mais: Esta hipótese é falsa. Lojas com maior sortimento tendem a vender menos. Isso contraria a intuição comum e, portanto, pode gerar insights relevantes.\n",
        "\n",
        "Lojas com competidores mais próximos deveriam vender menos: Novamente, a hipótese é contraintuitiva e falsa. Nossos dados indicam que lojas com competidores mais próximos tendem a vender mais.\n",
        "\n",
        "Lojas com competidores a mais tempo deveriam vender mais: Essa hipótese também é falsa. De acordo com a análise, lojas com competidores a mais tempo tendem a vender menos.\n",
        "\n",
        "Lojas com promoções ativas por mais tempo deveriam vender mais: Esta hipótese é falsa. Em vez disso, lojas com promoções ativas por mais tempo tendem a vender menos.\n",
        "\n",
        "Lojas com mais promoções consecutivas deveriam vender mais: Contrariando a suposição inicial, lojas com mais promoções consecutivas vendem menos.\n",
        "\n",
        "Lojas abertas durante o feriado de Natal deveriam vender mais: Esta hipótese é falsa. Lojas abertas durante o Natal tendem a vender menos.\n",
        "\n",
        "Lojas deveriam vender mais ao longo dos anos: Esta hipótese é falsa. As vendas tendem a diminuir ao longo dos anos.\n",
        "\n",
        "Lojas deveriam vender mais no segundo semestre do ano: Esta hipótese também é falsa. As lojas tendem a vender menos no segundo semestre do ano.\n",
        "\n",
        "Depois do dia 10 de cada mês, as lojas deveriam vender mais: Esta é uma hipótese verdadeira. De fato, as lojas vendem mais após o décimo dia de cada mês.\n",
        "\n",
        "Lojas deveriam vender menos aos finais de semana: Esta hipótese é verdadeira. As lojas geralmente vendem menos nos finais de semana.\n",
        "\n",
        "Lojas deveriam vender menos durante os feriados escolares: Esta hipótese é verdadeira. As lojas geralmente vendem menos durante os feriados escolares, exceto nos meses de julho e agosto.\n",
        "\n",
        "O estudo dessas hipóteses revelou várias tendências não intuitivas que podem ser úteis na formulação de estratégias de negócios e tomada de decisões. No entanto, é essencial validar esses insights com um entendimento do contexto do negócio e dados adicionais. É vital manter uma mentalidade aberta e explorar todas as possíveis anomalias e surpresas que os dados podem revelar."
      ],
      "metadata": {
        "id": "iDQTjyOaV6nz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tabulate import tabulate\n",
        "\n",
        "tab = [\n",
        "['Hipóteses', 'Conclusão', 'Relevância'],\n",
        "['H1', 'Falsa', 'Baixa'],\n",
        "['H2', 'Falsa', 'Média'],\n",
        "['H3', 'Falsa', 'Média'],\n",
        "['H4', 'Falsa', 'Baixa'],\n",
        "['H5', '-', '-'],\n",
        "['H6', 'Falsa', 'Baixa'],\n",
        "['H7', 'Falsa', 'Média'],\n",
        "['H8', 'Falsa', 'Alta'],\n",
        "['H9', 'Falsa', 'Alta'],\n",
        "['H10', 'Verdadeira', 'Alta'],\n",
        "['H11', 'Verdadeira', 'Alta'],\n",
        "['H12', 'Verdadeira', 'Baixa'],\n",
        "]\n",
        "print(tabulate(tab, headers='firstrow'))"
      ],
      "metadata": {
        "id": "i0y07tQZbDu8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.3 Análise Multivariada\n",
        "Análise Exploratória de Dados (EDA) é um processo que envolve a análise de várias variáveis simultaneamente. Antes de explicar a importância da análise multivariada, vamos recapitular os estágios anteriores: a análise univariada, que examina individualmente cada variável, e a análise bivariada, que busca entender o impacto de uma variável em relação à variável resposta.\n",
        "\n",
        "Agora, na análise multivariada, nosso objetivo é não apenas identificar correlações ou impactos entre a variável resposta e as demais variáveis, mas também examinar as relações entre as próprias variáveis. Essa etapa é essencial para a tomada de decisões e ajustes nos modelos de Machine Learning.\n",
        "\n",
        "Uma motivação importante para a análise multivariada é a \"Navalha de Occam\" ou \"Princípio da Parsimônia\", que sustenta que, ao escolher entre vários modelos, devemos optar pelo de menor complexidade, pois ele tende a generalizar melhor o aprendizado. A dimensionalidade é um fator que influencia na complexidade dos modelos, e ela está relacionada ao número de colunas (variáveis) nos dados.\n",
        "\n",
        "A redução da dimensionalidade pode ser alcançada ao eliminar variáveis que carregam informações redundantes ou similares. Por exemplo, se duas colunas contêm a mesma informação, podemos remover uma delas sem perda de dados.\n",
        "\n",
        "Nesse contexto, a análise multivariada nos ajuda a identificar quais variáveis estão correlacionadas entre si, permitindo a remoção das redundâncias e a diminuição da complexidade do modelo. Embora existam técnicas avançadas para isso, a análise visual e manual ainda é relevante para compreender a relação entre as variáveis.\n",
        "\n",
        "Em suma, a análise multivariada é uma etapa crucial na exploração de dados, pois nos auxilia a identificar quais variáveis estão correlacionadas e, consequentemente, quais podem ser removidas para reduzir a dimensionalidade e melhorar o desempenho dos modelos de Machine Learning. É uma prática essencial para obter insights valiosos e tomar decisões embasadas em dados."
      ],
      "metadata": {
        "id": "OKO7CgzgXim5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4.3.1. Numerical Attributes\n"
      ],
      "metadata": {
        "id": "BW2i-QekiKGk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list(num_attributes)"
      ],
      "metadata": {
        "id": "LB0iFEihiIBM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculando a matriz de correlação\n",
        "correlation_num = num_attributes.corr(method='pearson')\n",
        "\n",
        "# Configurações para melhorar a visualização\n",
        "plt.figure(figsize=(12, 10))\n",
        "sns.heatmap(correlation_num, annot=True, cmap='coolwarm', fmt=\".2f\", linewidths=0.5, square=True, cbar_kws={\"shrink\": 0.75}, annot_kws={\"size\": 8})\n",
        "plt.title('Matriz de Correlação Atributos Numéricos', fontsize=16)\n",
        "plt.xticks(rotation=45, fontsize=8)\n",
        "plt.yticks(rotation=0, fontsize=8)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "VeyNrBtgilk8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A matriz de correlação apresenta uma escala de cores, na qual a cor azul escuro indica correlação negativa mais forte e vermelho indica correlação positiva mais forte. Os tons intermediários não são tão relevantes. A matriz é simétrica, ou seja, a parte de baixo é o espelho da parte de cima, já que estamos comparando as mesmas variáveis.\n",
        "\n",
        "Por exemplo, a correlação entre as variáveis \"store\" e \"is_promo\" é de 0.0046, e essa mesma correlação é encontrada na parte oposta da matriz para as variáveis \"expomo\" e \"loja\". A diagonal principal é composta por quadrados brancos, representando a correlação das variáveis consigo mesmas, que é sempre 1.\n"
      ],
      "metadata": {
        "id": "kE_g-0n5oGIA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4.3.2. Categorical Attributes\n"
      ],
      "metadata": {
        "id": "Jn7C70eliWfA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = df4.select_dtypes(include = 'object')\n",
        "a.head()"
      ],
      "metadata": {
        "id": "WxCPh-QRqF_5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from scipy import stats\n",
        "\n",
        "def cramer_v(x, y):\n",
        "    cm = pd.crosstab(x, y).values\n",
        "    n = cm.sum()\n",
        "    r, k = cm.shape\n",
        "    chi2 = stats.chi2_contingency(cm)[0]\n",
        "    return np.sqrt((chi2/n) / (min(k-1, r-1)))"
      ],
      "metadata": {
        "id": "yjIZNlS8tZ-e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O V de Kramer, ou Coeficiente de V de Cramer, é uma medida de correlação categórica que quantifica a relação entre duas variáveis categóricas em uma tabela de contingência. Ele é uma extensão normalizada do coeficiente qui-quadrado (χ²), levando em conta o tamanho da amostra e o número de categorias das variáveis. Seu valor varia de 0 a 1, onde:\n",
        "\n",
        "- 0 indica nenhuma associação entre as variáveis categóricas\n",
        "- 1 indica uma forte associação entre as variáveis."
      ],
      "metadata": {
        "id": "O7BgqfKJv8MY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "resultado_cramer_v = cramer_v(cat_attributes['state_holiday'], cat_attributes['store_type'])\n",
        "print(resultado_cramer_v)"
      ],
      "metadata": {
        "id": "puzHs8imtd6f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "vamos corrigir o método de cálculo do V de Kramer para mitigar o viés ou erro de estimativa. Conforme mencionado na Wikipédia, para a correção do viés, devemos utilizar a fórmula do coeficiente C, que é uma forma corrigida do V de Kramer."
      ],
      "metadata": {
        "id": "g8b4Ki1TyKFX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# only categorical data\n",
        "a = df4.select_dtypes( include='object' )\n",
        "# Calculate cramer V\n",
        "a1 = cramer_v( a['state_holiday'], a['state_holiday'] )\n",
        "a2 = cramer_v( a['state_holiday'], a['store_type'] )\n",
        "a3 = cramer_v( a['state_holiday'], a['assortment'] )\n",
        "a4 = cramer_v( a['store_type'], a['state_holiday'] )\n",
        "a5 = cramer_v( a['store_type'], a['store_type'] )\n",
        "a6 = cramer_v( a['store_type'], a['assortment'] )\n",
        "a7 = cramer_v( a['assortment'], a['state_holiday'] )\n",
        "a8 = cramer_v( a['assortment'], a['store_type'] )\n",
        "a9 = cramer_v( a['assortment'], a['assortment'] )\n",
        "# Final dataset\n",
        "d = pd.DataFrame( {'state_holiday': [a1, a2, a3],\n",
        "'store_type': [a4, a5, a6],\n",
        "'assortment': [a7, a8, a9] })\n",
        "d = d.set_index( d.columns )\n",
        "sns.heatmap( d, annot=True )"
      ],
      "metadata": {
        "id": "CeEq7h0S00iF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "qcn9JQ5CVIu-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5. Preparação dos Dados\n",
        "Nesta etapa do projeto de ciência de dados, estamos nos concentrando na modelagem dos dados para treinamento dos algoritmos de aprendizado de máquina. No entanto, antes de mergulharmos nesse tópico, é crucial atualizarmos o progresso do nosso projeto, que será compartilhado com os stakeholders.\n",
        "\n",
        "Até agora, no projeto de previsão de vendas Rossman, a demanda inicial veio dos gerentes das lojas, que buscavam uma previsão de vendas para as próximas seis semanas. Esse pedido foi tratado de forma estratégica, conduzindo-nos à próxima etapa: entender o negócio.\n",
        "\n",
        "Identificamos que a motivação para essa previsão era a necessidade de planejar uma reforma nas lojas. Para isso, é necessário saber a receita esperada para cada loja, permitindo um cálculo preciso do investimento necessário. Portanto, a previsão de vendas para as próximas seis semanas se tornou relevante.\n",
        "\n",
        "O próximo passo no processo foi a coleta de dados. Neste caso, os dados foram obtidos de uma plataforma online. No cenário real, seria o momento de extrair todos os dados necessários do banco de dados da empresa.\n",
        "\n",
        "Após a coleta dos dados, foi realizada a limpeza dos mesmos. Durante este processo, também lidamos com dados ausentes e fizemos substituições, além de ter aplicado restrições do negócio e filtrado os dados para ficarmos apenas com aqueles relevantes para nossa análise.\n",
        "\n",
        "Finalmente, conduzimos a análise exploratória de dados, que foi, até agora, a etapa mais extensa do projeto. Aqui, elaboramos diversas hipóteses e aprendemos como preparar os dados para o treinamento dos algoritmos.\n",
        "\n",
        "Ainda restam algumas etapas para concluirmos o primeiro ciclo do projeto e apresentarmos a primeira versão da nossa solução. Entretanto, já estamos proporcionando valor para o negócio através do progresso que fizemos até aqui. Agora, prosseguiremos para a próxima fase do projeto: **a modelagem de dados**."
      ],
      "metadata": {
        "id": "O20OA1fX0i9d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df5 = df4.copy()"
      ],
      "metadata": {
        "id": "yy45CeZSVKgq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Motivação da Preparação dos Dados"
      ],
      "metadata": {
        "id": "uh3l5fFNNsyl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "m = pd.concat([d2, d3, d4, ct1, ct2, d1, d5, d6]).T.reset_index()\n",
        "m.columns = ['attributes', 'min', 'max', 'range', 'mean', 'median', 'std', 'skew', 'kurtosis']\n",
        "m"
      ],
      "metadata": {
        "id": "ruPuASZhPC25"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A preparação dos dados é uma etapa fundamental no processo de aprendizado de máquina. Se eu tivesse que resumir o motivo para a preparação dos dados em uma frase, diria que a maioria dos **algoritmos de aprendizado de máquina são facilitados por dados numéricos e na mesma escala**. Portanto, a preparação de dados envolve duas tarefas principais: a **conversão de dados categóricos em numéricos** e a **normalização das escalas** de dados.\n",
        "\n",
        "Os algoritmos de aprendizado de máquina, em sua maioria, foram desenvolvidos considerando dados numéricos. Isso ocorre porque esses **algoritmos trabalham com métodos de otimização que frequentemente se baseiam em operações matemáticas**, como somas e multiplicações. Os métodos de otimização buscam **encontrar os melhores parâmetros para o conjunto** de dados e, para isso, **eles usam derivadas**, que são definidas **apenas para variáveis numéricas**. Portanto, variáveis categóricas precisam ser convertidas em numéricas sem perder a informação essencial.\n",
        "\n",
        "Outra questão importante é a normalização das escalas de dados. Por exemplo, se considerarmos duas variáveis, \"day_of_week\" variando de 1 a 7 e \"competition_distance\" variando de 20 metros a 200 mil metros, vemos que as **escalas são drasticamente diferentes**. Isso pode influenciar o aprendizado do modelo, já que métodos de otimização, como o gradiente descendente, tendem a favorecer variáveis com maior amplitude. Assim, **o modelo pode dar uma importância excessiva a variáveis com escalas maiores**. Para evitar esse problema, **precisamos normalizar os dado**s, garantindo que todas as variáveis estejam na mesma escala.\n",
        "\n",
        "Portanto, para preparar os dados para o aprendizado de máquina, precisamos lidar com duas tarefas principais: **codificar variáveis categóricas** (transformá-las em variáveis numéricas) e **normalizar as escalas**."
      ],
      "metadata": {
        "id": "6MyrKlqtPhm7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tipos de Preparação de Dados\n",
        "Existem basicamente três tipos de preparação de dados: Normalização, Escalonamento e Codificação numérica.\n",
        "\n",
        "- **Normalização**: Essa técnica reescala os dados de modo que eles tenham uma **média zero e um desvio padrão igual a um**. Por exemplo, considere uma variável 'competition_distance' com média de 100 metros e desvio padrão de 20 metros. A normalização desloca essa variável para um novo intervalo de valores, onde a média é 0 e o desvio padrão é 1. Isso significa que todos os valores são ajustados para o mesmo intervalo, que vai de -1 a 1. A normalização é particularmente eficaz quando os dados seguem uma distribuição normal.\n",
        "\n",
        "- **Escalonamento**: Essa técnica é semelhante à normalização, mas é mais adequada para dados que não seguem uma distribuição normal. Assim como a normalização, o escalonamento ajusta os valores para um intervalo comum, mas ao contrário da normalização, ele não pressupõe que os dados seguem uma distribuição normal.\n",
        "\n",
        "- **Encoding**: Esta técnica é usada para converter variáveis categóricas em numéricas, como mencionado anteriormente.\n",
        "\n",
        "Além dessas três técnicas, pode ser necessário aplicar outras transformações dependendo da natureza dos dados. Por exemplo, variáveis cíclicas como os meses do ano, que se repetem em um ciclo fixo, podem precisar ser transformadas de uma maneira que reflita essa natureza cíclica."
      ],
      "metadata": {
        "id": "YR5XGreeiUz-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.2 [Normalização](https://www.kaggle.com/code/discdiver/guide-to-scaling-and-standardizing/notebook)\n",
        "Para começar com a normalização, precisamos entender a fórmula básica que a define. A fórmula é:\n",
        "\n",
        "Z = (X - μ) / σ\n",
        "\n",
        "Onde:\n",
        "\n",
        "- Z é a variável normalizada.\n",
        "- X é a variável original.\n",
        "- μ é a média dos valores da variável original.\n",
        "- σ é o desvio padrão dos valores da variável original.\n",
        "\n",
        "O processo de normalização consiste em subtrair a média de cada valor e depois dividir pelo desvio padrão. Essa operação ajusta os valores para uma nova escala onde a média é 0 e o desvio padrão é 1.\n",
        "\n",
        "Apesar de poder ser feita manualmente, existem bibliotecas como o Scikit-Learn que possuem funções prontas para aplicar a normalização diretamente.\n",
        "\n",
        "![non-normalized.png](data:image/png;base64,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)\n",
        "\n",
        "No entanto, é importante observar que a normalização pode afetar a natureza da distribuição dos dados. Por exemplo, se tivermos várias distribuições diferentes, como Beta (vermelha), exponencial (azul) e duas normais (roxa e verde), a aplicação da normalização fará com que todas essas distribuições se movam para uma média de 0 e um desvio padrão de 1.\n",
        "\n"
      ],
      "metadata": {
        "id": "wDlRBuuPRxpI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![normalized.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "hraGBBvoT-Xj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.2 Normalização\n",
        "Para começar a normalização, primeiro **precisamos avaliar quais variáveis devem ser normalizadas**. Isso é feito ao observar a distribuição dessas variáveis, que foram analisadas anteriormente durante a fase de análise exploratória de dados. A organização do notebook ou ambiente de programação é crucial para facilitar esse processo.\n",
        "\n",
        "Portanto, voltamos à \"Análise Univarida\" no notebook, onde as distribuições de todas as variáveis foram analisadas.\n",
        "\n",
        "Especificamente, queremos focar nas variáveis numéricas, então vamos abrir a subseção \"Análise Univarida - Variáveis Numéricas\".\n",
        "\n",
        "Agora, nossa missão é identificar as variáveis que seguem uma distribuição normal. Lembre-se, a normalização é mais eficaz quando aplicada a variáveis que já têm uma distribuição normal. Portanto, o objetivo aqui é identificar quais variáveis têm essa característica:"
      ],
      "metadata": {
        "id": "Dc773lFTWIOs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 'num_attributes' é o seu DataFrame\n",
        "num_attributes.hist(bins=25, figsize=(20, 15), grid=False);  # Aumente o tamanho do gráfico\n",
        "\n",
        "plt.xticks(fontsize=10);  # Reduza o tamanho das fontes dos ticks do eixo x\n",
        "plt.yticks(fontsize=10);  # Reduza o tamanho das fontes dos ticks do eixo y\n",
        "\n",
        "plt.tight_layout()  # Ajusta o layout para que os gráficos não se sobreponham\n",
        "plt.show()  # Exibe o gráfico\n"
      ],
      "metadata": {
        "id": "I8stEJUOV-4Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Embora se possa argumentar que algumas variáveis, como a \"sales\", esteja ligeiramente mais próxima de uma distribuição normal, essas ainda não é verdadeiramente uma distribuição normal. Portanto, considerando a qualidade e as características dos nossos dados, é ideal não aplicar a normalização, evitando assim forçar um ajuste que poderia não ser adequado.\n",
        "\n",
        "Dessa forma, o próximo passo que vamos seguir será a aplicação da técnica de Rescaling para todas as variáveis. Este método nos ajudará a trazer todas as variáveis para um mesmo intervalo, facilitando assim o trabalho dos algoritmos de aprendizado de máquina na próxima fase do projeto.\n"
      ],
      "metadata": {
        "id": "zeS_CS0FeoVn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.3 Rescaling\n",
        "Antes de mergulhar diretamente nesse processo, é importante revisitar brevemente a motivação por trás da preparação de dados em projetos de ciência de dados.\n",
        "\n",
        "Nosso conjunto de dados contém dois tipos principais de variáveis que exigem modificações:\n",
        "\n",
        "- **Variáveis categóricas**: temos três dessas variáveis em nosso conjunto de dados, que precisam ser convertidas em variáveis numéricas. A razão para isso é que os algoritmos de aprendizado de máquina requerem entradas numéricas para realizar operações de aprendizado. Assim, **a conversão de variáveis categóricas em numéricas é uma etapa fundamental** na preparação de dados.\n",
        "\n",
        "- **Variáveis numéricas**: muitas variáveis em nosso conjunto de dados **possuem intervalos bastante distintos**. Os algoritmos de aprendizado de máquina tendem a atribuir mais importância às variáveis com valores maiores, o que nem sempre é apropriado. Por exemplo, embora a variável \"competition_distance\" possua valores significativamente mais altos do que a variável \"day_of_week\", isso não implica que a primeira seja mais importante que a segunda. Portanto, precisamos equalizar essas diferenças de intervalos para que o algoritmo possa aprender a importância real de cada variável.\n",
        "\n",
        "Assim, a aplicação da técnica de Rescaling ajuda a colocar todas as variáveis em um intervalo comum, permitindo que os algoritmos de aprendizado de máquina trabalhem de forma mais eficiente."
      ],
      "metadata": {
        "id": "HvZnyVSmUt1X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.3.1. Min-Max Scaler\n",
        "Temos a técnica de escalonamento conhecida como Min-Max Scaler, especialmente **útil para variáveis que não seguem uma distribuição normal**.\n",
        "\n",
        "Primeiro, é crucial entender a formulação por trás do Min-Max Scaler. Consideremos uma nova variável numa nova escala, X_scaled. A fórmula que define X_scaled é a seguinte:\n",
        "\n",
        "X_scaled = (X_i - X_min) / (X_max - X_min)\n",
        "\n",
        "Onde X_i é o valor original da variável, e X_max e X_min são, respectivamente, os valores máximo e mínimo da variável em questão.\n",
        "\n",
        "Na prática, o processo envolve as seguintes etapas:\n",
        "\n",
        "- Escolha a variável numérica para a qual você deseja aplicar o Min-Max Scaler.\n",
        "- Calcule o valor mínimo (X_min) e o valor máximo (X_max) da variável escolhida.\n",
        "- Subtraia o valor mínimo de cada valor original da variável (X_i - X_min).\n",
        "- Divida o resultado pelo intervalo, que é a diferença entre o valor máximo e o valor mínimo (X_max - X_min).\n",
        "- O resultado dessa operação será o novo valor na nova escala.\n",
        "\n",
        "Aplicando este cálculo a todos os valores na coluna original, você obterá uma nova coluna de valores numa nova escala.\n",
        "![non-normalized.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "nw9y68FVgvjB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Depois da aplicação de MinMaxScaler:"
      ],
      "metadata": {
        "id": "S6UPNX8YhfrJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![min_max.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "i8rTrfgGhc62"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.3.2. Robust Scaler\n",
        "Vamos explorar outra técnica chamada \"Robust Scaler\", que, assim como a Min-Max Scaler, é usada para escalonar variáveis, porém, é **menos sensível a outliers**.\n",
        "\n",
        "O Min-Max Scaler, embora útil, tem uma limitação importante: é altamente sensível a outliers. Isso ocorre porque **se baseia nos valores mínimos e máximos para escalonar os dados**. Portanto, se houver outliers significativos, **esses extremos distorcem a escala**, aglomerando muitos valores próximos ao zero na nova escala. Isso pode, consequentemente, **alterar a distribuição original dos dados**.\n",
        "\n",
        "Para lidar com esse problema, usamos o Robust Scaler. A ideia por trás dessa técnica é semelhante à Min-Max Scaler, mas **em vez de usar o valor mínimo e máximo, usamos os quartis, que são menos influenciados pelos outliers**.\n",
        "\n",
        "A fórmula para o Robust Scaler é:\n",
        "\n",
        "X_scaled = (X_i - Q1) / (Q3 - Q1)\n",
        "\n",
        "Onde Q1 é o primeiro quartil (25º percentil) e Q3 é o terceiro quartil (75º percentil).\n",
        "\n",
        "**Aplicamos o Robust Scaler a todas as variáveis que apresentam outliers significativos**. Isso nos permite manter a distribuição original dos dados, sem deixar que os outliers distorçam a nova escala.\n",
        "\n",
        "No entanto, deve-se ter em mente que embora o Robust Scaler seja menos sensível a outliers, ele pode comprimir os dados de maneira a alterar a natureza da distribuição original."
      ],
      "metadata": {
        "id": "yuj9p1NQis_0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Aplicação\n",
        "O primeiro passo para a aplicação de técnicas de escalonamento é **identificar as variáveis que serão escalonadas**. Fazemos isso selecionando as variáveis numéricas em nossos dados. No Python, podemos utilizar a função **select_dtypes**, que permite selecionar colunas de um DataFrame com base em seus tipos de dados."
      ],
      "metadata": {
        "id": "ZeQ2s-y6jjbR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = df5.select_dtypes(include = ['int64', 'float64'])\n",
        "a.head()"
      ],
      "metadata": {
        "id": "DgGNiAtTjmyJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nesse código, estamos solicitando que o pandas selecione todas as colunas cujo tipo de dados seja 'int64' ou 'float64', que são os tipos de dados numéricos típicos em pandas. Em seguida, visualizamos as primeiras linhas dessas variáveis para confirmar que as colunas corretas foram selecionadas.\n",
        "\n",
        "A decisão sobre quais variáveis aplicar o MinMaxScaler ou o RobustScaler depende da natureza dos dados. Decidimos aplicar estas técnicas nas variáveis 'day_of_week', 'competition_distance', 'year', 'month', 'day', 'week_of_year', 'competition_time_month' e 'promo_time_week'."
      ],
      "metadata": {
        "id": "qLBkccrpmgeq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Variáveis Cíclicas\n",
        "Ao preparar os dados para modelagem, é essencial considerar a natureza das variáveis que estamos trabalhando. Identifiamos certas variáveis cíclicas como 'month', 'day', 'week_of_year' e 'day_of_week'. Estas variáveis, por natureza, repetem-se ao longo do tempo, portanto, seria mais apropriado aplicar uma transformação cíclica nelas.\n",
        "\n",
        "### Variáveis Não Cíclicas\n",
        "\n",
        "Entretanto, possuímos algumas variáveis que não são cíclicas como 'competition_distance', 'year', 'competitition_time_month', promo_time_week. A questão agora é decidir  aplicar a técnica de escala **MinMaxScaler** ou a técnica **RobustScaler** nessas variáveis. A decisão entre estas duas técnicas geralmente **depende da presença de outliers** nos dados.\n",
        "\n"
      ],
      "metadata": {
        "id": "pwXjVHCxoA7q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Analisar visualmente os dados é uma etapa crucial para determinar a presença de outliers. Ao usar um boxplot para a variável 'competition_distance', por exemplo, podemos identificar se existem outliers significativos:\n",
        "\n"
      ],
      "metadata": {
        "id": "OxM646LBmizv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1. **Robust Scaler** em 'competition_distance'"
      ],
      "metadata": {
        "id": "kN2pY-xCrmKT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_distance'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['competition_distance'])"
      ],
      "metadata": {
        "id": "ww_dLcaLp6Em"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste cenário, como identificamos outliers bem definidos na variável 'competition_distance', a melhor opção é usar o RobustScaler para reescalar essa variável. O RobustScaler é menos sensível a outliers, tornando-o apropriado neste contexto.\n",
        "\n",
        "Para utilizar o RobustScaler, primeiro precisamos importá-lo da biblioteca Scikit-learn em Python."
      ],
      "metadata": {
        "id": "BtbY5pEfqx9T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import RobustScaler\n",
        "rs = RobustScaler()\n",
        "df5['competition_distance'] = rs.fit_transform(df5[['competition_distance']])"
      ],
      "metadata": {
        "id": "3oE7sKkPqkug"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para aplicar o RobustScaler aos dados, usamos método fit_transform(), que ajusta o transformador aos dados e então aplica a transformação. A ideia aqui é que o método fit_transform() irá calcular os parâmetros da fórmula (os quartis neste caso) e então aplicá-los para reescalar os dados.\n",
        "\n",
        "Agora, a coluna 'Competition distance' tem os mesmos valores, mas numa nova escala. Os outliers que identificamos anteriormente agora terão menos influência no restante dos dados."
      ],
      "metadata": {
        "id": "55B8YbUurGSM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_distance'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['competition_distance'])"
      ],
      "metadata": {
        "id": "kppIDAgAVGKP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao analisar o gráfico da variável 'competition distance', percebemos que a nova distribuição varia de 0 a 30 aproximadamente, com os valores reescalados para um intervalo entre 0 e 1. Esta reescala, realizada através da técnica MinMax Scaler, é um passo fundamental na preparação de nossos dados para a modelagem.\n",
        "\n",
        "Ao observar a distribuição original da 'Competition distance', vemos que os valores variavam de 0 a 200 mil, com um número significativo de exemplos por volta de 80 mil. Após a aplicação do escalonamento MinMax, a visualização da distribuição com o distplot mantém o mesmo formato, contudo, o intervalo de valores é agora de 0 a 1.\n",
        "\n",
        "É importante destacar que a transformação MinMax Scaler não altera a distribuição dos dados, mas sim, ajusta a escala para um intervalo comum, o que permite que todas as variáveis tenham a mesma importância na modelagem. A distribuição dos dados permanece a mesma - ou seja, mantém-se o \"shape\" - mas agora no novo intervalo de valores, de 0 a 1.\n",
        "\n",
        "Esta é a essência e o poder da técnica de escalonamento MinMax: garantir que todas as variáveis estejam em um intervalo comum, preservando a forma original da distribuição de dados e permitindo comparações adequadas entre diferentes variáveis para a utilização no modelo."
      ],
      "metadata": {
        "id": "-fe1Gl80VVcQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2. **Robust Scaler** em 'competition_time_month'\n",
        "O mesmo aplicaremos à variável'competition_time_month'.\n"
      ],
      "metadata": {
        "id": "bUO-YkQ1sDS7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_time_month'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['competition_time_month'])"
      ],
      "metadata": {
        "id": "nhO5yzofsG03"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import RobustScaler\n",
        "rs = RobustScaler()\n",
        "df5['competition_time_month'] = rs.fit_transform(df5[['competition_time_month']])"
      ],
      "metadata": {
        "id": "wsnkFxQ1scpV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_time_month'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['competition_time_month'])"
      ],
      "metadata": {
        "id": "PfziPD8wV6YE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "CEgu5qcKV28s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. **MinMaxScaler** em 'promo_time_week'\n"
      ],
      "metadata": {
        "id": "556yVdUOs9Lo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['promo_time_week'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['promo_time_week'])"
      ],
      "metadata": {
        "id": "DuQt6Nx5uYoz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import MinMaxScaler\n",
        "mms = MinMaxScaler()\n",
        "df5['promo_time_week'] = mms.fit_transform(df5[['promo_time_week']])"
      ],
      "metadata": {
        "id": "VJsD-Oqdv2NM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['promo_time_week'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['promo_time_week'])"
      ],
      "metadata": {
        "id": "pQU_sudWWkzm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4. MinMaxScaler em 'year'\n"
      ],
      "metadata": {
        "id": "mQHLnkKUUqY6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['year'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['year'])"
      ],
      "metadata": {
        "id": "RieVLz6NU0ZQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import MinMaxScaler\n",
        "mms = MinMaxScaler()\n",
        "df5['year'] = mms.fit_transform(df5[['year']])"
      ],
      "metadata": {
        "id": "MlvpUSjgUscY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['year'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['year'])"
      ],
      "metadata": {
        "id": "_6UJ2jqVW_6c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.4 Encoding\n",
        "Nesta etapa do projeto, discutiremos a transformação de recursos, especificamente a codificação (encoding) de variáveis. A codificação é um processo que **converte variáveis categóricas em numéricas**, mantendo a informação essencial. Este é um passo crucial na preparação dos dados para modelos de aprendizado de máquina, pois **a maioria desses modelos requer entradas numéricas**.\n",
        "\n",
        "Há uma variedade de métodos de codificação disponíveis, cada um adequado a diferentes tipos de dados categóricos e situações. Embora possa ser comum encontrar referências a apenas dois ou três desses métodos em blogs ou vídeos, na realidade existem mais de dez tipos de codificação para variáveis categóricas.\n",
        "\n",
        "Com uma infinidade de opções, é natural questionar qual é o \"melhor\" método de codificação. Infelizmente, a resposta não é direta e **depende em grande parte dos dados específicos com os quais estamos trabalhando**. Aqui estão duas dicas para auxiliar na escolha do método de codificação adequado:\n",
        "\n",
        "- **Conheça os dados:** Através da análise exploratória, podemos ganhar uma compreensão dos valores únicos (ou \"níveis\") que as variáveis categóricas podem assumir. Por exemplo, uma variável categórica \"cor\" pode ter níveis como \"preto\", \"amarelo\", \"vermelho\", \"laranja\", etc. Ao analisar esses níveis em relação ao objetivo (por exemplo, vendas), podemos obter insights sobre qual método de codificação pode ser o mais adequado.\n",
        "\n",
        "- **Experimentar diferentes métodos:** Não há substituto para a experimentação. Aprenda e aplique diferentes métodos de codificação aos seus dados e compare os resultados. Novos métodos de codificação estão sendo constantemente desenvolvidos, por isso, é sempre bom estar aberto a novas técnicas.\n"
      ],
      "metadata": {
        "id": "SD3mff_DVZM_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tipos de Encoding\n",
        "Exploraremos seis dos mais comuns e eficazes métodos de codificação de variáveis categóricas, cada um com suas características distintas:\n",
        "\n",
        "- **One-Hot Encoding:** Este método, provavelmente o mais conhecido, cria uma nova coluna para cada categoria única na variável original. Cada uma dessas **colunas contém valores binários (0 e 1), representando a presença (1) ou ausência (0)** dessa categoria específica na observação.\n",
        "\n",
        "- **Label Encoding:** O método de codificação de rótulos **atribui a cada categoria única um número inteiro**. Isso é especialmente útil quando a variável categórica tem muitos valores únicos, o que poderia tornar o One-Hot Encoding ineficiente.\n",
        "\n",
        "- **Ordinal Encoding:** Muito semelhante ao Label Encoding, este método também atribui um número inteiro a cada categoria única. A diferença é que o Ordinal Encoding **leva em conta a ordem das categorias, sendo adequado para variáveis categóricas ordinais**, onde as categorias têm uma ordem inerente.\n",
        "\n",
        "- **Target Encoding:** Este método de codificação** usa a média do valor alvo (target)** para uma categoria específica como seu valor codificado. Este método é particularmente útil quando há uma correlação entre a categoria e o valor alvo.\n",
        "\n",
        "- **Frequency Encoding:** Semelhante ao Target Encoding, mas **em vez de usar a média do valor alvo, usa a frequência da categoria** na base de dados.\n",
        "\n",
        "- **Binary Encoding:** Este é um método de codificação interessante que **converte cada categoria em um código binário**, sendo uma solução e**ficiente para lidar com variáveis categóricas com muitas categorias**.\n",
        "\n",
        "Existem muitos recursos excelentes disponíveis para aprender mais sobre esses métodos de codificação. Um desses recursos é um post de [blog](https://towardsdatascience.com/all-about-categorical-variable-encoding-305f3361fd02#:~:text=Thermometer%20Encoder%20is%20used%20to,form%20a%20new%20numerical%20variable.) escrito por um respeitado profissional da área de ciência de dados. O post cobre cada um desses métodos de codificação em detalhes, ilustrando como cada um funciona com gráficos e desenhos. Além disso, recomendo o pacote [Python category_encoders](https://contrib.scikit-learn.org/category_encoders/), que implementa muitos desses métodos de codificação e pode economizar tempo ao evitarmos escrever tudo manualmente."
      ],
      "metadata": {
        "id": "EjpIIHVdckUe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.4.1. One-Hot Encoding\n",
        "Esse enconding converte cada categoria de uma variável categórica em uma nova coluna binária.\n",
        "\n",
        "Para ilustrar essa técnica, vamos usar a variável categórica 'Temperatura' com os níveis 'Cold', 'Warm', 'Hot' e 'Very Hot'. Ao aplicar o One-Hot Encoding, cada um desses níveis se torna uma nova coluna. Em cada linha, a coluna correspondente ao valor original da variável será marcada com '1' e as demais colunas serão marcadas com '0'.\n",
        "\n",
        "Aqui, a variável original 'Temperatura' é 'Hot', então na coluna correspondente 'Hot', colocamos '1', e as demais colunas (Cold, Warm, Very Hot) são preenchidas com '0'.\n",
        "\n"
      ],
      "metadata": {
        "id": "-2AZMn4jfgs3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = {'Temperatura': ['Hot'], 'Cold': [0], 'Warm': [0], 'Hot': [1], 'Very Hot': [0] }\n",
        "df = pd.DataFrame(data); print(df)"
      ],
      "metadata": {
        "id": "LSdoKdN9hqAl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Essa técnica tem vantagens e desvantagens. Uma grande vantagem é que ela é** simples de aplicar e transforma efetivamente variáveis categóricas em numéricas**. No entanto, ela também **pode aumentar significativamente a dimensionalidade dos dados**, especialmente se a variável categórica tiver muitos níveis. Isso pode ser problemático, pois **pode tornar o aprendizado do modelo mais complexo e ineficiente**.\n",
        "\n",
        "Apesar dessa desvantagem, o One-Hot Encoding pode ser particularmente útil em determinadas circunstâncias. Por exemplo, ao codificar uma variável categórica que representa um 'estado', como 'feriado'. Um feriado pode ser visto como um estado diferente de um dia regular. Nesses dois estados diferentes, pode haver diferenças significativas de comportamento que podem ser capturadas através do One-Hot Encoding. Isso pode, portanto, melhorar o desempenho de um modelo de aprendizado de máquina ao prever fenômenos que ocorrem em dias regulares versus feriados."
      ],
      "metadata": {
        "id": "ye1N2k-7hor6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.4.2 Label Encoding\n",
        "O Label Encoding é outra técnica frequentemente utilizada para transformar variáveis categóricas em numéricas. Este método **associa a cada categoria de uma variável categórica um valor numérico único**. Os números atribuídos não têm necessariamente uma relação ordinal ou significado inerente - eles simplesmente servem para representar as categorias de forma numérica.\n",
        "\n",
        "Usando o exemplo da variável categórica 'Temperatura' com os níveis 'Cold', 'Warm', 'Hot' e 'Very Hot', o processo de Label Encoding poderia resultar no seguinte:"
      ],
      "metadata": {
        "id": "ml_efcR4gabf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = {'Temperatura': ['Hot', 'Cold', 'Very Hot', 'Warm'], 'Label Encoding': [1, 2, 3, 4]}\n",
        "df = pd.DataFrame(data); df"
      ],
      "metadata": {
        "id": "e0sxcE5phbQa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aqui, cada categoria de 'Temperatura' foi substituída por um número único. Não há uma relação ordinal entre esses números; eles simplesmente servem para representar as diferentes categorias.\n",
        "\n",
        "O Label Encoding é particularmente útil quando se lida com variáveis categóricas que representam entidades nominalmente diferentes sem uma relação ordenada explícita, como nomes de lojas ou marcas de produtos. Embora simples e eficiente, é importante ressaltar que essa técnica pode levar a interpretações errôneas do modelo se a variável categórica tiver uma natureza ordinal. Isso ocorre porque o Label Encoding trata todas as categorias como numericamente equivalentes, independentemente da sua ordem."
      ],
      "metadata": {
        "id": "yhZLlqQxhUdi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.4.3 Ordinal Encoding\n",
        "O método Ordinal Encoding é uma técnica de codificação de variáveis categóricas que considera a ordem ou a hierarquia às categorias. Esta técnica é útil quando os valores categóricos têm um significado de ordem (como 'baixo', 'médio', 'alto', ou 'frio', 'morno', 'quente', 'muito quente').\n",
        "\n",
        "Por exemplo, considere a variável categórica 'Temperatura' com os níveis 'Cold', 'Warm', 'Hot', 'Very Hot'. Ao contrário do Label Encoding, que atribui valores numéricos arbitrários, o Ordinal Encoding consideraria a ordem natural dessas categorias. Ou seja, 'Cold' (Frio) é inferior a 'Warm' (Morno), que é inferior a 'Hot' (Quente), que por sua vez é inferior a 'Very Hot' (Muito quente)."
      ],
      "metadata": {
        "id": "vlnHaa9EiA4S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from sklearn.preprocessing import OrdinalEncoder\n",
        "\n",
        "# Dados de exemplo\n",
        "data = {'Temperatura': ['Cold', 'Warm', 'Hot', 'Very Hot']}\n",
        "\n",
        "# Criação do DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Aplicação do Ordinal Encoding\n",
        "encoder = OrdinalEncoder(categories=[['Cold', 'Warm', 'Hot', 'Very Hot']])\n",
        "df['Temperatura_encoded'] = encoder.fit_transform(df[['Temperatura']])\n",
        "\n",
        "print(df)\n"
      ],
      "metadata": {
        "id": "D0teC3wwi2JP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Desta forma, o Ordinal Encoding transfere a ordem natural da variável categórica para a representação numérica, criando assim uma representação mais significativa dos dados para certos algoritmos de aprendizado de máquina.\n",
        "\n",
        "No entanto, deve-se ter cuidado ao utilizar o Ordinal Encoding com variáveis que não possuem uma relação explícita de ordem, pois isso poderia introduzir uma suposição de ordem onde não existe, possivelmente levando a um modelo de aprendizado de máquina impreciso."
      ],
      "metadata": {
        "id": "zhTHvtyQi81I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.4.4 Target Encoding"
      ],
      "metadata": {
        "id": "LDyouBpOjHcg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A codificação target funciona calculando a média do valor alvo (target) para cada categoria da variável categórica e substituindo a categoria por esse valor médio.\n",
        "\n",
        "Para ilustrar, suponha que temos uma variável categórica chamada \"Temperatura\" com categorias como 'Hot', 'Cold', 'Very Hot' e 'Warm', e uma variável de destino que representa as vendas.\n",
        "\n",
        "Se aplicarmos a codificação target à variável \"Temperatura\", cada categoria (nível) será substituída pela média de vendas correspondente a essa categoria."
      ],
      "metadata": {
        "id": "XEba5G7ikuXU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = {\n",
        "    'temperature': ['hot', 'cold', 'very hot', 'warm', 'hot', 'warm', 'warm', 'hot', 'hot', 'cold'],\n",
        "    'temp_target': [0.7, 0.5, 0.2, 0.3, 0.7, 0.3, 0.3, 0.7, 0.7, 0.5]}; df = pd.DataFrame(data); df"
      ],
      "metadata": {
        "id": "zZfKHYvijJ5Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Este método é particularmente útil para variáveis categóricas com muitos níveis, pois pode lidar com a alta dimensionalidade de forma eficiente, sem a necessidade de criar muitas novas colunas (como no caso da codificação one-hot)."
      ],
      "metadata": {
        "id": "PnGQp6-qlKpr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.4.5 Frequency Encoding\n",
        "A Frequency Encoding é um método útil para tratar variáveis categóricas com muitos níveis. Esse método substitui cada valor categórico pela frequência (contagem) ou proporção de ocorrências desse valor no conjunto de dados.\n",
        "\n",
        "Para exemplificar, consideremos uma variável categórica \"temperatura\" com níveis 'Hot', 'Cold', 'Very Hot', e 'Warm'. A codificação de frequência substituiria cada ocorrência de 'Hot' pela contagem total ou proporção de 'Hot' no conjunto de dados."
      ],
      "metadata": {
        "id": "55e-IEGKlbRF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = {\n",
        "    'temperature': ['hot', 'cold', 'very hot', 'warm', 'hot', 'warm', 'warm', 'hot', 'hot', 'cold'],\n",
        "    'temp_target': [0.4, 0.2, 0.1, 0.3, 0.4, 0.3, 0.3, 0.4, 0.4, 0.2]}; df = pd.DataFrame(data); df"
      ],
      "metadata": {
        "id": "4KUnrTIjk6Ms"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A codificação de frequência pode ser particularmente útil em casos onde a variável categórica é representativa de um \"nome\" sem qualquer relação intrínseca entre os níveis. Por exemplo, em um projeto envolvendo marcas de carros, a codificação de frequência poderia ser usada para substituir cada marca ('Chevrolet', 'Ford', etc.) pela frequência de ocorrência dessa marca no conjunto de dados.\n"
      ],
      "metadata": {
        "id": "aWO4_s88mnX1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.4.6 Embeding Encoding\n",
        "O encoding de incorporação (Embedding Encoding) é uma técnica muito usada em aprendizado profundo, particularmente em tarefas de Processamento de Linguagem Natural (NLP). Ela permite transformar dados categóricos em vetores numéricos densos de dimensão fixa, onde as palavras ou categorias semelhantes são mapeadas para vetores próximos no espaço de vetores.\n",
        "\n",
        "Suponha que tenhamos um vocabulário de palavras com \"hot\", \"cold\", \"very hot\", \"warm\". Em uma representação de incorporação de dimensão 2 (apenas para facilitar a visualização), as palavras podem ser representadas por vetores bidimensionais:\n",
        "\n",
        "- \"hot\": [0.1, 0.3]\n",
        "- \"cold\": [-0.2, -0.1]\n",
        "- \"very hot\": [0.2, 0.4]\n",
        "- \"warm\": [0, 0.2]\n",
        "\n",
        "A chave aqui é que esses vetores não são arbitrários, mas são aprendidos durante o treinamento do modelo, com base em como as palavras ou categorias co-ocorrem no conjunto de dados."
      ],
      "metadata": {
        "id": "eAkUNfb7nlVT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.5 Encoding na Prática\n",
        "Temos o nosso DataFrame \"df5\", que inclui uma variável categórica chamada \"state_holiday\". Esta variável pode assumir diferentes estados, como 'dias regulares', 'Páscoa', 'Natal' e assim por diante.\n",
        "\n",
        "A codificação One-hot cria novas colunas binárias para cada categoria única presente na variável original. Assim, cada observação recebe um '1' na coluna correspondente ao seu estado e '0' nas demais colunas.\n",
        "\n",
        "No Pandas, a função get_dummies() pode ser usada para realizar essa transformação de forma simples e eficaz. Por exemplo:"
      ],
      "metadata": {
        "id": "RsxNhFvroBJ3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df6 = df5.copy()"
      ],
      "metadata": {
        "id": "Y8KJEty8EQkE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.5.1 state_holiday"
      ],
      "metadata": {
        "id": "r_pRd2xMwx6L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# state_holiday - One-Hot Encoding\n",
        "df6 = pd.get_dummies(df6, columns=['state_holiday'], prefix='state_holiday');df6"
      ],
      "metadata": {
        "id": "jqlemly-mJgx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste exemplo, o argumento columns especifica a coluna a ser codificada, enquanto o argumento prefix indica o prefixo a ser adicionado ao nome de cada nova coluna."
      ],
      "metadata": {
        "id": "vos90hbhvWPn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.5.2 store_type\n",
        "O pacote sklearn fornece a classe LabelEncoder, que pode ser usada para transformar variáveis categóricas em números. Temos a variável categórica chamada \"store_type\", com categorias do tipo 'A', 'B' ou 'C'.\n",
        "\n",
        "O LabelEncoder substitui cada categoria única por um número inteiro. Esta transformação é útil quando as categorias têm uma ordem natural (por exemplo, 'baixo', 'médio', 'alto'), mas também pode ser usada em casos em que a ordem não está clara."
      ],
      "metadata": {
        "id": "WosP-m3Sw1-T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "le = LabelEncoder()\n",
        "df6['store_type'] = le.fit_transform(df6['store_type'])"
      ],
      "metadata": {
        "id": "yKgSG9fawIiM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nesse código, o método fit_transform é usado para ajustar o LabelEncoder à variável 'store_type' e, em seguida, transformar essa variável. Em seguida, o resultado é armazenado na mesma coluna 'store_type' no DataFrame original.\n",
        "\n",
        "Se chamarmos fit_transform nos dados de treinamento, tudo está bem: o LabelEncoder aprende o mapeamento com base nas categorias presentes no conjunto de treinamento e então aplica esse mapeamento ao conjunto de treinamento.\n",
        "\n",
        "No entanto, se também chamarmos fit_transform nos dados de teste, teremos um problema: o LabelEncoder aprenderá um novo mapeamento, que pode ser diferente do mapeamento aprendido nos dados de treinamento. Isso significa que a mesma categoria pode ser mapeada para números diferentes nos conjuntos de treinamento e teste, o que é confuso para o modelo."
      ],
      "metadata": {
        "id": "Xw8eLFq7xzP3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.5.3 assortment\n",
        "Temos a variável categórica 'Assortment', que contém três categorias: 'Basic', 'Extra' e 'Extended'. Estas categorias têm uma ordem inerente, ou seja, 'Basic' é menor que 'Extra', que por sua vez é menor que 'Extended'.\n",
        "\n",
        "Nesses casos, é útil mapear essas categorias para números que refletem essa ordem. Para isso, utilizamos o método de codificação ordinal.\n",
        "\n",
        "Para aplicar a codificação ordinal, primeiro definimos um dicionário que mapeia cada categoria para um número que reflete a sua posição na escala.\n",
        "\n",
        "Este mapeamento é implementado com o seguinte dicionário:"
      ],
      "metadata": {
        "id": "f_YFA0T9zFrk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "assortment_dict = {'basic':1, 'extra':2, 'extended':3}\n",
        "df6['assortment'] = df6['assortment'].map(assortment_dict)\n",
        "df6.sample()"
      ],
      "metadata": {
        "id": "b1JinanwxjXW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.6 Transformação dos Dados\n",
        "A transformação de dados é uma técnica comum em ciência de dados que ajuda a melhorar a interpretabilidade do modelo, a precisão da previsão e a aderência às premissas dos algoritmos de aprendizado de máquina. Existem dois tipos principais de transformações:\n",
        "\n",
        "- **Transformação de Grandeza:** O objetivo dessa transformação é **aproximar a distribuição da variável resposta de uma distribuição normal**. Muitos algoritmos de aprendizado de máquina, especialmente os baseados em métodos estatísticos, têm como **premissa que os dados seguem uma distribuição normal**. Quando a distribuição da **variável resposta é mais próxima de uma normal, a performance do algoritmo tende a melhorar**. Ou seja, essa transformação ajuda a aumentar a precisão dos modelos, aproximando a distribuição dos dados das premissas dos algoritmos usados.\n",
        "\n",
        "- **Transformação de Natureza:** Essa transformação tem como objetivo capturar a natureza inerente dos dados dentro do conjunto de dados. Por exemplo, em uma variável que representa os meses do ano, numerados de 1 (Janeiro) a 12 (Dezembro), a proximidade entre os números não reflete a realidade de que Dezembro (12) e Janeiro (1) são meses sucessivos, ou seja, estão próximos. **Quando tratamos essa variável como numérica, perdemos a noção cíclica inerente aos meses do ano**. A transformação de natureza permite que capturemos essa característica cíclica, fazendo com que Dezembro seja considerado próximo a Janeiro, como é na realidade."
      ],
      "metadata": {
        "id": "NXktUVfI6Vzc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.6.1 Tipos de Transformação\n",
        "Transformações de dados são técnicas usadas para **mudar a escala ou a distribuição dos dados**, e existem várias abordagens para realizá-las. As transformações mais comuns incluem a transformação logarítmica, a transformação Box-Cox, a extração de raiz cúbica, e a extração de raiz quadrada. Essas transformações são particularmente úteis para lidar com dados assimétricos.\n",
        "\n",
        "- **Transformação Logarítmica:** Uma das transformações mais comuns, a transformação logarítmica, é aplicada tomando o logaritmo de todos os valores da variável. Isso pode ajudar a **tornar as distribuições enviesadas mais semelhantes a uma distribuição normal**.\n",
        "\n",
        "- **Transformação Box-Cox:** Esta é uma família de transformações parametrizadas que inclui a transformação logarítmica, raiz quadrada, inversa, entre outras, e é usada para criar uma versão mais normal da variável. A transformação Box-Cox tem uma fórmula específica e pacotes de software que automatizam esse processo.\n",
        "\n",
        "- **Extração de Raiz Cúbica:** Esta transformação envolve tomar a raiz cúbica de todos os valores na variável. É útil quando os dados têm uma assimetria positiva.\n",
        "\n",
        "- **Extração de Raiz Quadrada:** Similar à extração de raiz cúbica, mas neste caso, estamos tomando a raiz quadrada dos valores.\n",
        "\n",
        "Essas transformações ajudam a moldar os dados para que se tornem mais compatíveis com as premissas do algoritmo que será usado, aumentando assim a precisão do modelo. No entanto, é importante ressaltar que nem"
      ],
      "metadata": {
        "id": "9oMalNps67WU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Transformação Logarítmica da Variável Resposta 'sales'\n",
        "O processo para aplicar a transformação logarítmica na variável de resposta é simples. Em nosso exemplo, utilizaremos a função log1p do pacote NumPy, uma função que aplica o logaritmo natural mais 1, para transformar a variável resposta, denominada neste caso como sales."
      ],
      "metadata": {
        "id": "hSdSL0pm78Fw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "sns.distplot(df6['sales'])\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "df6['sales'] = np.log1p(df6['sales'])\n",
        "sns.distplot(df6['sales'])"
      ],
      "metadata": {
        "id": "6Vvlo698wOfX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao visualizar o histograma à direita, esperamos ver uma distribuição que se assemelha mais à forma de um sino, característica de uma distribuição normal. Isso indica que a transformação logarítmica foi bem-sucedida em tornar a distribuição dos dados mais próxima da normalidade.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "m8ZYBR5A97w6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Transformação Cíclica Temporal\n",
        "A transformação de natureza tem como objetivo capturar a \"verdadeira natureza\" dos dados. Vamos usar um exemplo de dados temporais para esclarecer isso. Se você tem dados mensais que se repetem a cada ano (de Janeiro a Dezembro), isso constitui um ciclo. O desafio é representar essa natureza cíclica nos dados.\n",
        "\n",
        "Suponha que estejamos no ano de 2023 com meses de Janeiro a Dezembro e o mesmo se repete para 2024. Notamos que há um ciclo: a cada ano que passa, os mesmos meses se repetem.\n",
        "\n",
        "Imagine um círculo onde cada mês é um ponto ao longo da borda. Agora, a distância entre Janeiro e Fevereiro é a mesma que a distância de Dezembro a Janeiro. Isso porque os dados são cíclicos, onde Janeiro (do próximo ano) segue Dezembro. Se usássemos uma representação linear (por exemplo, números de 1 a 12 para representar os meses), perderíamos essa informação cíclica. O número 1 (Janeiro) estaria distante do número 12 (Dezembro), mas na verdade, eles estão muito próximos em termos de tempo.\n",
        "\n",
        "Para resolver este problema, podemos usar uma técnica chamada \"codificação cíclica\", que **se baseia no círculo trigonométrico**. Nessa técnica, cada mês é representado por duas coordenadas: **o seno e o cosseno do ângulo que corresponde a esse mês no círculo**.\n",
        "\n",
        "Supondo que dividimos nosso círculo em 12 partes iguais (para os 12 meses), Janeiro (representado por 1) teria um seno de 0 e cosseno de 1. Fevereiro, sendo o segundo mês, teria um seno de 0.92 e cosseno de 0.4, e assim por diante para os outros meses.\n",
        "\n",
        "Assim, cada mês é agora representado por dois valores - seno e cosseno - que juntos capturam sua natureza cíclica. Embora isso possa parecer que estamos aumentando a dimensionalidade dos dados (criando uma coluna adicional), a informação adicional que capturamos **(a natureza cíclica dos dados) supera o aumento da dimensionalidade**."
      ],
      "metadata": {
        "id": "jW2lo26o_Mvi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df6['month_sin'] = df6['month'].apply(lambda x: np.sin(x * (2. * np.pi/12)))\n",
        "df6['month_cos'] = df6['month'].apply(lambda x: np.cos(x * (2. * np.pi/12)))"
      ],
      "metadata": {
        "id": "Y50c9F8O9WCo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos descrever essa etapa de forma mais técnica e concisa:\n",
        "\n",
        "Selecionando a coluna de meses: A primeira coisa a se fazer é selecionar a coluna 'month' no DataFrame df5. Esta é a coluna que será transformada.\n",
        "\n",
        "Definindo a função de transformação: Em seguida, definimos a função de transformação que será aplicada a cada valor na coluna de meses. Essa função usa a função seno para transformar cada valor. O valor é multiplicado por 2 * π / ciclo, onde ciclo é a duração do ciclo (neste caso, 12 meses).\n",
        "\n",
        "A função de transformação é aplicada a cada valor na coluna de meses usando o método apply, que aplica uma função a cada elemento de uma série ou um dataframe. O resultado é armazenado em uma nova coluna chamada 'month_sin'.\n",
        "\n",
        "Repetindo o processo com a função cosseno: O processo é então repetido, mas desta vez usando a função cosseno. O resultado é armazenado em outra nova coluna chamada 'month_cos'.\n",
        "\n",
        "Agora faremos o mesmo para as demais varíaveis cíclicas e seus respectivos períodos:"
      ],
      "metadata": {
        "id": "N5_NKY7oCBPB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df6['day_of_week_sin'] = df6['day_of_week'].apply(lambda x: np.sin(x * (2. * np.pi/7)))\n",
        "df6['day_of_week_cos'] = df6['day_of_week'].apply(lambda x: np.cos(x * (2. * np.pi/7)))"
      ],
      "metadata": {
        "id": "3PobnjnJCfRt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df6['day_sin'] = df6['day'].apply(lambda x: np.sin(x * (2. * np.pi/30)))\n",
        "df6['day_cos'] = df6['day'].apply(lambda x: np.cos(x * (2. * np.pi/30)))"
      ],
      "metadata": {
        "id": "8q2-cq0WCf7R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df6['week_of_year_sin'] = df6['week_of_year'].apply(lambda x: np.sin(x * (2. * np.pi/52)))\n",
        "df6['week_of_year_cos'] = df6['week_of_year'].apply(lambda x: np.cos(x * (2. * np.pi/52)))"
      ],
      "metadata": {
        "id": "nb2USC-eCfra"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- **Transformação cíclica para Dias da Semana:** Reconhecemos que o ciclo de um dia da semana é de sete dias, pois uma semana contém sete dias. Portanto, ao aplicar as funções seno e cosseno, utilizamos o número sete como período do ciclo.\n",
        "\n",
        "- **Transformação cíclica para Mês:** Em seguida, assumimos que um mês, em média, dura 30 dias. Portanto, ao realizar a transformação cíclica para a variável mês, utilizamos o número 30 como o período do ciclo.\n",
        "\n",
        "- **Transformação cíclica para Semana do Ano:** Finalmente,  um ano tem aproximadamente 52 semanas. Então, ao realizar a transformação cíclica para a variável semana do ano, utilizamos o número 52 como o período do ciclo.\n",
        "\n",
        "Porém, não se deve aplicar essa transformação cíclica à variável ano, pois ela é considerada uma variável linear e não cíclica, a menos que se possa retroceder no tempo."
      ],
      "metadata": {
        "id": "X9Ru834aDLYW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Update do Projeto\n",
        "Aqui está uma descrição passo a passo do nosso projeto de projeção de vendas seguindo a metodologia CRISP-DM:\n",
        "\n",
        "- **Definição do Problema de Negócio:** A etapa inicial foi entender a demanda do nosso cliente, neste caso, os gerentes de lojas que solicitaram uma previsão de vendas para os próximos seis meses. Essa etapa é crucial para estabelecer os objetivos e limites do nosso projeto.\n",
        "\n",
        "- **Entendimento do Negócio:** Antes de mergulharmos de cabeça na solução, realizamos um trabalho de investigação para entender melhor o \"porquê\" dessa solicitação. Descobrimos que **o objetivo final era estipular um orçamento para reforma das lojas**. O valor destinado para as reformas depende do quanto cada loja poderá gerar em faturamento. Portanto, **a previsão de vendas é fundamental para planejar as reformas**.\n",
        "\n",
        "- **Coleta de Dados:** Uma vez entendido o problema, passamos para a coleta de dados. Para o nosso projeto, os dados foram baixados a partir de uma plataforma Kaggle. No entanto, na prática, coletar dados pode envolver diversas fontes e métodos, desde consultas em bancos de dados até a solicitação de dados através de interfaces de programação (API's).\n",
        "\n",
        "- **Limpeza de Dados:** Com os dados em mãos, fizemos um \"check-up\" neles. Primeiro, observamos de maneira geral para entender a extensão e natureza do conjunto de dados. Em seguida, realizamos o \"feature engineering\", para criar novas variáveis (features) a partir dos dados brutos que temos. Por último, filtramos as variáveis com base em restrições de negócio, ou seja, levamos em conta as regras e limitações que existem no mundo real.\n",
        "\n",
        "- **Exploração de Dados:** Depois da limpeza, partimos para uma análise mais aprofundada dos dados. Isso envolveu buscar correlações entre as variáveis e gerar hipóteses para entender melhor como os dados se relacionam e como podem nos ajudar a fazer a previsão de vendas.\n",
        "\n",
        "- **Modelagem de Dados:** Na modelagem, preparamos nossos dados para alimentar um modelo de aprendizado de máquina. Isso incluiu a seleção das variáveis mais relevantes, ou seja, aquelas que acreditamos que o modelo pode aprender melhor para fazer a previsão de vendas.\n",
        "---"
      ],
      "metadata": {
        "id": "UGOJmH0iG2LG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6. Feature Selection\n",
        "\n",
        "### 6.1 Motivação da Seleção de Atributos\n",
        "A seleção de variáveis é uma etapa crucial em projetos de ciência de dados. Ela se alinha a um dos princípios da aprendizagem estatística, conhecido como princípio da Navalha de Occam, que indica que a explicação mais simples para um fenômeno observado deve ser preferida sobre explicações mais complexas.\n",
        "\n",
        "Para ilustrar, consideremos o exemplo de descrever um carro. Uma descrição simples pode incluir quatro rodas, dois faróis, uma placa, lanternas e um retrovisor. Essa descrição forma um \"modelo\", uma representação simplificada de um fenômeno observado (neste caso, um carro).\n",
        "\n",
        "Alguém pode nos fornecer uma descrição mais complexa, incluindo Bluetooth, wi-fi, quatro portas, câmbio automático, entre outros. Este é também um modelo, mas mais detalhado e complexo. No entanto, nem todos os carros possuem esses recursos. Portanto, esse modelo mais complexo não se aplica a todos os carros e é, por isso, menos generalizável.\n",
        "\n",
        "Assim, segundo o princípio da Navalha de Occam, **deve-se dar preferência ao modelo mais simples**, pois é mais provável que generalize melhor o fenômeno em questão. Este princípio guia a seleção de variáveis em um projeto de ciência de dados.\n",
        "\n",
        "Em aprendizagem de máquina, o objetivo é simplificar a aprendizagem usando modelos mais simples, ou seja, modelos com menos variáveis para ajustar. A simplicidade do conjunto de dados está na quantidade de colunas ou variáveis (também chamadas de características ou 'features') que ele contém. Algumas destas variáveis podem ser redundantes ou 'colineares', ou seja, elas explicam a mesma parte do fenômeno observado.\n",
        "\n",
        "A identificação e remoção de variáveis colineares simplifica o modelo, tornando-o mais eficiente. No exemplo do carro, \"quatro rodas\" e \"quatro pneus\" são variáveis colineares que descrevem a mesma coisa. Da mesma forma, \"lanternas\" e \"faróis\", e \"para-brisa dianteiro\" e \"janela frontal\" são pares de variáveis colineares.\n",
        "\n",
        "Portanto, a seleção de variáveis envolve identificar e remover variáveis colineares, resultando em um modelo mais simples que pode ser aprendido mais facilmente por algoritmos de aprendizagem de máquina. Existem diversas técnicas para a seleção de variáveis, que serão discutidas e implementadas em estágios posteriores do nosso projeto.\n"
      ],
      "metadata": {
        "id": "DDOFKO2BFQV9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.1.2. Métodos de Seleção de Atributos\n",
        "- **Seleção Univariada (Filter Methods):** Avalia cada variável individualmente com relação à variável alvo ou variável resposta. Ela verifica a relação estatística entre cada variável de entrada e a variável de saída. As variáveis que apresentam uma relação forte (alta correlação, por exemplo) são selecionadas, enquanto aquelas que apresentam uma relação fraca (baixa correlação) são descartadas.\n",
        "\n",
        "- **Seleção por Importância (Embedded Methods):** Este método **prioriza variáveis com base na sua relevância estatística** dentro do conjunto de dados. As variáveis são classificadas de acordo com sua importância, ou seja, o impacto que têm sobre a variável de saída ou resultado.\n",
        "\n",
        "- **Seleção por Subset (Wrapper Methods):** Este método avalia conjuntos de variáveis como um todo para **identificar subconjuntos de variáveis que, em conjunto, fornecem o melhor desempenho**. Este método é especialmente útil quando as variáveis estão correlacionadas entre si.\n",
        "\n",
        "Cada método utiliza um mecanismo específico para classificar as variáveis como relevantes ou não para o aprendizado do modelo. Além disso, cada abordagem possui suas próprias vantagens e desvantagens, e a escolha do método ideal geralmente depende do conjunto de dados específico e dos objetivos do projeto.\n",
        "\n",
        "Em ciência de dados, a relevância de uma variável é definida pelo quanto essa variável consegue explicar de um fenômeno que ocorre no mundo real. No contexto de um modelo de aprendizado de máquina, a relevância é uma medida de quão influente uma variável é na previsão do resultado desejado.\n",
        "\n",
        "Tomemos o exemplo de um projeto que objetiva entender as vendas de um produto. Podemos ter várias variáveis, como preço, ano, promoção e feriados. Cada uma dessas variáveis pode explicar uma porção do fenômeno das vendas. No entanto, **nem todas têm o mesmo grau de influência**. Por exemplo,** a promoção pode explicar uma grande parte do fenômeno** de venda, **enquanto o feriado pode explicar apenas uma pequena parte**. Nesse caso, a promoção é mais relevante do que o feriado para o modelo.\n",
        "\n",
        "### • Coeficiente de Correlação em Variáveis Numéricas\n",
        "Para quantificar matematicamente essa relevância, **utilizamos o coeficiente de correlação**, que mede a intensidade da relação entre duas variáveis. O valor deste coeficiente vai de -1 a 1. Se for próximo de 1, indica uma correlação positiva forte, ou seja, quando uma variável aumenta, a outra também tende a aumentar. Se for próximo de -1, indica uma correlação negativa forte, ou seja, quando uma variável aumenta, a outra tende a diminuir. Se for próximo de zero, indica uma correlação fraca, ou seja, as duas variáveis têm pouca relação entre si.\n",
        "\n",
        "Por exemplo, se plotarmos as vendas em relação ao preço, podemos ver que quanto maior o preço, menor é a venda. Portanto, há uma correlação negativa forte. Se plotarmos as vendas em relação aos anos, podemos ver que quanto mais anos passam, mais vendemos. Portanto, há uma correlação positiva forte. Se plotarmos as vendas em relação à distância até os concorrentes, podemos ver que não há um comportamento claro. Portanto, há uma correlação fraca.\n",
        "\n",
        "### • Coeficiente de Correlação em Variáveis Categóricas\n",
        "Em todos esses exemplos, estávamos lidando com variáveis numéricas. Mas e se tivermos variáveis categóricas? Ainda podemos calcular a correlação. Dependendo do tipo de variável (numérica ou categórica), usamos diferentes métodos para calcular a correlação:\n",
        "\n",
        "- **Entre duas variáveis contínuas:** correlação de Pearson.\n",
        "- **Entre duas variáveis categóricas:** Cramér's V ou Chi-Square.\n",
        "- **Entre preditora categórica e alvo contínua:** Análise de Variância (ANOVA).\n",
        "- **Entre preditora contínua e alvo categórica:** Linear Discriminant Analysis (LDA).\n",
        "\n",
        "### • Método de Seleção Univariada\n",
        "O método de seleção univariada envolve a análise da correlação entre cada variável individual ou \"univariada\" e a variável resposta. Em outras palavras, avalia-se a **relação direta entre cada variável de entrada e a variável que estamos tentando prever** ou classificar.\n",
        "\n",
        "Entre as vantagens da seleção univariada estão sua simplicidade e eficiência. Isso pode parecer óbvio, mas nem todos os métodos de seleção de variáveis são fáceis de entender ou rápidos de aplicar. A seleção univariada, por sua natureza, é facilmente compreensível e pode ser realizada de maneira relativamente rápida.\n",
        "\n",
        "No entanto, a seleção univariada tem uma desvantagem significativa: **ela não considera a influência conjunta de múltiplas variáveis na variável resposta**. As variáveis em um conjunto de dados **muitas vezes não operam isoladamente**; elas **podem influenciar umas às outras** e essa interação pode ter um impacto considerável na variável resposta.\n",
        "\n",
        "Por exemplo, pode haver uma situação em que uma variável individual tenha uma correlação fraca com a variável resposta e, portanto, seria descartada na seleção univariada. No entanto, essa mesma variável, **quando combinada com outra, pode ter uma correlação forte com a variável resposta**.\n",
        "\n",
        "Portanto, ao usar o método de seleção univariada, **há o risco de excluir variáveis que, quando combinadas com outras**, podem ter uma forte correlação com a variável resposta. Este é um aspecto crítico a ser considerado ao escolher o método de seleção de variáveis a ser utilizado.\n",
        "\n",
        "Para superar esta limitação, outras técnicas de seleção de variáveis mais sofisticadas e avançadas são usadas, que levam em conta a influência combinada das variáveis.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "PEGTAd8bT3br"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.1.3. Seleção de Variáveis pelo Método de Importância\n",
        "A seleção de variáveis pelo método de importância é uma abordagem integral na ciência de dados, diferente do método univariado que se concentra principalmente na correlação entre as variáveis. Esta abordagem é **conhecida também como método embutido**. Sua nomeação deve-se ao fato de que a seleção de variáveis de importância é frequentemente um subproduto do processo de aprendizado de alguns modelos de algoritmos.\n",
        "\n",
        "Por exemplo, o algoritmo de aprendizado, conhecido como \"Random Forest\", que é utilizado tanto para classificação quanto para regressão, cria uma \"floresta\" de árvores de decisão durante o processo de aprendizado. **Para construir uma árvore ótima, o algoritmo seleciona as variáveis mais relevantes**. Logo, a própria ideia de aprendizado do modelo já está embutida na seleção de variáveis por importância. Desta forma, podemos usar o algoritmo não apenas para classificação ou regressão, mas também para identificar as variáveis mais relevantes para o modelo.\n",
        "\n",
        "Outro exemplo são os algoritmos de regressão regularizados, como o Lasso (Least Absolute Shrinkage and Selection Operator) e o Ridge. **Na regressão regularizada, é atribuído um peso a cada variável**, que é definido por meio do algoritmo de aprendizado. **As variáveis que recebem pesos mais altos geralmente são mais importantes** para o aprendizado do modelo, enquanto as variáveis com pesos menores tendem a ser menos relevantes.\n",
        "\n",
        "Portanto, **o método de seleção de variáveis por importância é uma ferramenta poderosa**, que permite identificar as variáveis mais relevantes para o aprendizado de modelos complexos, como os utilizados em algoritmos de machine learning. Essa seleção de variáveis é feita como parte integral do processo de aprendizado do modelo, o que a torna um método muito eficiente e eficaz para a seleção de variáveis."
      ],
      "metadata": {
        "id": "4yANRh6bfpJF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.1.4. Seleção de Variáveis com Gini Impurity\n",
        "O algoritmo Random Forest utiliza um critério de impureza, especificamente a impureza de Gini, para selecionar variáveis. A impureza de Gini é uma métrica de homogeneidade: a seleção de variáveis se baseia em **dividir o conjunto de dados original em dois subconjuntos o mais homogêneos (ou similares) possíveis**. Se uma variável consegue realizar essa divisão de forma eficaz, ela é considerada importante.\n",
        "\n",
        "Por exemplo, suponha que temos um conjunto de dados de vendas e decidimos dividir esse conjunto usando a variável \"preço\". As vendas com preço baixo formam um subconjunto e as vendas com preço alto formam outro. Se os dois subconjuntos resultantes forem homogêneos (ou seja, as vendas em cada grupo são bastante similares), então o \"preço\" é uma variável importante.\n",
        "\n",
        "Agora, suponha que decidimos dividir ainda mais o subconjunto de vendas de preço baixo usando a variável \"promoção\". As vendas a preço baixo fora do período promocional formam um grupo e as vendas a preço baixo durante o período promocional formam outro. Se a variabilidade dentro de cada subconjunto aumentar (ou seja, as vendas em cada grupo não são tão similares), então \"promoção\" é uma variável menos importante.\n",
        "\n",
        "A ideia geral, portanto, é que o algoritmo Random Forest seleciona variáveis que dividem o conjunto de dados de forma que os subconjuntos resultantes sejam o mais homogêneos possível. Esse processo ajuda a determinar a importância de cada variável.\n",
        "\n",
        "Na prática, **treinamos um modelo Random Forest no nosso conjunto de dados de treinamento, e o resultado inclui a importância de cada variável**. Podemos então plotar essas importâncias, o que nos ajuda a entender quais variáveis são mais relevantes para o modelo. Em resumo, a seleção de variáveis com base na impureza de Gini é um método poderoso para identificar as variáveis mais importantes em um conjunto de dados, permitindo-nos criar modelos mais simples e eficazes.\n",
        "\n",
        "### 6.1.5 Seleção de Variávies com Regressão Lasso\n",
        "A Regressão Lasso é um método de regressão que pode ser usado para a seleção de variáveis. Ela funciona **impondo uma penalidade aos coeficientes do modelo**, de tal forma que **alguns deles são forçados a ser exatamente zero**. Esse processo é chamado de **regularização**.\n",
        "\n",
        "A regressão Lasso funciona da seguinte maneira: primeiro, ajustamos o modelo aos nossos dados, que consistem em várias características mais a variável de resposta. Em seguida, examinamos os pesos (ou coeficientes) que o modelo atribuiu a cada variável. Variáveis com um peso significativamente maior ou menor que zero são consideradas importantes, enquanto as que têm um peso próximo de zero podem ser consideradas menos importantes ou irrelevantes.\n",
        "\n",
        "Por exemplo, se treinamos um modelo Lasso e descobrimos que três variáveis têm os maiores pesos positivos e outras três têm os maiores pesos negativos, podemos considerar essas seis variáveis como as mais importantes. Se tínhamos originalmente 15 ou 16 variáveis, agora reduzimos nosso modelo para apenas seis variáveis, mantendo uma grande parte da explicabilidade do fenômeno que estamos estudando.\n",
        "\n",
        "### 6.1.6 Seleção de Variávies por Subset (Wrapper Method)\n",
        "A Seleção por Subconjuntos é um processo iterativo para determinar quais variáveis em um conjunto de dados são mais relevantes para o modelo de aprendizado. A ideia é **examinar todas as combinações possíveis de recursos e selecionar a combinação que resulta no melhor desempenho do modelo**.\n",
        "\n",
        "Em contraste com os outros dois métodos mencionados anteriormente (seleção univariada e seleção por importância), a **seleção por subconjuntos não depende da correlação entre as variáveis e a variável de resposta**, ou do nível de importância atribuído pelo modelo de aprendizado.\n",
        "\n",
        "Aqui estão os passos que normalmente são seguidos no processo de seleção por subconjuntos:\n",
        "\n",
        "- **Seleção Inicial:** Primeiramente, uma única variável é escolhida aleatoriamente do conjunto de dados. Juntamente com a variável alvo (ou variável de resposta), essa variável selecionada é usada para treinar um algoritmo de aprendizado de máquina - como Random Forest ou Gradient Boosting. O desempenho deste modelo inicial é calculado, comumente em termos de acurácia ou erro.\n",
        "\n",
        "- **Adição e Avaliação de Variáveis:** A seguir, uma nova variável é adicionada aleatoriamente ao modelo. O algoritmo é treinado novamente e o desempenho do modelo é recalculado. Se o desempenho do modelo melhora com a adição desta nova variável (por exemplo, a acurácia aumenta de 62% para 65%), essa variável é mantida no modelo. Esta variável adicionada é considerada informativa, pois traz nova luz ao fenômeno em estudo.\n",
        "\n",
        "- **Remoção de Variáveis Não-Informativas:** Se a adição de uma nova variável não melhora o desempenho do modelo (por exemplo, a acurácia permanece em 65%), a variável é removida. Essa variável é considerada não informativa, já que não contribui para a compreensão do fenômeno que está sendo modelado.\n",
        "\n",
        "- **Iteração:** O processo de adição de variáveis, treinamento do modelo e avaliação do desempenho é repetido até que todas as variáveis do conjunto de dados original tenham sido testadas.\n",
        "\n",
        "- **Resultado Final:** Ao final deste processo, o resultado é um subconjunto de variáveis do conjunto de dados original - apenas as variáveis que são mais relevantes para o fenômeno em estudo.\n"
      ],
      "metadata": {
        "id": "cl2DVreakGBp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6.2 Seleção de Variáveis com Algoritmo Boruta\n",
        "O Boruta é um algoritmo utilizado na seleção de variáveis importantes em um conjunto de dados, **baseado no algoritmo Random Forest**. Este método se destaca pela forma como trata a seleção de características, usando o conceito de \"variáveis shadow\" (ou variáveis sombra).\n",
        "\n",
        "Em primeiro lugar, o algoritmo **seleciona duas variáveis aleatórias** de seu conjunto de dados original, que serão nomeadas de V1 e V2. Em seguida, cria-se **cópias dessas variáveis, chamadas de \"shadow\"**, nas quais as linhas são embaralhadas. Esta etapa de embaralhamento é feita para eliminar qualquer correlação entre as variáveis shadow e as originais.\n",
        "\n",
        "Após essa etapa, o novo conjunto de dados, contendo as variáveis originais e as shadow, é usado para treinar um modelo, geralmente uma Random Forest. Uma vez treinado o modelo, calcula-se a importância de cada uma das variáveis, tanto originais quanto shadow.\n",
        "\n",
        "A partir daqui, o algoritmo Boruta foca-se nas variáveis shadow. Ele **determina qual variável shadow tem a maior importância e compara essa importância com cada uma das variáveis originais**. Se a importância da variável original for maior do que a variável shadow mais importante, é atribuído o valor 1 a essa variável em uma tabela. Caso contrário, atribui-se o valor 0.\n",
        "\n",
        "Este processo é repetido várias vezes, com diferentes embaralhamentos das variáveis shadow, resultando em uma tabela que contabiliza a quantidade de vezes que cada variável original superou a importância da variável shadow mais importante.\n",
        "\n",
        "Uma vez obtida a tabela, é possível **aplicar uma distribuição binomial para calcular o p-valor de cada variável original**. O p-valor é um conceito estatístico usado para determinar se uma hipótese é aceita ou rejeitada. Neste caso, ele ajuda a determinar se uma variável é relevante ou não.\n",
        "\n",
        "Para finalizar o processo, é estabelecido um limite para o p-valor. Se o p-valor de uma variável for menor do que esse limite, a variável é considerada importante. Caso contrário, é descartada.\n",
        "\n",
        "Este ciclo é repetido para todas as variáveis do conjunto de dados. No final, o resultado é um conjunto de dados reduzido contendo apenas as variáveis consideradas importantes pelo algoritmo Boruta."
      ],
      "metadata": {
        "id": "qO3bliDbzgTM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.2.1. Split DataFrame into Training and Test Dataset\n",
        "Nesta etapa do projeto de ciência de dados, abordaremos a implementação do algoritmo Boruta e a preparação do DataFrame para esse processo.\n",
        "\n",
        "Inicialmente, é importante compreender que precisamos separar o DataFrame original em duas partes. Antes de proceder com essa divisão, vamos excluir algumas variáveis. O motivo desta exclusão está na etapa de seleção de recursos (feature selection), onde criamos novas variáveis a partir das originais. Para evitar redundâncias, é necessário remover as variáveis originais que deram origem às novas.\n",
        "\n",
        "Por exemplo, a variável \"week_of_year\" foi usada para gerar \"week_of_year_sin' e 'week_of_yer_cos\". Neste caso, a variável original \"week_of_year\" deve ser eliminada, pois suas informações já estão representadas nas novas variáveis.\n",
        "\n",
        "Para realizar essa tarefa, criamos uma lista chamada \"cols_drop\" para anotar as variáveis que precisam ser excluídas.\n",
        "\n",
        "Depois de identificar essas variáveis, utilizamos o método 'drop' do pandas para excluí-las do DataFrame. Fazemos isso ao redefinir o DataFrame (neste caso, 'df6') para conter apenas as variáveis que não foram excluídas."
      ],
      "metadata": {
        "id": "TEpazPtH3D6M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cols_drop = ['week_of_year', 'day', 'month', 'day_of_week', 'promo_since', 'competition_since', 'year_week']\n",
        "df6 = df6.drop(cols_drop, axis =1)"
      ],
      "metadata": {
        "id": "TtvGuwjEDv74"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O argumento 'axis=1' no método drop significa que queremos excluir colunas. Quando o drop é executado, a coluna inteira, com todas as suas linhas, é excluída.\n",
        "\n",
        "Em suma, o preparo do DataFrame envolve a remoção de variáveis originais que foram usadas para derivar novas variáveis, garantindo assim a limpeza e eficácia dos dados ao implementar o algoritmo Boruta."
      ],
      "metadata": {
        "id": "iP7RNjgV4fh4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### • Split Dataset"
      ],
      "metadata": {
        "id": "7ZRuHVAj7zqw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nesta etapa, vamos discutir como dividir nosso conjunto de dados em conjuntos de treinamento e teste.\n",
        "\n",
        "O objetivo é treinar o modelo com uma parte do conjunto de dados e então usar os dados de teste para medir a precisão do modelo. Para um problema de séries temporais, como o que estamos lidando, é essencial considerar a ordem temporal dos dados ao realizar essa divisão.\n",
        "\n",
        "Não podemos selecionar aleatoriamente as linhas que pertencerão ao conjunto de treinamento e de teste, pois isso poderia envolver a mistura de dados futuros e passados em ambos os conjuntos. Esta prática pode resultar em \"overfitting\", onde o modelo simplesmente memoriza os dados de treinamento em vez de aprender com eles.\n",
        "\n",
        "No nosso caso, estamos lidando com dados de vendas diárias por loja e queremos prever as próximas seis semanas de vendas. Assim, dividiremos nosso conjunto de dados de forma que as últimas seis semanas de vendas sejam usadas como conjunto de teste e o restante seja usado como conjunto de treinamento.\n",
        "\n",
        "Para realizar isso, primeiro agrupamos nossos dados por loja e calculamos a data mínima e máxima de cada venda. Isso nos ajudará a entender o intervalo de tempo do nosso conjunto de dados."
      ],
      "metadata": {
        "id": "RWKxL9_37q3c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df6[['store', 'date']].groupby('store').max().reset_index()['date'][0] - datetime.timedelta(days = 6*7)"
      ],
      "metadata": {
        "id": "D4qLxw9b503z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Depois, identificamos a data que é seis semanas antes da data máxima de venda usando o método \"timedelta\" da classe \"datetime\". Esta data será o ponto de corte entre nossos dados de treinamento e teste.\n",
        "\n",
        "Por exemplo, se a data máxima é 31/07/2015, subtraímos seis semanas (ou 42 dias) para obter a data de 19/06/2015. Portanto, usaremos os dados do primeiro dia de venda até 18/06/2015 para treinamento e os dados de 19/06/2015 até a última data para teste."
      ],
      "metadata": {
        "id": "3h6-3Rs17apF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# training dataset\n",
        "X_train = df6[df6['date'] < '2015-06-19']\n",
        "y_train = X_train['sales']\n",
        "\n",
        "# test dataset\n",
        "X_test = df6[df6['date'] >=  '2015-06-19']\n",
        "y_test = X_test['sales']"
      ],
      "metadata": {
        "id": "U9B4gs4f6K7J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finalmente, verificamos se nossa divisão de dados está correta, imprimindo as datas mínimas e máximas de ambos os conjuntos de dados de treinamento e teste. Isso deve confirmar que a data máxima do conjunto de treinamento é um dia antes da data mínima do conjunto de teste e a última data de venda é a data máxima do conjunto de teste. Isso garante que temos um intervalo contínuo de datas e um método de divisão de dados que leva em consideração a natureza temporal dos dados."
      ],
      "metadata": {
        "id": "d1BwBhK38h2y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Training Min Date: {}'.format(X_train['date'].min()))\n",
        "print('Training Max Date: {}'.format(X_train['date'].max()))\n",
        "\n",
        "print('\\nTest Min Date: {}'.format(X_test['date'].min()))\n",
        "print('Test Max Date: {}'.format(X_test['date'].max()))"
      ],
      "metadata": {
        "id": "YQtIkeYb8hUD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6.3 Boruta as Feature Selector\n",
        "No que diz respeito à divisão de dados para treinamento e teste, já concluímos essa parte. Agora, o que precisamos fazer é implementar o Boruta para seleção de características (ou features).\n",
        "\n",
        "A classe BorutaPy no Python é usada para implementar a seleção de atributos. Esta classe possui vários argumentos, o primeiro dos quais é o modelo que será utilizado para a seleção de atributos. Neste caso, utilizaremos o modelo RandomForestRegressor.\n",
        "\n",
        "Outro argumento importante é o número de estimadores. Neste caso, optamos por uma abordagem em que deixamos o algoritmo escolher o melhor número de árvores para a ramificação em 'auto'. Além disso, definimos a saída do log de verbosidade como 2 para que possamos monitorar o progresso do algoritmo, já que este pode demorar algum tempo.\n",
        "\n",
        "Uma consideração importante é a definição do estado aleatório, ou 'random state'. O Boruta seleciona as variáveis de forma aleatória para gerar o modelo. Para garantir que o algoritmo comece do mesmo ponto sempre que for executado, definimos o estado aleatório como 42.\n",
        "\n",
        "Para treinar o modelo, utilizamos o método 'fit'. Neste ponto, é crucial lembrar que este método não aceita dataframes como entrada. Portanto, teremos que transformar nossos dados em um vetor de números.\n",
        "\n",
        "Abaixo, primeiro importamos as classes necessárias. Em seguida, instanciamos o RandomForestRegressor e o Boruta. No processo de preparação dos dados para o Boruta, removemos as colunas 'date' e 'sales' do conjunto de treinamento (X_train) e transformamos o restante em um vetor de valores. Da mesma forma, transformamos o vetor alvo de treinamento (y_train) em um vetor de valores. Finalmente, ajustamos o Boruta com o conjunto de treinamento preparado.\n"
      ],
      "metadata": {
        "id": "Or1QX_J_8l8D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#from boruta import BorutaPy\n",
        "#from sklearn.ensemble import RandomForestRegressor\n",
        "\n",
        "# Definindo RandomForestRegressor\n",
        "rf = RandomForestRegressor(n_jobs=-1)\n",
        "\n",
        "# Definindo Boruta\n",
        "boruta = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=42)\n",
        "\n",
        "# Preparando os conjuntos de treino e teste para o Boruta\n",
        "X_train_n = X_train.drop(['date', 'sales'], axis=1).values\n",
        "y_train_n = y_train.values.ravel()\n",
        "\n",
        "# Treinando o modelo Boruta\n",
        "boruta.fit(X_train_n, y_train_n)"
      ],
      "metadata": {
        "id": "iZW30SIa99Oq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Interpretação Seleção de Variáveis com Boruta\n",
        "Analisando os resultados do algoritmo Boruta para seleção de recursos, observamos que a ferramenta gera várias informações durante sua execução. Estes são organizados em diferentes categorias, nomeadamente 'Iteration', 'Confirmed', 'Tentative' e 'Rejected'.\n",
        "\n",
        "'Iteration' é uma representação da iteração atual do algoritmo de um total de 100. Em nosso projeto, o Boruta passou por nove iterações. Este é um valor padrão, já que Boruta executa um máximo de 100 iterações para decidir sobre cada variável. Se atingir a centésima iteração e não puder tomar uma decisão, o algoritmo para.\n",
        "\n",
        "'Confirmed' indica o número de variáveis que Boruta confirmou como sendo relevantes para o modelo. Neste caso, o algoritmo confirmou 18 variáveis como importantes ou relevantes.\n",
        "\n",
        "'Tentative' se refere às variáveis sobre as quais Boruta tem dúvidas. Neste estágio, o algoritmo não conseguiu classificar estas variáveis como irrelevantes ou não.\n",
        "\n",
        "Por fim, 'Rejected' são as variáveis que Boruta rejeitou e considerou não serem relevantes para o modelo. O algoritmo rejeitou nove variáveis em nosso projeto.\n",
        "\n",
        "Portanto, através da utilização do algoritmo Boruta, fomos capazes de identificar e selecionar as variáveis mais relevantes para o nosso modelo. Também pudemos descartar as variáveis que não contribuem significativamente para a modelagem dos dados, melhorando assim a eficiência e precisão do nosso modelo.\n"
      ],
      "metadata": {
        "id": "sg97-89HBduT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from numpy import setdiff1d\n",
        "\n",
        "# Cria uma lista com as colunas selecionadas por Boruta\n",
        "cols_selected = boruta.support_.tolist()\n",
        "\n",
        "# Melhores features\n",
        "X_train_fs = X_train.drop(['date', 'sales'], axis = 1)\n",
        "cols_selected_boruta = X_train_fs.columns[cols_selected].to_list()\n",
        "\n",
        "# Colunas não selecionadas pelo Boruta\n",
        "cols_not_selected_boruta = list(setdiff1d(X_train_fs.columns, cols_selected_boruta))"
      ],
      "metadata": {
        "id": "0-2gxQJZBdgy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O método Boruta seleciona e classifica variáveis com base em sua relevância, atribuindo a cada variável um ranking. Para identificar as variáveis selecionadas, usamos o atributo support_ do Boruta, que retorna um vetor booleano indicando quais variáveis foram selecionadas.\n",
        "\n",
        "Vamos criar uma lista chamada cols_selected que irá armazenar os índices das colunas que foram selecionadas pelo Boruta. Em seguida, para facilitar a visualização e interpretação dos resultados, vamos transformar esses índices em nomes de colunas.\n",
        "\n",
        "Lembre-se de que nosso conjunto de dados ainda inclui as colunas 'date' e 'sales', que precisam ser removidas antes de continuar com a análise. Como agora estamos trabalhando com índices, não nomes de colunas, vamos criar um novo conjunto de dados chamado X_train_fs, que será uma cópia do X_train original, mas sem as colunas 'date' e 'sales'.\n",
        "\n",
        "Agora podemos criar um novo conjunto de dados chamado cols_selected_boruta, que conterá apenas as colunas selecionadas pelo Boruta em X_train_fs.\n",
        "\n",
        "Além disso, é interessante saber quais colunas não foram selecionadas pelo Boruta. Para isso, precisamos comparar as colunas em X_train_fs com as colunas em cols_selected_boruta. Vamos usar a função np.setdiff1d do numpy para isso, que retorna a diferença entre dois arrays. O resultado será armazenado na variável cols_not_selected_boruta."
      ],
      "metadata": {
        "id": "GG-C5JTpD0fn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Colunas Selecionadas por Boruta\n",
        "Podemos ver quais variáveis foram consideradas significativas pelo algoritmo."
      ],
      "metadata": {
        "id": "mHf2kdssHDXo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cols_selected_boruta"
      ],
      "metadata": {
        "id": "UomzFTLsAo98"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Colunas Descartadas por Boruta\n",
        "Por outro lado, Boruta descartou algumas variáveis, considerando-as irrelevantes para o modelo."
      ],
      "metadata": {
        "id": "DsRyq_fWHSk9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cols_not_selected_boruta"
      ],
      "metadata": {
        "id": "GSgfX7qlHW2C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Conclusão Feature Selection com Boruta\n",
        "Ao final da fase de seleção de variáveis, devemos fazer uma análise aprofundada dos resultados obtidos com o algoritmo Boruta. Este é o momento de lembrar da análise exploratória de dados realizada anteriormente, onde avaliamos diversas hipóteses e criamos uma tabela para verificar quais delas foram confirmadas, quais foram rejeitadas e qual a relevância de cada uma para o nosso modelo.\n",
        "\n",
        "O próximo passo é comparar nossas observações com o que o Boruta nos sugeriu como relevante para o modelo. Essa comparação nos permite ter uma visão mais clara e fazer um \"match\" desses resultados.\n",
        "\n",
        "Para exemplificar, podemos observar as hipóteses de alta importância (9 a 12). Cada uma dessas hipóteses está ligada a uma variável central. A hipótese 9, por exemplo, afirma que as vendas das lojas deveriam aumentar ao longo dos anos. No entanto, o algoritmo Boruta considerou 'Year' como não relevante. Isso é uma contradição que deve ser avaliada pelo cientista de dados. Lembre-se, você pode fazer a escolha de seguir ou não a sugestão do algoritmo. Uma estratégia sugerida é, na primeira iteração, seguir as indicações do Boruta, e posteriormente, em ciclos subsequentes do processo de análise (CRISP), adicionar variáveis que possam aumentar a precisão do modelo.\n",
        "\n",
        "Essa estratégia também pode ser aplicada para as outras hipóteses. Por exemplo, a hipótese 10 sugere que as lojas deveriam vender mais no segundo semestre do ano, estando ligada à variável 'Month'. O Boruta considerou 'month_cos' como relevante e 'month_sin' como não relevante, mas podemos optar por incluir ambas em nossa análise.\n",
        "\n",
        "Da mesma forma, a hipótese 11, que sugere que as lojas deveriam vender mais depois do dia 10 de cada mês, está ligada à variável 'Day'. O Boruta considerou tanto 'day_sin' como 'day_cos' como relevantes, o que confirma nossa hipótese.\n",
        "\n",
        "Em resumo, é importante realizar esse processo de verificação e análise entre as sugestões do algoritmo e as hipóteses levantadas pela análise exploratória de dados."
      ],
      "metadata": {
        "id": "Dsl-AVVkJFCn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6.4 Manual Feature Selection"
      ],
      "metadata": {
        "id": "i5DR_nf4I_ei"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cols_selected_boruta = [\n",
        "    'store',\n",
        "    'promo',\n",
        "    'store_type',\n",
        "    'competition_distance',\n",
        "    'competition_open_since_month',\n",
        "    'competition_open_since_year',\n",
        "    'promo2',\n",
        "    'promo2_since_week',\n",
        "    'promo2_since_year',\n",
        "    'competition_time_month',\n",
        "    'promo_time_week',\n",
        "    'day_of_week_sin',\n",
        "    'day_of_week_cos',\n",
        "    'month_sin'\n",
        "    'month_cos',\n",
        "    'day_sin',\n",
        "    'day_cos',\n",
        "    'week_of_year_sin'\n",
        "    'week_of_year_cos']\n",
        "\n",
        "# columns to add\n",
        "# feat_to_add = ['date', 'sales']\n",
        "\n",
        "# final features\n",
        "#cols_selected_boruta_full = cols_selected_boruta.copy()\n",
        "#cols_selected_boruta_full"
      ],
      "metadata": {
        "id": "tng1fx1eJCko"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## 7. Machine Learning\n",
        "O campo da ciência de dados é vasto e complexo. Entender o papel dos algoritmos de aprendizado de máquina (Machine Learning) é fundamental para aplicá-los corretamente em suas respectivas áreas. Um algoritmo de aprendizado de máquina é capaz de aprender o comportamento de um fenômeno - neste caso, vendas - baseado nas variáveis disponíveis, para depois usar esse aprendizado para generalizar para outros exemplos. Isso é semelhante à maneira como os humanos aprendem, associando características a objetos específicos para facilitar o reconhecimento futuro.\n",
        "\n",
        "Por exemplo, ao ver um computador, um indivíduo aprende a associar determinadas características - forma quadrada, presença de um teclado, cores preto e cinza - a esse objeto. Quando confrontado com um objeto similar no futuro, o cérebro humano rapidamente identifica-o como um computador devido a essas características. Da mesma forma, algoritmos de aprendizado de máquina são treinados para identificar padrões e, quando apresentados a um novo objeto, utilizam o aprendizado obtido para classificá-lo ou prever seu comportamento.\n",
        "\n",
        "Embora os algoritmos de aprendizado de máquina sejam sofisticados, métodos mais simples como cálculo de médias ainda são amplamente utilizados em muitas empresas. A média, que é a soma de todos os dados dividida pela quantidade de dados, serve como um resumo útil da variância dos dados. É importante salientar que a média é um modelo simples, mas que tem contribuído significativamente para várias realizações no mundo dos negócios.\n",
        "\n",
        "Os algoritmos de aprendizado de máquina podem realizar diversas tarefas. Entre elas, a classificação é um processo supervisionado comum em que o algoritmo aprende a mapear as entradas para as saídas corretas, semelhante ao papel de um supervisor ou inspetor que estabelece regras e orientações. No contexto de machine learning, as características ou medidas de um objeto (altura, largura, comprimento, etc.) são usadas para identificá-lo. Um exemplo disso seria identificar um ônibus, um carro ou uma van com base em suas medidas.\n",
        "\n",
        "Nesse processo, vários exemplos de cada veículo seriam passados para o algoritmo durante o treinamento, permitindo que ele aprenda a correlacionar as entradas com a saída correta. Quando apresentado a um novo conjunto de medidas, o algoritmo compara essas medidas com as do treinamento para classificar o veículo corretamente. É importante notar que o algoritmo só pode classificar objetos que foram incluídos em seu treinamento.\n",
        "\n",
        "A classificação tem uma ampla gama de aplicações, como diagnóstico de doenças com base em sintomas, identificação de objetos com base em suas características, detecção de fraudes com base em comportamentos suspeitos, e muito mais. Além disso, não se limita apenas à classificação de medidas manuais, mas também pode lidar com imagens e outros tipos de dados.\n",
        "\n",
        "### • Aprendizado Supervisionado\n",
        "Em ciência de dados, existem diferentes tipos de problemas que podem ser abordados por meio de técnicas de aprendizado supervisionado. Neste artigo, discutiremos três dessas categorias: Classificação, Regressão e Séries Temporais.\n",
        "\n",
        "1. Classificação\n",
        "\n",
        "A classificação é uma tarefa que envolve a atribuição de uma classe a um exemplo de entrada com base em seus atributos. Por exemplo, se tivermos um conjunto de dados de veículos com informações sobre suas características (ou 'features') e os preços de compra, podemos usar um modelo de classificação para aprender a relação entre esses atributos e se um veículo é um carro, uma van ou um ônibus. No entanto, a classificação se limita a prever categorias discretas, ou seja, classes finitas.\n",
        "\n",
        "2. Regressão\n",
        "\n",
        "A regressão, por outro lado, é usada quando a variável de resposta é contínua, ou seja, pode assumir infinitos valores. No mesmo exemplo do conjunto de dados de veículos, em vez de prever a classe do veículo, queremos prever o preço de compra do veículo. Nesse cenário, o modelo aprenderá a mapear as características do veículo ao seu preço. Este tipo de problema é chamado de regressão.\n",
        "\n",
        "3. Séries Temporais\n",
        "\n",
        "A terceira categoria é a análise de séries temporais, que se concentra na modelagem de dados que são coletados ao longo do tempo. Este método é comumente usado para fazer previsões futuras. Suponha que estamos interessados ​​em monitorar o desgaste do pneu de uma van ao longo do tempo. Podemos medir a espessura do pneu diariamente e usar esses dados para treinar um modelo de série temporal. Com base nesses dados históricos, o modelo pode prever o dia em que o desgaste do pneu atingirá o limite e precisará ser substituído.\n",
        "\n",
        "Portanto, dependendo do problema em mãos e do tipo de variável de resposta, podemos escolher entre classificação, regressão e séries temporais. Esses são os três tipos principais de problemas que podem ser abordados no âmbito do aprendizado supervisionado. No próximo artigo, discutiremos os problemas de aprendizado não supervisionado e semi-supervisionado.\n",
        "\n",
        "### • Aprendizado Não Supervisionado\n",
        "No campo da Ciência de Dados, temos duas abordagens principais para o aprendizado de máquinas: aprendizado supervisionado e aprendizado não supervisionado.\n",
        "\n",
        "No aprendizado supervisionado, o modelo é treinado em um conjunto de dados rotulados. No entanto, no aprendizado não supervisionado, como o nome sugere, não há supervisão direta. Em outras palavras, não há rótulos pré-definidos para o conjunto de dados e, em vez disso, o modelo tenta identificar padrões e relações por si só.\n",
        "\n",
        "Para compreender melhor essa diferença, considere o seguinte exemplo: imagine que você tenha uma variedade de frutas em casa. Sem alguém te orientando, você organiza essas frutas na fruteira de acordo com alguns critérios que você escolhe. Talvez você agrupe as bananas juntas, porque são amarelas e curvadas. As uvas podem ser agrupadas porque são pequenas e ficam em cachos. Laranjas e limões podem ser agrupados juntos porque são redondos e têm um galho em um extremo. O critério utilizado para agrupar essas frutas é semelhante às \"variáveis\" ou \"características\" que um algoritmo de aprendizado não supervisionado usaria para agrupar dados semelhantes.\n",
        "\n",
        "Um exemplo ainda mais ilustrativo pode ser encontrado ao considerar um conjunto de silhuetas de animais. Se você não sabe o nome desses animais, pode agrupá-los com base em características que parecem similares para você. Talvez você agrupe alguns animais porque têm quatro patas, um rabo fino e um corpo mais cilíndrico. Outros animais podem ser agrupados porque, embora também tenham quatro patas, têm um rabo pontudo, orelhas pontudas e um focinho mais longo. Esses grupos são semelhantes às \"clusters\" que um algoritmo de aprendizado não supervisionado pode identificar.\n",
        "\n",
        "Até agora, discutimos problemas de aprendizado supervisionado, que podem ser resolvidos através de classificação, regressão e análise de séries temporais. Também discutimos problemas não supervisionados, onde, sem uma \"resposta correta\", o objetivo é agrupar os objetos com base na semelhança de suas características. Esses podem ser resolvidos por meio de técnicas de clustering ou de agrupamento. Este é um breve resumo das principais diferenças entre as tarefas supervisionadas e não supervisionadas em aprendizado de máquina.\n",
        "\n",
        "### • Aprendizado Semi Supervisionado\n",
        "O conceito de aprendizado semi-supervisionado é um avanço empolgante na ciência de dados e na aprendizagem de máquinas. Este método combina elementos de aprendizado supervisionado e não supervisionado para otimizar a eficiência do modelo. Acredita-se que a abordagem semi-supervisionada tem o potencial de revolucionar a maneira como aplicamos o aprendizado de máquinas atualmente.\n",
        "\n",
        "Em métodos tradicionais de aprendizado supervisionado, o modelo é treinado com um conjunto de dados rotulados e então tenta generalizar o aprendizado a partir deste conjunto. No entanto, em um modelo semi-supervisionado, além do aprendizado com base nos dados rotulados, o modelo também é capaz de aprender durante a execução, um processo que chamamos de aprendizado on-the-fly.\n",
        "\n",
        "O aprendizado semi-supervisionado é implementado através de um sistema de ação-recompensa. Em termos simples, sempre que uma ação é realizada pelo modelo, ele recebe uma recompensa que informa o quão bem ele realizou a tarefa. Dentro desse sistema, temos duas entidades: o agente (o modelo de aprendizado de máquina) e o ambiente. O agente realiza ações sobre o ambiente, que em troca fornece uma recompensa ao agente.\n",
        "\n",
        "Este ciclo de ação-recompensa permite que o agente explore várias ações possíveis e avalie suas consequências, que podem ser positivas ou negativas. Por exemplo, se uma ação leva a uma recompensa positiva, o agente pode aprender a repetir essa ação em circunstâncias semelhantes. Da mesma forma, se uma ação leva a uma recompensa negativa, o agente aprende a evitar essa ação no futuro.\n",
        "\n",
        "A plataforma de streaming Netflix, por exemplo, emprega uma equipe de designers criativos que criam múltiplas capas para uma mesma série, como \"Stranger Things\". Estas capas são então avaliadas pela equipe de dados, que determina qual delas é a mais atrativa para os usuários, com o objetivo final de incentivar mais visualizações.\n",
        "\n",
        "Esse tipo de problema pode ser resolvido com aprendizado supervisionado, onde se podem extrair métricas das capas para avaliar qual delas funciona melhor. No entanto, o cenário se assemelha mais a um problema de aprendizado semi-supervisionado. Para entender isso, imagine-se navegando na Netflix. Existem várias capas para várias séries, e cada uma delas foi preparada pela equipe criativa.\n",
        "\n",
        "Nesse caso, a equipe de dados passa por duas fases, chamadas de \"exploração\" e \"exploração com base no aprendizado\". Na primeira fase, as capas são apresentadas aleatoriamente aos usuários, e os feedbacks são coletados. Na segunda fase, com base nos dados coletados, as capas que não levaram a visualizações são eliminadas.\n",
        "\n",
        "Por exemplo, se uma capa específica levou um usuário a assistir à série, essa capa recebe uma recompensa positiva. Se uma capa não levou à visualização, ela recebe uma recompensa negativa. Ao longo do tempo, a equipe de dados começa a perceber que certas capas sempre levam a visualizações, aumentando suas recompensas, enquanto outras são eliminadas. Ao final deste processo, a capa com a maior recompensa é a que será exibida para a maioria dos usuários.\n",
        "\n",
        "Esse processo pode ser aplicado a uma variedade de situações, como testes A/B em sites, onde se deseja descobrir qual botão leva a mais cliques, por exemplo. O aprendizado semi-supervisionado e o sistema de recompensas se mostram eficazes na resolução de tais problemas.\n",
        "\n",
        "Em um nível mais amplo, o aprendizado de máquina pode ser usado para resolver uma variedade de problemas. O aprendizado supervisionado pode ser usado para tarefas de classificação, regressão e séries temporais. O aprendizado não supervisionado é útil para agrupamento ou \"clustering\". O aprendizado semi-supervisionado, que é um tipo de aprendizado por reforço, é um terceiro tipo de problema que a aprendizagem de máquina pode resolver.\n",
        "\n",
        "Deep learning, que tem se tornado bastante popular, é um tipo de aprendizado supervisionado usado principalmente para o reconhecimento de imagens. As redes neurais profundas (\"deep neural networks\"), que são a base do deep learning, têm muitas camadas ocultas e cada camada contém vários neurônios. Essas redes conseguem extrair características complexas das imagens à medida que a informação passa por cada camada, sendo portanto altamente eficazes para essa tarefa.\n",
        "\n",
        "Portanto, a aprendizagem de máquina tem uma ampla gama de aplicações e pode resolver uma variedade de problemas, desde a classificação simples até o reconhecimento de imagens mais complexo."
      ],
      "metadata": {
        "id": "f24zeXE2j06t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "# 7. Algoritmos de Machine Learning\n",
        "Neste vídeo, vou mostrar cinco implementações dos melhores modelos de aprendizado de máquina, de acordo com minha opinião. Vou compartilhar a estratégia que uso para fazer o modelo funcionar e vou explicar por que escolho cada um dos modelos e por que sua funcionalidade é importante na minha estratégia.\n",
        "\n",
        "O primeiro modelo que implementaremos é o modelo de média, também conhecido como modelo \"average\". Você pode nunca ter ouvido falar sobre isso, mas eu lhe garanto que é um dos modelos que você mais usa no dia a dia. O modelo de média funciona colocando os dados na entrada e ele sempre vai prever a média. Por exemplo, se você tem uma loja e quer prever vendas futuras, este modelo sempre dará a média das vendas passadas.\n",
        "\n",
        "Você pode pensar que isso é muito simples, mas o objetivo do modelo de média não é resolver completamente o seu problema de aprendizado de máquina ou de previsão de vendas. O principal papel do modelo de média é servir como uma base comparativa para a performance dos outros modelos. Se a performance de um modelo de aprendizado de máquina é melhor que o modelo de média, então há um aprendizado real. Mas se um modelo de aprendizado de máquina tem uma performance pior do que a média, a média resolve o seu problema igualmente bem.\n",
        "\n",
        "O próximo modelo que implementaremos neste projeto é o de regressão linear e de regressão linear regularizada. Geralmente, o modelo de regressão linear regularizada tem um desempenho um pouco melhor que a regressão linear. Eu implemento esses dois modelos primeiro porque sigo o princípio de Occam's Razor, que sugere que devemos dar preferência a modelos mais simples quando possível.\n",
        "\n",
        "Depois disso, implementaremos os modelos de \"Random Forest\" e \"Gradient Boosting\", ambos baseados em árvores e adaptados para regressões. Eles costumam ter um desempenho melhor e se tornaram conhecidos porque muitas pessoas começaram a vencer competições de Kaggle com eles.\n",
        "\n",
        "Você pode estar se perguntando onde estão os modelos de redes neurais, Deep Learning, CNN e LSTM. Estes são modelos complexos e exigem mais tempo para serem implementados. Estamos seguindo um plano de projeto cíclico e nosso objetivo é completar o ciclo o mais rápido possível para entregar a primeira versão da nossa solução. Em um projeto real, já teríamos passado de quatro a seis semanas neste ponto e haveria uma expectativa crescente por resultados."
      ],
      "metadata": {
        "id": "lQEu-muHkt_3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Implementing Linear Models\n",
        "A primeira coisa que faremos é coletar as variáveis que selecionamos com o auxílio do Boruta. Lembre-se, nós tínhamos separado o X_train e o X_test. Vou capturar apenas as colunas que o Boruta selecionou, que são as \"cols_selected_boruta\", e vou armazená-las numa nova variável também chamada x_train, mas com o \"x\" minúsculo.\n",
        "\n",
        "Vou fazer o mesmo para o teste, de maneira que o x_test será o X_test, mas contendo apenas as colunas selecionadas pelo Boruta. Depois, vou fazer algo aqui: vou retornar àquele script anterior e não vou adicionar \"date\" e \"sales\" nesse primeiro momento de treinamento dos modelos. Vou reservar isso para mais tarde.\n",
        "\n",
        "Agora temos todas as colunas mais relevantes de acordo com o Boruta e também nossa própria experiência. Então, vamos começar a partir daqui."
      ],
      "metadata": {
        "id": "irTwRtRixtee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Seleciona as colunas mais relevantes para o treinamento, conforme definido pelo Boruta\n",
        "x_train = X_train[cols_selected_boruta]\n",
        "x_test  = X_test[cols_selected_boruta]\n",
        "\n",
        "# Seleciona as colunas mais relevantes para o teste, conforme definido pelo Boruta\n",
        "x_training = X_train[cols_selected_boruta_full]"
      ],
      "metadata": {
        "id": "5OVA6pMZj4Je"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.1 Average Model\n",
        "Estamos construindo um modelo para prever a média de vendas de diferentes lojas. Começamos fazendo uma cópia do conjunto de dados de teste 'X_test' e armazenamos essa cópia na variável 'aux1'. Na variável 'aux1', criamos uma nova coluna 'sales', que armazena as vendas reais (ou seja, a variável alvo) do conjunto de teste.\n",
        "\n",
        "Em seguida, o objetivo é calcular a média de vendas para cada loja. Fazemos isso agrupando os dados por loja e, em seguida, aplicamos a função média à coluna 'sales'. O resultado desse agrupamento e cálculo da média é armazenado na variável 'aux2'.\n",
        "\n",
        "O próximo passo é anexar as médias de vendas calculadas de volta ao conjunto de dados original 'aux1'. Isso é feito usando a função de mesclagem do pandas, onde 'store' é usada como chave de junção. Isso é importante para que possamos comparar diretamente a média de vendas calculada com as vendas reais para cada loja.\n",
        "\n",
        "Agora que temos as vendas reais e as médias de vendas calculadas, podemos calcular a performance do nosso modelo. Para isso, definimos uma função chamada 'ml_error'. Essa função recebe três argumentos: o nome do modelo, as vendas reais e as previsões (ou seja, as médias de vendas calculadas).\n",
        "\n",
        "A função 'ml_error' calcula três medidas diferentes de erro. O primeiro é o erro absoluto médio (MAE), que é a média das diferenças absolutas entre as previsões e os valores reais. O segundo é o erro percentual absoluto médio (MAPE), que é a média das diferenças percentuais absolutas entre as previsões e os valores reais. E o terceiro é a raiz do erro quadrático médio (RMSE), que é a raiz quadrada da média dos erros quadrados.\n",
        "\n",
        "É importante notar que, para calcular a performance, precisamos reverter a transformação logarítmica aplicada à variável de resposta. Para isso, usamos a função exponencial.\n",
        "\n",
        "Finalmente, a função 'ml_error' retorna um DataFrame do pandas que armazena o nome do modelo e os três erros calculados."
      ],
      "metadata": {
        "id": "c0rcgi0syFOX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando bibliotecas\n",
        "from sklearn.metrics import mean_absolute_error, mean_squared_error\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# --------------------------------------------------------------------\n",
        "\n",
        "# Definindo a função de erro médio absoluto percentual (MAPE), recebe valor real (y) e predito (yhat).\n",
        "def mean_absolute_percentage_error(y, yhat):\n",
        "    # MAPE é a média dos valores absolutos da (diferença entre o valor real e a previsão) dividido pelo valor real.\n",
        "    return np.mean(np.abs((y - yhat) / y))\n",
        "\n",
        "# --------------------------------------------------------------------\n",
        "\n",
        "# Definindo a função para calcular o erro do modelo\n",
        "def ml_error(model_name, y, yhat):\n",
        "    # Calculando o erro absoluto médio (MAE)\n",
        "    mae = mean_absolute_error(y, yhat)\n",
        "    # Calculculando erro percentual absoluto médio (MAPE) - Qual é a porcentagem de erro do modelo?\n",
        "    mape = mean_absolute_percentage_error(y, yhat)\n",
        "    # Calculando a raiz do erro quadrático médio (RMSE)\n",
        "    rmse = np.sqrt(mean_squared_error(y, yhat))\n",
        "    # Retornando um DataFrame com os erros calculados\n",
        "    return pd.DataFrame({'Model Name': model_name,\n",
        "                         'MAE': mae,\n",
        "                         'MAPE': mape,\n",
        "                         'RMSE': rmse}, index=[0])\n",
        "\n",
        "# --------------------------------------------------------------------\n",
        "\n",
        "# Criando uma cópia dos dados de teste\n",
        "aux1 = x_test.copy()\n",
        "\n",
        "# Incluindo as vendas reais no dataframe aux1\n",
        "aux1['sales'] = y_test.copy()\n",
        "\n",
        "# Calculando a média de vendas para cada loja e armazenando em um novo DataFrame aux2, renomeando sales\n",
        "aux2 = aux1[['store', 'sales']].groupby('store').mean().reset_index().rename(columns={'sales': 'predictions'})\n",
        "\n",
        "# Anexando as previsões (predictions (média) de vendas de cada loja) de volta ao DataFrame aux1\n",
        "aux1 = pd.merge(aux1, aux2, how='left', on='store')\n",
        "\n",
        "# Definindo as predições|previsões (yhat) como a média de vendas calculada anteriormente\n",
        "yhat_baseline = aux1['predictions']\n",
        "\n",
        "# Performance - calculando os erros entre as vendas reais e as previsões.\n",
        "# Como fizemos log(y), agora precisamos fazer exp(y) para reverter a transformação e obter os valores originais\n",
        "baseline_result = ml_error('Average Model', np.expm1(y_test), np.expm1(yhat_baseline))"
      ],
      "metadata": {
        "id": "wpjBtXspy6NA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        " **Obtivemos os seguintes resultados:** a métrica 'MAE' deu um valor de R$ 1.354, o Erro Médio Absoluto Percentual (MAPE) foi de 0.45 (ou seja, 45%) e o Erro Quadrático Médio da Raiz (RMSE) resultou em 1.835."
      ],
      "metadata": {
        "id": "xooXDINa0w79"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.2 Linear Regression Model\n",
        "Em nosso projeto, aplicaremos diferentes modelos de aprendizado de máquina para identificar o que melhor se adequa aos nossos dados. Um desses modelos é o de Regressão Linear. A Regressão Linear é um algoritmo supervisionado que prevê um valor de saída com base em variáveis ​​independentes. É usada para problemas de regressão, tais como a previsão de vendas ou o cálculo de tendências de crescimento.\n",
        "\n",
        "O uso deste modelo envolve três passos principais:\n",
        "\n",
        "### Model\n",
        "No treinamento, utilizamos o método \"fit\" para treinar o nosso modelo. Isso é feito passando os dados de treino (X_train, y_train) para o modelo. O modelo de Regressão Linear aprende a partir desses dados de treino. A linha de código para esta etapa é:"
      ],
      "metadata": {
        "id": "AK32AJOQ1Cy_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LinearRegression\n",
        "lr = LinearRegression().fit(x_train, y_train)"
      ],
      "metadata": {
        "id": "9URL_zQ519B3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Após o treinamento, guardamos o modelo treinado em uma variável chamada 'lr'.\n",
        "\n",
        "### Prediction\n",
        "Com o modelo já treinado, podemos fazer previsões nos dados de teste (X_test) que o modelo ainda não viu. Para isso, usamos o método \"predict\". As previsões são então armazenadas em uma variável chamada 'yhat_lr':"
      ],
      "metadata": {
        "id": "-Np4PKA61_FW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "yhat_lr = lr.predict(x_test)"
      ],
      "metadata": {
        "id": "zmA7iDvw2AdC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Performance\n",
        "Finalmente, avaliamos o desempenho do nosso modelo. Para isso, utilizamos a função 'ml_error' que recebe o nome do modelo ('Linear Regression'), os dados reais (y_test) e as predições (yhat_lr). É importante notar que, caso os valores tenham sido transformados (como no log), eles precisam ser revertidos à sua escala original usando a função exponencial 'np.expml'. O código para essa etapa é:"
      ],
      "metadata": {
        "id": "uKUnpPaB2CzH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lr_result = ml_error('Linear Regression', np.expml(y_test), np.expml(yhat_lr))"
      ],
      "metadata": {
        "id": "-4m1O5YY2Ern"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Obtivemos os seguintes resultados:** a métrica 'MAE' deu um valor de 1867, o Erro Médio Absoluto Percentual (MAPE) foi de 0.29 (ou seja, 29%) e o Erro Quadrático Médio da Raiz (RMSE) resultou em 2671.\n"
      ],
      "metadata": {
        "id": "OvYE0JfQ2G0-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Average Model vs. Linear Model\n",
        "Para o Modelo de Média, o RMSE foi de 1835, enquanto que para o Modelo de Regressão Linear, o RMSE foi de 2671.\n",
        "\n",
        "Notamos que o **RMSE do Modelo de Regressão Linear é significativamente maior que o do Modelo de Média**, o que indica que a Regressão Linear apresentou um erro maior ao prever os dados.\n",
        "\n",
        "Isso sugere duas importantes conclusões:\n",
        "\n",
        "1. **Superioridade do Modelo de Média:** O RMSE menor do Modelo de Média sugere que, neste caso, ele se saiu melhor na previsão dos dados em comparação ao modelo de Regressão Linear.\n",
        "\n",
        "2. **Complexidade dos Dados:** A Regressão Linear, por sua natureza, procura padrões lineares nos dados. No entanto, se o nosso conjunto de dados apresenta um comportamento não linear, isso pode explicar a performance inferior da Regressão Linear. Portanto, nossos dados parecem ter um comportamento complexo e, muito provavelmente, modelos lineares não conseguirão aprender efetivamente esse comportamento.\n",
        "\n",
        "A partir dessas conclusões, é evidente que precisaremos utilizar modelos não lineares para nossas próximas análises. Esses modelos são capazes de capturar a complexidade dos dados e podem fornecer melhores previsões em situações onde os dados não seguem uma relação linear."
      ],
      "metadata": {
        "id": "KsDZ6Zpo2zrW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.3 Linear Regression Regularized Modelo - Lasso\n",
        "Uma técnica eficaz para aprimorar o desempenho dos modelos de regressão é a **regularização**.\n",
        "\n",
        "A regularização ajuda a** prevenir o overfitting ao restringir os pesos** associados às características. Uma forma de regularização é o método Lasso (Least Absolute Shrinkage and Selection Operator), que pode **simplificar modelos de regressão complexos tornando alguns desses pesos zero**, efetivamente excluindo algumas características do modelo.\n",
        "\n",
        "Primeiro, definimos um objeto Lasso com um parâmetro 'alpha' de 0.01. Este parâmetro é muito importante no Lasso, pois **define o grau de regularização que queremos aplicar** aos nossos dados."
      ],
      "metadata": {
        "id": "p5fT8wkv26ZN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LinearRegression, Lasso\n",
        "lrr = Lasso(alpha=0.01).fit(x_train, y_train)"
      ],
      "metadata": {
        "id": "4QovfAkT4IFB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Após o treinamento do modelo, usamos esse objeto para prever os valores da variável de destino em nosso conjunto de dados de teste:"
      ],
      "metadata": {
        "id": "IiwO_Fas4K2o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "yhat_lrr = lrr.predict(x_test)"
      ],
      "metadata": {
        "id": "Elj8yZp04Mba"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A seguir, calculamos o erro do modelo regularizado em comparação com os valores reais usando a função 'ml_error'. Neste caso, 'ml_error' é uma função personalizada que calcula as métricas de erro relevantes para avaliar o desempenho do modelo."
      ],
      "metadata": {
        "id": "9Fx4odAh4O6N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Em resumo, ao aplicar a regularização Lasso ao nosso modelo de regressão linear, conseguimos controlar a complexidade do modelo ajustando o parâmetro 'alpha'. Isso nos ajuda a evitar overfitting e a melhorar o desempenho geral do nosso modelo em novos dados.\n",
        "\n",
        "Se diminuírmos o alpha, ele demorará mais no treinamento, mas retornará resultados melhores."
      ],
      "metadata": {
        "id": "-0z0_zsU4WuI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lrr_result = ml_error('Linear Regression - Lasso', np.expml(y_test), np.expml(yhat_lrr))"
      ],
      "metadata": {
        "id": "YGzfytHj4Qc7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Obtivemos os seguintes resultados:** a métrica 'MAE' deu um valor de 1891 o Erro Médio Absoluto Percentual (MAPE) foi de 0.29 (ou seja, 29%) e o Erro Quadrático Médio da Raiz (RMSE) resultou em 2744.\n"
      ],
      "metadata": {
        "id": "C27sByWhKUuh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### • Avaliação dos 3 Primeiros Modelos\n",
        "Neste estudo, foram explorados três modelos: média, regressão linear e regressão linear regularizada (Lasso).\n",
        "\n",
        "A avaliação, baseada no erro quadrático médio (RMSE), mostrou que o modelo de média, embora mais simples, obteve o menor RMSE de 1.835. A regressão linear alcançou 2.670 e o Lasso, que previne o sobreajuste por meio de penalidades nos coeficientes, registrou 2.744.\n",
        "\n",
        "Embora o modelo de média tenha alcançado menor erro, fica evidente a necessidade de modelos não-lineares, dada a complexidade dos dados. Portanto, a próxima etapa será o teste com modelos não-lineares para uma representação mais precisa do fenômeno em estudo. Esta conclusão é crucial, reforçando que soluções mais simples nem sempre são as mais eficazes para fenômenos complexos."
      ],
      "metadata": {
        "id": "wZ1YXvmg5OHj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "###  • Algoritmos Não Lineares\n",
        "Na etapa anterior, exploramos três modelos lineares de aprendizado de máquina. Agora, vamos prosseguir com modelos não lineares, especificamente o Random Forest.\n",
        "\n",
        "Embora modelos lineares sejam práticos, nem sempre conseguem captar a complexidade dos dados. Por isso, vamos utilizar o Random Forest, um **modelo não linear mais flexível e capaz de lidar com padrões complexos**.\n",
        "\n",
        "Nossa estratégia é iniciar com modelos simples, completando o primeiro ciclo do CRISP-DM, um padrão para projetos de mineração de dados. A complexidade aumentará nos ciclos seguintes, conforme a necessidade do projeto."
      ],
      "metadata": {
        "id": "5BmnypoU_5pm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## 7.4 Random Forest Regressor\n",
        "Este algoritmo baseia-se em árvores de decisão, criando um \"bosque\" de árvores independentes durante o treinamento. Para novas entradas, a saída é a média das previsões individuais das árvores (no caso de regressão).\n",
        "\n",
        "O modelo Random Forest é implementado através da biblioteca Scikit-learn (\"sklearn\"), uma ferramenta Python versátil para modelagem de dados. Uma instância desse modelo é criada sob o nome \"rf\"."
      ],
      "metadata": {
        "id": "84QdchtqFnaI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestRegressor\n",
        "\n",
        "# model\n",
        "rf = RandomForestRegressor(n_estimatores=100, n_jobs=1, random_state=42).fit(x_train, y_train)"
      ],
      "metadata": {
        "id": "4_3iI9ZPFvuz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao criar a instância do modelo, fornecemos três argumentos. \"n_estimators=100\" define o total de árvores de decisão. \"n_jobs=-1\" indica que todos os processadores disponíveis serão usados para paralelização. \"random_state=42\" para obter resultados consistentes.\n",
        "\n",
        "Depois de construir o modelo, aplicamos o método 'fit' aos nossos dados de treinamento (x_train e y_train).\n",
        "\n",
        "Na etapa de previsão, utilizamos o modelo treinado para gerar estimativas nos dados de teste (x_test), armazenadas na variável yhat_rf."
      ],
      "metadata": {
        "id": "IRTeVIsjEuUO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# prediction\n",
        "yhat_rf = rf.predict(x_test)"
      ],
      "metadata": {
        "id": "s5YHMMXkF4se"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Por fim, medimos a performance do modelo comparando as vendas reais (y_test) com as previsões do modelo (yhat_rf). Para isso, usamos a função ml_error, e o resultado é armazenado na variável rf_result."
      ],
      "metadata": {
        "id": "AeVfZI1sF69E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# performance\n",
        "rf_result = ml_error('Random Forest Regressor', np.expm1(y_test), np.expm1(yhat_rf))"
      ],
      "metadata": {
        "id": "ck_HvdR6F8Pa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Com isso, finalizamos a aplicação do algoritmo Random Forest Regressor, etapa vital em nossa progressão de modelagem de aprendizado de máquina. Durante esse processo, mostramos o treinamento do modelo, a realização de previsões e a avaliação do seu desempenho."
      ],
      "metadata": {
        "id": "BmRHEmtoF-Sp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## 7.5 XGBoost Regressor\n",
        "Neste momento, aplicamos um quinto algoritmo de aprendizado de máquina, o XGBoost Regressor. A preferência pelo XGBoost, ou \"Extreme Gradient Boosting\", deve-se à sua rapidez e eficácia, características que o destacam na área de Ciência de Dados.\n"
      ],
      "metadata": {
        "id": "JMZLEEX4GH8G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import xgboost as xgb\n",
        "\n",
        "# model\n",
        "model_xgb = xgb.XGBRegressor(objective='reg:squarederror',\n",
        "                             n_estimators=100,\n",
        "                             eta=0.001,\n",
        "                             max_depth=10,\n",
        "                             subsample=0.7,\n",
        "                             colsample_bytree=0.9).fit(x_train, y_train)"
      ],
      "metadata": {
        "id": "DlXT4fesIuDw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao instanciar o modelo, são passados vários parâmetros, tais como:\n",
        "\n",
        "- objective='reg:squarederror': a função objetiva, que neste caso é o erro quadrado para problemas de regressão.\n",
        "- n_estimators=100: o número de etapas de boosting para executar. Cada estágio do boosting constrói um novo modelo que tenta corrigir os erros dos modelos anteriores.\n",
        "- eta=0.001: a taxa de aprendizagem do nosso modelo.\n",
        "- max_depth=10: a profundidade máxima de cada árvore.\n",
        "- subsample=0.7: a fração dos dados de treinamento para serem usados em cada árvore.\n",
        "- colsample_bytree=0.9: a fração das colunas a serem amostradas para cada árvore.\n",
        "\n",
        "Após a criação do modelo, o ajustamos (fit) aos dados de treinamento (x_train e y_train).\n",
        "\n",
        "Na fase de previsão, usamos o modelo treinado para gerar previsões para os dados de teste (x_test) e armazenamos essas previsões na variável yhat_xgb:"
      ],
      "metadata": {
        "id": "SzeDtKE2Iw6n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# prediction\n",
        "yhat_xgb = model_xgb.predict(x_test)"
      ],
      "metadata": {
        "id": "OPeSBID0I9hV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para avaliar a performance do nosso modelo XGBoost, calculamos o erro entre as vendas reais (y_test) e as previsões feitas pelo modelo (yhat_xgb). Esses cálculos são realizados através da função ml_error e os resultados são armazenados na variável xgb_result:"
      ],
      "metadata": {
        "id": "l-1e7hysJAcv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# performance\n",
        "xgb_result = ml_error('XGBoost Regressor', np.expm1(y_test), np.expm1(yhat_xgb))"
      ],
      "metadata": {
        "id": "t23Sb5vfF_in"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Implementamos o modelo XGBoost Regressor e suas respectivas etapas: criação do modelo, previsão e avaliação da performance."
      ],
      "metadata": {
        "id": "Fd8_HRFCJHmL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## 7.6 Model Performance Comparison\n",
        "A meta aqui é unir e contrastar os resultados dos vários modelos de aprendizado de máquina previamente implementados. Esta etapa nos possibilita identificar o modelo com o menor erro de previsão.\n",
        "\n",
        "Para alcançar esse fim, usamos uma função do Pandas denominada concat, que nos permite concatenar, isto é, combinar múltiplos DataFrames em um único."
      ],
      "metadata": {
        "id": "iRKdfAv5JW2-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "modelling_result = pd.concat([baseline_result, lr_result, lrr_result, rf_result, xgb_result])"
      ],
      "metadata": {
        "id": "dFr0yyOJJWcW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nessa linha de código, reunimos os resultados de cinco modelos diferentes: o modelo baseline (média), a regressão linear (Linear Regression), a regressão com regularização Lasso (Lasso Regression), o modelo Random Forest e, finalmente, o XGBoost. O resultado dessa concatenação é armazenado na variável modelling_result.\n",
        "\n",
        "Após concatenar os resultados, queremos ordená-los para identificar qual modelo apresentou o melhor desempenho. A métrica que usamos para esta comparação é o Erro Quadrático Médio (RMSE, do inglês Root Mean Squared Error). Quanto menor o RMSE, melhor o modelo, pois isso significa que ele produziu previsões mais precisas.\n",
        "\n",
        "Para ordenar os modelos de acordo com o RMSE, usamos a função sort_values, da seguinte maneira:"
      ],
      "metadata": {
        "id": "Gj6NxC5nsWLN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "modelling_result.sort_values('RMSE')"
      ],
      "metadata": {
        "id": "Zv2eK4WKsZwu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste ponto da análise, organizamos os resultados em ordem ascendente de RMSE para identificar o modelo de melhor desempenho. É essencial notar que o RMSE é uma medida que quantifica o erro do nosso modelo, sendo menores valores indicativos de melhor desempenho.\n",
        "\n",
        "Nossos testes englobaram modelos Random Forest, XGBoost Regressor (XGBoost), além de outros lineares e não-lineares. O Random Forest destacou-se com o melhor RMSE, de 1011, seguido pelo XGBoost Regressor com 1250 e o modelo de médias com 1835. Os modelos lineares apresentaram desempenho inferior, com RMSE de 2600 e 2744, sugerindo sua inadequação para a complexa tarefa de previsão de vendas.\n",
        "\n",
        "Esta análise aponta que a previsão de vendas, o fenômeno em estudo, possui natureza complexa e não-linear. Portanto, modelos mais sofisticados, como o Random Forest e o XGBoost, tendem a ter melhor desempenho.\n",
        "\n",
        "Contudo, vale destacar que o tempo de execução desses modelos complexos pode ser limitante. Se aumentarmos o número de árvores para 2500 ou 3000, o tempo de execução crescerá significativamente, o que pode ser desafiador em um ambiente de produção.\n",
        "\n",
        "Outra consideração crucial é que o RMSE reportado pode não refletir a performance real do modelo. Isso ocorre porque dividimos os dados em conjuntos de treino e teste, reservando as últimas seis semanas para testes. Dependendo da distribuição dos dados e da volatilidade das vendas, o RMSE pode estar superestimando a performance do modelo."
      ],
      "metadata": {
        "id": "d6xa54Uwsdn2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## 7.7 Cross-Validation Method (measuring actual model performance)\n",
        "Na etapa anterior, implementamos cinco modelos cuja performance foi avaliada com base nos dados das últimas seis semanas. No entanto, esse valor não representa a performance real dos modelos, pois depende do intervalo de tempo escolhido para o teste, que pode corresponder à melhor ou à pior semana de vendas.\n",
        "\n",
        "Para obter uma medida de desempenho mais precisa, utilizamos a validação cruzada, uma técnica que avalia a performance do modelo em vários intervalos de tempo no conjunto total de dados. A validação cruzada pode ser aplicada em tarefas de classificação ou regressão, bem como em séries temporais, com uma ligeira modificação.\n",
        "\n",
        "Essa técnica pode ser ilustrada com a metáfora de um baralho de 100 cartas, representando o conjunto de dados. Dividimos o baralho em 10 montes de 10 cartas. Em cada rodada de validação cruzada, usamos 9 montes para treinamento e um para validação. Ao repetir o processo com diferentes montes para teste, garantimos que todas as partes dos dados são usadas tanto para treino quanto para validação.\n",
        "\n",
        "No final, calculamos a média das performances em todas as rodadas para determinar a performance geral do modelo. Isso nos permite avaliar o desempenho do modelo de forma mais confiável.\n",
        "\n",
        "Cabe destacar que, no contexto de validação cruzada, os dados de teste são chamados de dados de validação para evitar confusões. Assim, em cada ciclo, o modelo é treinado nos dados de treinamento e testado nos dados de validação, e o resultado é armazenado. A performance real do modelo é calculada como a média desses resultados.\n",
        "\n",
        "### 7.7.1. Time Series Cross Validation\n",
        "A validação cruzada para séries temporais é uma técnica especialmente adaptada de validação cruzada comum, preservando a ordem cronológica dos dados, que é vital em séries temporais. Iniciamos com uma parcela inicial dos dados para treinamento e uma subsequente para validação, sempre considerando a sequência temporal. Em cada iteração, o conjunto de treinamento se expande, incorporando os dados de validação da etapa anterior, e um novo período é escolhido para validação.\n",
        "\n",
        "Por exemplo, se estivermos prevendo as vendas semanais da Rossmann por um período de 6 semanas, com base nos padrões de vendas das semanas anteriores.\n",
        "\n",
        "Na primeira iteração da validação cruzada em série, usaríamos os dados da primeira semana para treinar o modelo e os dados da segunda semana para validação.\n",
        "\n",
        "Na segunda iteração, os dados das duas primeiras semanas seriam utilizados para treinar o modelo, e os dados da terceira semana seriam usados para validação.\n",
        "\n",
        "Esse processo continuaria, sempre expandindo a quantidade de dados de treinamento para incluir os dados de validação da semana anterior, até que a sexta semana fosse usada para validação.\n",
        "\n",
        "Assim, a cada iteração, o modelo é treinado com mais dados, mantendo a ordem temporal, e validado com dados da semana subsequente. Isso assegura que o modelo seja testado em condições similares àquelas que encontrará na previsão real.\n"
      ],
      "metadata": {
        "id": "KnFuGfUwulVU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Filtragem de Dados\n",
        "Para realizar análises temporais, é crucial tratar os dados corretamente. Vamos considerar um conjunto de dados, chamado \"X_train\", que possui todas as variáveis que precisamos, porém não inclui as colunas 'date' e 'sales', que são essenciais para nossa análise.\n",
        "\n",
        "Primeiramente, criamos uma nova coluna chamada 'full', que inclui todas as colunas e copiamos os dados do \"X_train\" para ela. Então, adicionamos as colunas 'date' e 'sales' que faltavam:"
      ],
      "metadata": {
        "id": "F-JH_zP560uT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#columns to add\n",
        "feat_to_add = ['date', 'sales']\n",
        "\n",
        "cols_selected_boruta_full = cols_selected_boruta.copy()\n",
        "cols_selected_boruta_full.extend(feat_to_add)\n",
        "\n",
        "x_training = X_train[cols_selected_boruta_full]\n",
        "x_training.head()"
      ],
      "metadata": {
        "id": "ZjZaRrB066H9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### Validação Cruzada K-Fold\n",
        "Construímos a função de validação cruzada, denominada cross_validation. Esta função aceita os dados de treino, o número de dobras (kfold) e o nome do modelo como entradas. Dentro dela, inicializamos listas vazias para as métricas MAE, MAPE e RMSE.\n",
        "\n",
        "Durante o processo, executamos uma iteração reversa de 1 até kfold + 1. Em cada ciclo, filtramos os conjuntos de treino e validação com base nas datas. Em seguida, ajustamos o modelo aos dados de treino e realizamos a previsão com os dados de validação.\n",
        "\n",
        "O desempenho obtido em cada iteração é registrado nas listas de MAE, MAPE e RMSE. Ao final da função, retornamos um DataFrame que contém o nome do modelo, assim como as médias e desvios padrão das métricas, conforme ilustrado no código abaixo."
      ],
      "metadata": {
        "id": "3YKiCn9oBopO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def cross_validation(x_training, kfold, model_name, model, verbose=False):\n",
        "  mae_list  = []\n",
        "  mape_list = []\n",
        "  rmse_list = []\n",
        "\n",
        "  for k in reversed(range(1, kfold+1)):\n",
        "    # Defina o início e o fim da validação baseado na data\n",
        "    validation_start_date = x_training['date'].max() - datetime.timedelta(k*7*6)\n",
        "    validation_end_date   = x_training['date'].max() - datetime.timedelta((k-1)*7*6)\n",
        "\n",
        "    # Filtrando o conjunto de dados\n",
        "    training   = x_training[x_training['date'] < validation_start_date]\n",
        "    validation = x_training[(x_training['date'] >= validation_start_date) & (x_training['date'] <= validation_end_date)]\n",
        "\n",
        "    # Training and Validation dataset\n",
        "\n",
        "    # Training\n",
        "    xtraining = training.drop(['date', 'sales'], axis=1)\n",
        "    ytraining = training['sales]\n",
        "\n",
        "    # Validation\n",
        "    xvalidation = validation.drop(['date', 'sales'], axis=1)\n",
        "    yvalidation = validation['sales']\n",
        "\n",
        "    # Ajuste do modelo\n",
        "    m = model().fit(xtraining, ytraining)\n",
        "\n",
        "    # Previsão\n",
        "    yhat = m.predict(xvalidation)\n",
        "\n",
        "    # Calculando o erro\n",
        "    m_result = ml_error(model_name, np.expm1(yvalidation), np.expm1(yhat))\n",
        "\n",
        "    # Armazenando a performance de cada iteração\n",
        "    mae_list.append( m_result['MAE'])\n",
        "    mape_list.append(m_result['MAPE'])\n",
        "    rmse_list.append(m_result['RMSE'])\n",
        "\n",
        "  # Retornando as médias e desvios padrão das métricas\n",
        "  return pd.DataFrame({'Model Name': model_name,\n",
        "                       'MAE CV'    : np.round(np.mean(mae_list),  2).astype(str) + '+/-' + np.round(np.std(mae_list),  2).astype(str),\n",
        "                       'MAPE CV'   : np.round(np.mean(mape_list), 2).astype(str) + '+/-' + np.round(np.std(mape_list), 2).astype(str),\n",
        "                       'RMSE CV'   : np.round(np.mean(rmse_list), 2).astype(str) + '+/-' + np.round(np.std(rmse_list), 2).astype(str)})\n"
      ],
      "metadata": {
        "id": "cRZCSMg6Bp25"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### Detalhamento da Função Cross Validation\n",
        "Agora que possuímos os dados adequados, iremos dividi-los em dois grupos: treinamento e validação. Para isso, vamos definir uma data de início e outra de término para a validação, que serão chamadas de \"validation_start_date\" e \"validation_end_date\", respectivamente. Essas datas são definidas com base na data mais recente do nosso conjunto de dados e no número de semanas que pretendemos reservar para a validação:\n",
        "\n",
        "Por exemplo, se os nossos dados vão até a data 'D' e decidimos usar as últimas 6 semanas para a validação, então \"validation_end_date\" será a data 'D' e \"validation_start_date\" será a data 'D' menos 6 semanas.\n",
        "\n",
        "Com esse procedimento, conseguimos simular uma situação real em que treinamos nosso modelo com dados passados (conjunto de treinamento) e avaliamos sua habilidade de prever eventos futuros (conjunto de validação)."
      ],
      "metadata": {
        "id": "PwVL5e2J7N3l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "# start date for validation\n",
        "validation_start_date = x_training['date'].max() - datetime.timedelta(k*7*6)\n",
        "\n",
        "#end date for validation\n",
        "validation_end_date = x_training['date'].max() - datetime.timedelta((k-1)*7*6)"
      ],
      "metadata": {
        "id": "Yn36VcEt7Py4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tendo determinado as datas de início e término da validação, podemos agora subdividir nossos dados em conjuntos de treinamento e validação. O conjunto de treinamento incluirá todos os dados anteriores à \"validation_start_date\". Por sua vez, o conjunto de validação conterá os dados compreendidos no período entre \"validation_start_date\" e \"validation_end_date\"."
      ],
      "metadata": {
        "id": "oBbHRe4F7VRS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "# filtering dataset\n",
        "training = x_training[x_training['date'] < validation_start_date]\n",
        "validation = x_training[(x_training['date'] >= validation_start_date) & (x_training['date'] <= validation_end_date)]"
      ],
      "metadata": {
        "id": "ClE0_5XX7X69"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos então verificar se os dados foram filtrados corretamente, verificando as datas mínimas e máximas dos subconjuntos de treinamento e validação:"
      ],
      "metadata": {
        "id": "dpvYdAHt7dXL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "training['date'].min()\n",
        "training['date'].max()\n",
        "validation['date'].min()\n",
        "validation['date'].max()"
      ],
      "metadata": {
        "id": "prbaa5OG7gLx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Essa abordagem assegura que nossos subconjuntos estejam apropriadamente organizados para as análises futuras. O valor 'k' na fórmula que aplicamos para definir as datas de começo e fim da validação pode ser alterado para ajustar o número de semanas a ser considerado na validação, possibilitando uma análise temporal resistente e versátil."
      ],
      "metadata": {
        "id": "s2TwThDe7jLM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Detalhamento Validação Cruzada\n",
        "O primeiro passo é a preparação dos dados. Temos colunas 'data' e 'vendas' em nosso conjunto de dados que não devem ser usadas para treinar o modelo. Portanto, essas colunas são removidas dos dados de treinamento e validação.\n"
      ],
      "metadata": {
        "id": "rg5PewCFBL_c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "xtraining = training.drop(['date', 'sales'], axis =1 )\n",
        "validation = validation.drop(['date', 'sales'], axis=1)\n",
        "xvalidation = validation.drop(['date', 'sales'], axis =1)\n",
        "yvalidation = validation['sales']"
      ],
      "metadata": {
        "id": "ZWmVLE1rBcbN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Criação e Treinamento do Modelo\n",
        "\n",
        "Com os dados preparados, o modelo de Regressão Linear é criado e treinado com o conjunto de treinamento."
      ],
      "metadata": {
        "id": "4oC2ucz8BezB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "lr = LinearRegression().fit(xtraining, ytraining)"
      ],
      "metadata": {
        "id": "o4ricSZZBgK_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Predição e Avaliação\n",
        "\n",
        "O modelo treinado é usado para fazer previsões no conjunto de validação. A performance do modelo é então avaliada usando uma função de erro personalizada 'ml_error'."
      ],
      "metadata": {
        "id": "zxYHgclsBjgh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "yhat_lr = lr.predict(xvalidation)\n",
        "lr_result = ml_error('Linear Regression', np.expm1(yvalidation), np.expm1(yhat_lr))"
      ],
      "metadata": {
        "id": "K0h-dqE9BlN0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Na etapa final, invocamos a função cross_validation passando os dados de treinamento, o número de dobras e o modelo. O modelo usado neste exemplo é a Regressão Linear. Além disso, adicionamos um parâmetro opcional 'verbose' à função que controla se as iterações devem ser impressas ou não."
      ],
      "metadata": {
        "id": "hNQrg0rzM1m6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.2.1 Linear Regression Model - Cross Validation"
      ],
      "metadata": {
        "id": "h56A328WPS4j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lr_result"
      ],
      "metadata": {
        "id": "wr1gk6Cl8O1C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lr_result_cv = cross_validation(x_training, 5, 'Linear Regression', model)\n",
        "lr_result_cv"
      ],
      "metadata": {
        "id": "vbtyckxtM2ve"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nesse cenário, a função cross_validation recebe cinco parâmetros: o conjunto de dados para treinamento (Extreme), o número de divisões (cinco, neste caso), o nome do modelo ('Linear Regression'), o modelo treinado (LR) e o nível de detalhamento das informações exibidas durante o processo (falso).\n",
        "\n",
        "O processo de validação cruzada implica em dividir o conjunto de dados em cinco partes (devido à escolha de cinco divisões) e, em seguida, treinar o modelo em quatro delas, deixando uma parte para testes. Isso é repetido cinco vezes, cada vez com uma parte diferente deixada de fora para testes.\n",
        "\n",
        "Ao final dessas iterações, obtemos cinco medidas de desempenho, que são então usadas para calcular a média e o desvio padrão. Estas duas métricas juntas nos dão uma visão mais precisa do desempenho do modelo. Por exemplo, em uma das execuções, obtivemos um Root Mean Square (RMS) de 2.671, mas o RMS médio foi de 2.900, indicando que a primeira execução teve um desempenho superior ao usual.\n",
        "\n",
        "É importante salientar que a performance real do modelo é dada pela média mais ou menos o desvio padrão, nesse caso, o erro real deste modelo é de 2.900 mais ou menos 500. Isso nos dá uma faixa de variação para a performance do modelo, o que é mais confiável do que uma única medida pontual."
      ],
      "metadata": {
        "id": "evigTe-0BrkN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.3.1 Lasso - Cross Validation\n",
        "Assim como no caso anterior, a função cross_validation recebe cinco parâmetros: o conjunto de dados para treinamento (x_training), o número de divisões (neste caso, mantemos cinco), o nome do modelo ('Lasso'), o modelo treinado (LRR) e o nível de detalhamento das informações exibidas durante o processo (definido como falso).\n",
        "\n",
        "Na continuidade do nosso projeto de previsão de vendas, vamos agora aplicar a validação cruzada no modelo Lasso, uma forma de regressão linear regularizada. E\n",
        "\n",
        "A função cross_validation é acionada com cinco parâmetros: o conjunto de treinamento (x_training), o número de divisões (mantido como cinco), o nome do modelo ('Lasso'), o modelo treinado (lrr) e um marcador para a exibição de informações detalhadas durante o processo (definido como falso).\n",
        "\n",
        "O código correspondente fica assim:"
      ],
      "metadata": {
        "id": "IgqePxj1NFgr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lrr_result"
      ],
      "metadata": {
        "id": "MI0vKZvw8L0p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = Lasso(alpha=0.01)\n",
        "lrr_result_cv = cross_validation(x_training, 5, 'Lasso', lrr, verbose=False)\n",
        "lrr_result_cv"
      ],
      "metadata": {
        "id": "IdLDqMOYQ9xx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A validação cruzada, que subdivide os dados em cinco partes, treina o modelo em quatro delas e o testa na quinta, produz um novo conjunto de medidas de desempenho.\n",
        "\n",
        "O RMSE da última semana de vendas foi cerca de 2.952, mas o RMS médio da validação cruzada foi de 3.057, com um desvio padrão de 504. Isso sugere que a variação do desempenho do modelo está entre 2.500 a 3.500.\n",
        "\n",
        "A real performance do modelo é então dada pela média mais ou menos o desvio padrão, ou seja, 3.057 ± 504. Isso destaca o valor da validação cruzada para fornecer uma avaliação do modelo mais precisa e robusta. A semana de vendas com RMS inferior à média foi provavelmente uma semana atípica de alto desempenho. Porém, com a validação cruzada, conseguimos capturar uma gama maior de cenários, incluindo semanas de desempenho tanto superior quanto inferior."
      ],
      "metadata": {
        "id": "5lqV2HOQQ_xO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.4.1 Random Forest Regressor - Cross Validation\n",
        "\n",
        "Continuando nossa exploração de diferentes modelos de aprendizado de máquina para a previsão de vendas, a próxima etapa envolve a utilização do modelo de Regressão de Floresta Aleatória (Random Forest Regressor).\n",
        "\n",
        "Na Regressão de Floresta Aleatória, múltiplas árvores de decisão são treinadas e suas previsões são combinadas para produzir um resultado final mais robusto e preciso. Novamente, vamos implementar a validação cruzada para avaliar a performance do nosso modelo.\n",
        "\n",
        "A função cross_validation é usada novamente, mas desta vez, o parâmetro que indica o modelo treinado será o modelo de Floresta Aleatória, representado aqui pela variável 'rf'. Optamos por habilitar o parâmetro verbose, permitindo assim o acompanhamento em tempo real do progresso do processo.\n",
        "\n",
        "O comando para implementar a validação cruzada para o modelo de Regressão de Floresta Aleatória é o seguinte:"
      ],
      "metadata": {
        "id": "NHBQAk6u3Rxw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rf_result"
      ],
      "metadata": {
        "id": "VkCI5m9q8Rks"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rf_result_cv = cross_validation(x_training, 5, 'Random Forest Regressor', rf, verbose = True)\n",
        "rf_result_cv"
      ],
      "metadata": {
        "id": "v8AxWnDI3Ufb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Após a execução desta linha de código, obteremos as medidas de desempenho para o modelo de Floresta Aleatória. Estes resultados, assim como nos casos anteriores, nos fornecerão uma visão mais precisa da capacidade do modelo de realizar previsões precisas nas vendas."
      ],
      "metadata": {
        "id": "43wrOn6q397A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.5.1. XGBoost Regressor - Cross Validation\n",
        "A última abordagem que vamos analisar para a previsão de vendas é o uso do XGBoost Regressor, um modelo de aprendizado de máquina avançado que usa o conceito de boosting para gerar previsões precisas. Esta análise será realizada na subseção 7.5.1 do nosso script.\n",
        "\n",
        "A técnica de boosting se refere ao treinamento de modelos consecutivos, onde cada modelo subsequente aprende com os erros cometidos pelo modelo anterior. O XGBoost, em particular, é um algoritmo que se destacou em várias competições de aprendizado de máquina devido à sua alta eficiência e precisão.\n",
        "\n",
        "A implementação da validação cruzada para o XGBoost Regressor é similar à que realizamos para os modelos anteriores. A função cross_validation é novamente utilizada, com o conjunto de treinamento, o número de folds, o nome do modelo e o modelo treinado (neste caso, 'model_xgb') sendo passados como parâmetros. O parâmetro verbose é definido como True para permitir o acompanhamento do progresso do processo em tempo real.\n",
        "\n",
        "A linha de código a ser executada para realizar a validação cruzada com o XGBoost Regressor é a seguinte:"
      ],
      "metadata": {
        "id": "E82Verc64SPA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "xgb_result"
      ],
      "metadata": {
        "id": "f1jLvhhz8TN5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "xgb_result_cv = cross_validation(x_training, 5, 'XGBoost Regressor', model_xgb, verbose=True)\n",
        "xgb_result_cv"
      ],
      "metadata": {
        "id": "H-dwbDXv4WmU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Depois de executar esta linha de código, obteremos as métricas de desempenho para o XGBoost Regressor. Esses resultados nos permitirão avaliar o desempenho deste modelo em comparação com os modelos anteriores e selecionar o modelo que oferece a melhor precisão nas previsões de vendas."
      ],
      "metadata": {
        "id": "HiMz8khc41Xn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "sMVDGGZ-6Ven"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Algoritmo de Previsão de Vendas\n",
        "Finalizamos a etapa de aplicação dos algoritmos de previsão de vendas, que incluiu o uso do modelo de Regressão Linear, Lasso Regressor, Random Forest Regressor e XGBoost Regressor. Agora, vamos comparar o desempenho de cada um desses modelos para selecionar aquele que apresenta a melhor precisão.\n",
        "\n",
        "Para isso, vamos criar duas tabelas de desempenho: uma com a performance de cada modelo em um único fold (subseção 7.6.1 - Single Performance) e outra com o desempenho real dos modelos, medido através da validação cruzada (subseção 7.6.2 - Real Performance - Cross Validation)."
      ],
      "metadata": {
        "id": "wibyULZN6Y18"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 7.6.1. Single Perfomance\n",
        "Na subseção 7.6.1, vamos concatenar os resultados de cada modelo em um único DataFrame, chamado 'modeling_result', e classificar os modelos de acordo com o valor do Erro Quadrático Médio (RMSE - Root Mean Squared Error). A linha de código a ser executada é a seguinte:"
      ],
      "metadata": {
        "id": "O1hEI0m55S5R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "modeling_result = pd.concat(['baseline_result', 'lr_result', 'lrr_result', 'rf_result', 'xgb_result'])\n",
        "modeling_result.sort_values('RMSE')"
      ],
      "metadata": {
        "id": "ViDqOeqv5vg0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 7.6.2. Real Performance - Cross Validation\n",
        "Na subseção 7.6.2, vamos realizar um processo similar, mas agora considerando os resultados da validação cruzada. O código a ser executado é:\n"
      ],
      "metadata": {
        "id": "WjMOQBvh5V9b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "modeling_result_cv = pd.concat(['lr_result_cv', 'lrr_result_cv', 'rf_result_cv', 'xgb_result_cv'])\n",
        "modeling_result_cv.sort_values('RMSE')"
      ],
      "metadata": {
        "id": "hW31Z0gN5R5G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A execução dessas linhas de código nos fornecerá duas tabelas: uma apresentando a performance de cada modelo em um único fold e outra mostrando o desempenho real dos modelos, obtido através da validação cruzada. A partir desses resultados, podemos selecionar o modelo que melhor atende às nossas necessidades de previsão de vendas."
      ],
      "metadata": {
        "id": "omEp_H536sN-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Conclusão Algoritmo\n",
        "Chegamos ao final da etapa de treinamento e avaliação dos modelos de previsão de vendas. Nesta etapa, utilizamos quatro modelos diferentes: Linear Regression, Lasso Regression, Random Forest e XGBoost.\n",
        "\n",
        "Ao analisar os resultados obtidos após a execução do Cross Validation, percebemos que o modelo Random Forest apresentou uma performance superior aos demais, com um RMSE (Erro Quadrático Médio Raiz) médio de 1256, sendo este valor consideravelmente menor do que os demais modelos. Isso indica que o Random Forest, em geral, tem um desempenho muito satisfatório, sendo um algoritmo rápido para treinar e muito eficaz para problemas de classificação e regressão.\n",
        "\n",
        "Contudo, apesar da performance superior do Random Forest, optamos por continuar o projeto com o modelo XGBoost. Essa decisão foi tomada por dois motivos principais. Primeiro, o XGBoost tem ganhado fama recentemente devido a seus resultados promissores em diferentes cenários, porém ainda existe pouca informação disponível sobre a implementação desse modelo, o que nos motiva a explorá-lo mais a fundo. Segundo, em um projeto recente, observamos que o modelo Random Forest, embora apresentasse uma performance ligeiramente superior, tinha um tamanho consideravelmente maior, tornando o custo de manutenção desse modelo em produção significativamente mais alto.\n",
        "\n",
        "Apesar de optarmos pelo XGBoost, é importante ressaltar que a escolha do modelo depende do cenário e dos objetivos de cada projeto. Além disso, os passos que apresentamos até aqui podem ser aplicados a qualquer modelo de Machine Learning.\n",
        "\n",
        "Finalizamos a comparação dos modelos e seus respectivos desempenhos, e no próximo passo do projeto, vamos nos concentrar no ajuste fino dos hiperparâmetros do modelo XGBoost. Essa etapa é essencial para melhorar ainda mais o desempenho do algoritmo e consiste em otimizar os parâmetros que regulam o aprendizado do modelo."
      ],
      "metadata": {
        "id": "5uVIXPSOC5Gm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### Update do Progresso do Projeto Rossmann\n",
        "Neste momento fornecemos uma visão geral do progresso atual do nosso projeto de previsão de vendas para a Rossman, buscando esclarecer as etapas envolvidas para os envolvidos no projeto.\n",
        "\n",
        "O projeto se baseia em um processo de 10 passos, inspirado no ciclo CRISP-DM, uma metodologia conhecida na ciência de dados para conduzir projetos de aprendizado de máquina.\n",
        "\n",
        "A primeira etapa envolveu a **definição do problema**: a Rossman precisa prever as vendas de suas lojas para determinar o orçamento de reformas.\n",
        "\n",
        "Na segunda etapa, buscamos **compreender o problema em sua raiz**. Conversamos com stakeholders, identificando que a previsão de vendas para as próximas seis semanas seria uma solução adequada.\n",
        "\n",
        "A terceira etapa consistiu na **coleta de dados**. Em um contexto real, isso pode envolver consultas SQL, APIs, dados manualmente inseridos, entre outros. No nosso caso, obtivemos os dados a partir da plataforma Kaggle.\n",
        "\n",
        "Em seguida, realizamos a **limpeza dos dados**. Esta etapa engloba a descrição dos dados, a derivação de características a partir das variáveis originais (feature engineering) e a filtragem de dados com base em restrições do negócio.\n",
        "\n",
        "Na quinta etapa, **exploramos os dados para compreender o negócio** e identificar as variáveis relevantes para o aprendizado do modelo. Validamos hipóteses e realizamos testes estatísticos.\n",
        "\n",
        "Na etapa de **preparação dos dados**, codificamos as variáveis categóricas e aplicamos transformações em variáveis numéricas e categóricas para melhorar o desempenho do modelo.\n",
        "\n",
        "Na etapa seguinte, **filtramos as variáveis** com base em sua relevância para o aprendizado do modelo, utilizando um algoritmo chamado Boruta.\n",
        "\n",
        "Na **etapa de modelagem**, implementamos cinco algoritmos de machine learning, incluindo modelos lineares e não-lineares, além de um modelo baseado em médias.\n",
        "\n",
        "Atualmente, estamos na etapa de **ajuste de hiperparâmetros (fine-tuning), otimizando o algoritm** XGBoost, apesar de seu desempenho ser ligeiramente inferior ao Random Forest.\n",
        "\n",
        "As próximas etapas envolverão a **avaliação do desempenho do modelo** e a decisão sobre sua implementação na produção, concluindo assim a primeira versão da nossa solução para o problema de previsão de vendas da Rossman."
      ],
      "metadata": {
        "id": "b1PB5LpxHVtT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "# 8.0 Fine Tuning\n",
        "No contexto de nosso projeto de previsão de vendas, a técnica de ajuste de hiperparâmetros desempenha um papel fundamental para otimizar a performance de nossos modelos de Machine Learning.\n",
        "\n",
        "Os hiperparâmetros podem ser vistos como **configurações ajustáveis em nossos modelos que influenciam como eles aprendem** a partir dos dados. Para ilustrar, imagine-os como os botões de um rádio, que você ajusta até obter a melhor recepção possível.\n",
        "\n",
        "A título de exemplo, ao trabalhar com redes neurais, os hiperparâmetros podem envolver o número de neurônios, o número de camadas ocultas ou a função de ativação utilizada. Em modelos de \"Random Forest\", os hiperparâmetros podem ser o número de estimadores ou a profundidade máxima das árvores.\n",
        "\n",
        "Escolher os valores corretos para esses **hiperparâmetros é uma etapa decisiva para o sucesso do nosso modelo**. Se bem ajustados, eles têm o potencial de melhorar significativamente a precisão da previsão de vendas e minimizar o risco de overfitting - quando o modelo se ajusta excessivamente aos dados de treinamento e falha ao se deparar com novos dados.\n",
        "\n",
        "Diferente de escolher os valores desses hiperparâmetros aleatoriamente, e**mpregamos técnicas inteligentes de busca e otimização para encontrar os melhores valores que otimizam** o desempenho de nosso modelo de previsão de vendas. Este processo é essencial para melhorar a precisão de nossas previsões de vendas.\n",
        "\n",
        "Existem três estratégias principais para realizar o ajuste de hiperparâmetros:\n",
        "\n",
        "- **Random Search:** Esta estratégia **seleciona aleatoriamente valores para os hiperparâmetros**. Embora seja simples, pode não encontrar o conjunto ótimo de parâmetros.\n",
        "\n",
        "- **Grid Search:** Esta estratégia testa **todas as combinações possíveis de valores para os hiperparâmetros**. Apesar de ter o potencial de encontrar a combinação ótima, pode ser um processo computacionalmente intensivo e demorado.\n",
        "\n",
        "- **Bayesian Optimization:** Esta estratégia utiliza a teoria de Bayes para selecionar os valores dos hiperparâmetros. A otimização bayesiana **busca o conjunto de hiperparâmetros que maximiza a função de probabilidade** posterior.\n",
        "\n",
        "Cada uma dessas estratégias tem suas vantagens e desvantagens, e a escolha entre elas dependerá do contexto específico e dos recursos disponíveis."
      ],
      "metadata": {
        "id": "3Ucboai5B6s_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### • Random Search\n",
        "Este método funciona selecionando aleatoriamente valores dentro de um conjunto predefinido para os hiperparâmetros do modelo. Os hiperparâmetros, ajustáveis manualmente, orientam como o modelo aprende a partir dos dados.\n",
        "\n",
        "Para dar um exemplo mais claro, consideremos cinco hiperparâmetros em um modelo XGBoost: número de estimadores (n_estimators), subamostra (subsample), profundidade máxima (max_depth), taxa de aprendizado (eta) e peso mínimo da criança (min_child_weight). Cada um desses hiperparâmetros pode assumir uma série de valores elegíveis, que são definidos de acordo com as necessidades do projeto.\n",
        "\n",
        "O processo do Random Search é realizado em interações. Em cada interação, o método seleciona aleatoriamente um valor de dentro do conjunto de valores possíveis para cada hiperparâmetro. Em seguida, o modelo é treinado e testado com esses parâmetros selecionados e o desempenho do modelo é registrado. O processo é então repetido na próxima interação. Ao final das interações, escolhe-se o conjunto de hiperparâmetros que resultou na melhor performance do modelo.\n",
        "\n",
        "A principal vantagem do Random Search é a sua velocidade e simplicidade na implementação, especialmente quando comparado a outras técnicas de ajuste de hiperparâmetros. Contudo, o método também tem suas desvantagens. Devido à sua natureza aleatória, o Random Search pode selecionar o mesmo conjunto de hiperparâmetros em diferentes interações, o que pode ser considerado uma perda de tempo. Além disso, devido à mesma natureza aleatória, pode acontecer de o Random Search não encontrar o conjunto de hiperparâmetros que otimize ao máximo o aprendizado do modelo, pois a busca pode terminar antes de todas as combinações possíveis serem exploradas.\n",
        "\n",
        "Em resumo, o método Random Search é rápido e fácil de implementar, mas pode acabar repetindo hiperparâmetros já testados e, devido à seleção aleatória, pode não selecionar o melhor conjunto de hiperparâmetros para maximizar o aprendizado do modelo. Em próximas partes do projeto, abordaremos outras técnicas de ajuste de hiperparâmetros, como o Grid Search e a Bayesian Optimization."
      ],
      "metadata": {
        "id": "XJKa6G6ZQ3Km"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### • Grid Search\n",
        "Primeiro, falamos sobre a estratégia de Random Search (Busca Aleatória), que opera por meio de interações, selecionando aleatoriamente um valor para cada hiperparâmetro. Treina-se e testa-se o modelo com esses valores, geralmente usando a técnica de validação cruzada (Cross Validation) e registra-se a performance do modelo. Esse processo é repetido em diversas interações. No final, seleciona-se o conjunto de hiperparâmetros que resultou na melhor performance.\n",
        "\n",
        "Em seguida, discutimos o Grid Search (Busca em Grade), uma estratégia que, ao contrário do Random Search, não seleciona os valores aleatoriamente. O Grid Search procura encontrar o melhor conjunto de valores testando todas as combinações possíveis de hiperparâmetros. Para cada combinação, o modelo é treinado e testado, novamente utilizando a técnica de validação cruzada, e registra-se a performance. No final, escolhe-se o conjunto de hiperparâmetros que deu a melhor performance.\n",
        "\n",
        "No entanto, o Grid Search tem uma desvantagem significativa em relação ao tempo que leva para testar todas as combinações possíveis de hiperparâmetros. Esse tempo pode ser extenso, especialmente se houver muitos hiperparâmetros e se cada um puder assumir muitos valores possíveis. Em algumas situações, o Grid Search pode levar meses para completar, o que pode ser impraticável em muitos cenários de negócios.\n",
        "\n",
        "Ainda assim, vale ressaltar que o ajuste de hiperparâmetros, embora seja uma etapa importante no treinamento de um modelo de aprendizado de máquina, não é a única coisa que influencia a performance do modelo. Aspectos como a qualidade e a quantidade dos dados, a relevância das características (features) e a escolha do algoritmo adequado também são fatores críticos. Portanto, embora o ajuste de hiperparâmetros possa ajudar a melhorar a performance de um modelo, ele não deve ser visto como a solução definitiva para alcançar altos níveis de precisão."
      ],
      "metadata": {
        "id": "UYExjHDcVUZf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### • Bayesian Search\n",
        "O primeiro método, Random Search, escolhe valores aleatórios para os parâmetros do modelo, o que resulta numa execução rápida e de baixo custo. Contudo, a principal desvantagem é que, pela sua natureza aleatória, pode não identificar o melhor conjunto de parâmetros.\n",
        "\n",
        "Por outro lado, o Grid Search testa todas as combinações possíveis de parâmetros. Este método tem a vantagem de quase garantir a localização do melhor conjunto de parâmetros, maximizando a precisão do modelo. A desvantagem, no entanto, é o alto custo de tempo e recursos computacionais, o que pode não ser viável em todos os contextos empresariais.\n",
        "\n",
        "\n",
        "Usando a formulação bayesiana, nosso objetivo é encontrar a probabilidade de um determinado erro, dado que selecionamos um conjunto específico de valores para os parâmetros do modelo. No entanto, como não conhecemos antecipadamente os valores de parâmetros ideais, isso seria difícil de calcular. Aqui reside o cerne da busca bayesiana: ao invés de calcular a probabilidade do erro dado os parâmetros, calculamos a probabilidade dos parâmetros dado o erro.\n",
        "\n",
        "A vantagem principal da busca bayesiana é que ela é mais direcionada, baseando-se nos aprendizados anteriores para ajustar os parâmetros de forma mais eficiente. Isso a torna mais rápida que o Grid Search e mais precisa que o Random Search. A desvantagem é que o conceito pode ser um pouco complexo para compreender inicialmente, mas há uma vasta quantidade de literatura disponível para estudo.\n",
        "\n",
        "Concluindo, em nosso projeto, faremos uso do Random Search devido ao seu custo-benefício favorável e pela facilidade de implementação em qualquer algoritmo. No entanto, incentivamos a pesquisa e a compreensão das outras estratégias para expandir o seu conhecimento na área de aprendizado de máquina."
      ],
      "metadata": {
        "id": "eX9cNz9nVrMO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8.1. Random Search\n",
        "Em nosso projeto de previsão de vendas, estamos utilizando o algoritmo XGBoost para criar nosso modelo preditivo. Uma etapa crítica na construção de qualquer modelo de aprendizado de máquina é a seleção de hiperparâmetros. Esses hiperparâmetros incluem:\n",
        "\n",
        "- **n_estimators:** O número de árvores a serem construídas pelo modelo.\n",
        "eta: A taxa de aprendizado.\n",
        "- **max_depth:** A profundidade máxima de cada árvore.\n",
        "- **subsample:** A fração das amostras a serem usadas para ajustar os modelos de árvore individuais.\n",
        "- **colsample_bytree:** A fração de colunas a serem usadas em cada árvore.\n",
        "- **min_child_weight:** O peso mínimo necessário em uma folha.\n",
        "Para cada hiperparâmetro, definimos um conjunto de valores possíveis:"
      ],
      "metadata": {
        "id": "v-AR6Raqc-ex"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Definindo os hiperparâmetros para a busca aleatória (Random Search)\n",
        "param = {\n",
        "    # n_estimators refere-se ao número de árvores de decisão na floresta\n",
        "    'n_estimators' : [15, 17, 25, 30, 35],\n",
        "    # eta é a taxa de aprendizado\n",
        "    'eta': [0.01, 0.03],\n",
        "    # max_depth é a profundidade máxima das árvores\n",
        "    'max_depth': [3, 5, 9 ],\n",
        "    # subsample é a fração dos exemplos de treinamento a serem usados em cada árvore\n",
        "    'subsample': [0.1, 0.5, 0.7],\n",
        "    # colsample_bytree é a fração de colunas a serem usadas em cada árvore\n",
        "    'colsample_bytree': [0.3, 0.7, 0.9],\n",
        "    # min_child_weight é a soma mínima dos pesos de instância necessários em um filho\n",
        "    'min_child_weight': [3, 8, 15]\n",
        "}"
      ],
      "metadata": {
        "id": "pHLtlVvqk7g-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A busca aleatória é realizada para um número específico de iterações, definido pela variável MAX_EVAL. Para cada iteração, um conjunto de hiperparâmetros é selecionado aleatoriamente e utilizado para treinar um modelo XGBoost. O desempenho desse modelo é então avaliado através da validação cruzada.\n",
        "\n",
        "Aqui está a estrutura básica do nosso código para a busca aleatória:"
      ],
      "metadata": {
        "id": "XRjIQi92k9Uz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "MAX_EVAL = 2\n",
        "\n",
        "final_resulta = pd.DataFrame()\n",
        "\n",
        "for i in range(MAX_EVAL):\n",
        "  # Escolhe valores para parâmetros de forma aleatória\n",
        "  hp = {k: random.sample(v, 1)[0] for k, v in param.items()}\n",
        "  print(hp)\n",
        "\n",
        "  # Inicializando o modelo XGBoost com os hiperparâmetros selecionados\n",
        "  model_xgb = xgb.XGBRegressor( objective        = 'reg:squarederror',\n",
        "                                n_estimators     = hp['n_estimators'],\n",
        "                                eta              = hp['eta'],\n",
        "                                max_depth        = hp['max_depth'],\n",
        "                                subsample        = hp['subsample'],\n",
        "                                colsample_bytree = hp['colsample_bytree'],\n",
        "                                min_child_weight = hp['min_child_weight'])\n",
        "  # Avalia a performance do modelo utilizando validação cruzada\n",
        "  result = cross_validation(x_training, 2, 'XGBoost Regressor', model_xgb, verbose=False)\n",
        "  final_result = pd.concat([final_result, result])\n",
        "\n",
        "final_result"
      ],
      "metadata": {
        "id": "W2RmLnS_E0zI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Atenção!\n",
        "Após a execução das iterações de otimização, é fundamental analisar os resultados para identificar a melhor combinação de hiperparâmetros. Cada iteração é composta por uma combinação única de hiperparâmetros que foram selecionados aleatoriamente, resultando em uma performance diferente para cada iteração.\n",
        "\n",
        "Na primeira iteração, foram escolhidos determinados valores para os hiperparâmetros, enquanto que na segunda iteração, outros valores foram selecionados. A performance do modelo foi calculada para cada conjunto de hiperparâmetros.\n",
        "\n",
        "Para determinar qual iteração forneceu a melhor performance, a métrica Root Mean Square Error (RMSE) foi usada para comparar os resultados. Esta métrica é comumente usada para avaliar a performance de modelos de previsão, pois fornece uma quantificação do erro do modelo, ou seja, a diferença entre os valores previstos pelo modelo e os valores reais.\n",
        "\n",
        "No caso analisado, a segunda iteração apresentou um valor de RMSE menor do que a primeira iteração. Isto indica que o conjunto de hiperparâmetros selecionado na segunda iteração resultou em um modelo com uma melhor performance.\n",
        "\n",
        "Portanto, na prática, o cientista de dados anotaria os valores dos hiperparâmetros da segunda iteração, pois são esses que proporcionaram a melhor performance, de acordo com a métrica RMSE.\n",
        "\n",
        "Este passo é crucial para a construção de um projeto de previsão de vendas, pois permite identificar e selecionar os hiperparâmetros que otimizam a performance do modelo, melhorando assim a precisão das previsões de vendas."
      ],
      "metadata": {
        "id": "-nQO94EqZugM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8.2. Final Model\n",
        "Após a realização do processo de otimização dos hiperparâmetros do nosso modelo de previsão de vendas, identificamos que o conjunto de parâmetros da segunda iteração foi o que ofereceu a melhor performance, segundo a métrica RMSE.\n",
        "\n",
        "Deste modo, selecionamos os valores otimizados para os hiperparâmetros da seguinte maneira:"
      ],
      "metadata": {
        "id": "t2cI0fp4ofei"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definindo hiperparâmetros otimizados\n",
        "param_tuned = {\n",
        "          'n_estimators'    : 30,\n",
        "          'eta'             : 0.03,\n",
        "          'max_depth'       : 9,\n",
        "          'subsample'       : 0.1,\n",
        "          'colsample_bytree': 0.7,\n",
        "          'min_child_weight': 15.\n",
        "}"
      ],
      "metadata": {
        "id": "8UQeD62yokPv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Em seguida, o modelo XGBoost foi treinado com os hiperparâmetros otimizados e os dados de treinamento. As previsões foram geradas usando o conjunto de dados de teste."
      ],
      "metadata": {
        "id": "G_CfiJA8qru1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Modelo\n",
        "model_xgb_tuned = xgb.XGBRegressor( objective        = 'reg:squarederror',\n",
        "                                    n_estimators     = param_tuned['n_estimators'],\n",
        "                                    eta              = param_tuned['eta'],\n",
        "                                    max_depth        = param_tuned['max_depth'],\n",
        "                                    subsample        = param_tuned['subsample'],\n",
        "                                    colsample_bytree = param_tuned['colsample_bytree'],\n",
        "                                    min_child_weight = param_tuned['min_child_weight']).fit(x_train, y_train)\n",
        "\n",
        "# Predição\n",
        "yhat_xgb_tuned = model_xgb_tuned.predict(x_test)"
      ],
      "metadata": {
        "id": "ksNRaY72pC6h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finalmente, a performance do modelo otimizado foi avaliada utilizando o método 'ml_error'. Este método compara os valores reais das vendas ('y_test') com as previsões geradas pelo modelo ('yhat_xgb_tuned'). A função exponencial foi aplicada a ambos os conjuntos para reverter o logaritmo aplicado em etapas anteriores do projeto."
      ],
      "metadata": {
        "id": "vhpb8FN2oil4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Performance\n",
        "xgb_result_tuned = ml_error('XGBoost Regressor', np.expml(y_test), np.expml(yhat_xgb_tuned))\n",
        "xgb_result_tuned"
      ],
      "metadata": {
        "id": "QvaviykEq0HL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Com isso, temos um modelo otimizado com valores de hiperparâmetros que deverão oferecer uma previsão de vendas mais precisa. Cada hiperparâmetro ajustado tem um impacto significativo no desempenho do modelo, e é por isso que o processo de otimização é uma etapa crucial na construção de um projeto de previsão de vendas.\n",
        "\n",
        "Com a definição desses valores, seguimos para a etapa de treinamento e validação do nosso modelo de previsão, sempre com o objetivo de melhorar a precisão e a confiabilidade das nossas previsões de vendas."
      ],
      "metadata": {
        "id": "XkJMz39tq2Az"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Rossmann Project Status\n",
        "Chegamos finalmente no estamos na etapa 9 do nosso projeto de previsão de vendas, onde vamos tratar de um assunto extremamente importante: a **interpretação e tradução do erro**. Esse passo nos ajudará a entender como a performance do nosso modelo de machine learning se converte em resultados concretos para o nosso negócio. Ou seja, vamos descobrir como dizer ao chefe quanto dinheiro nosso modelo pode trazer, e o que uma acurácia de 70% realmente significa em termos financeiros, em número de novos clientes, e assim por diante.\n",
        "\n",
        "Mas, antes de mergulhar nisso, vamos atualizar nosso progresso no projeto para garantir que todos estejam na mesma página.\n",
        "\n",
        "Então, o nosso primeiro passo foi entender a questão do negócio, o problema real que estamos tentando resolver. Com base nessa compreensão, fizemos uma coleta de dados cuidadosa, utilizando SQL para fornecer a base para nossos modelos.\n",
        "\n",
        "O próximo passo foi a limpeza dos dados. Antes de fazer qualquer coisa com nossos dados, precisávamos ter certeza de que eles estavam em boas condições - sem outliers indesejados ou valores que precisavam ser substituídos.\n",
        "\n",
        "Depois disso, era hora de realmente entender os dados que tínhamos. Fizemos várias análises, validamos nossas hipóteses e adquirimos uma compreensão clara do problema e do negócio.\n",
        "\n",
        "Com nossos dados compreendidos e limpos, o próximo passo foi prepará-los para a modelagem. Isso envolveu a transformação dos dados para adequá-los aos modelos de machine learning, que nem sempre lidam bem com variáveis categóricas ou outras características dos nossos dados brutos.\n",
        "\n",
        "Então, foi hora de treinar nossos modelos. Implementamos vários algoritmos, desde modelos lineares a não lineares, e comparamos a performance deles com um modelo baseline para avaliar o desempenho de cada um.\n",
        "\n",
        "Agora, chegamos ao ponto em que estamos prontos para avaliar nosso algoritmo. Vamos olhar para a performance do nosso modelo e avaliar o impacto que ele pode ter no negócio. Se a performance for boa o suficiente, colocamos o modelo em produção. Se não, fazemos ajustes e iteramos até que estejamos satisfeitos.\n",
        "\n",
        "Lembre-se, ao longo desse projeto, nosso objetivo é resolver um problema real de negócios. A ciência de dados e o machine learning são ferramentas que estamos usando para fazer isso, mas o verdadeiro valor vem de aplicá-los de maneira eficaz para melhorar nosso negócio.\n",
        "\n",
        "Então, vamos continuar com a avaliação do nosso algoritmo e ver o que descobrimos.\n"
      ],
      "metadata": {
        "id": "8WYAMykAX100"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## 9.0 Error Translation and Interpretation\n",
        "O projeto de previsão de vendas demanda a condução de uma avaliação meticulosa do erro e a correção da escala dos dados. Neste artigo, vamos abordar ambas essas tarefas importantes, focando na clareza e precisão para facilitar a compreensão por indivíduos não familiarizados com o campo técnico da ciência de dados.\n",
        "\n",
        "Para avaliar o erro, primeiramente é necessário selecionar as colunas pertinentes do conjunto de testes (X_test), que foram identificadas durante a etapa de seleção de características (feature selection), utilizando a técnica de Boruta. Essas colunas são armazenadas na variável cols_selected_boruta_full. Além disso, colunas como 'date' (data) e 'sales' (vendas) são usadas no processo, visto que desempenharam papéis cruciais na validação cruzada (cross-validation)."
      ],
      "metadata": {
        "id": "1As4iN-perwY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df9 = X_test[cols_selected_boruta_full]"
      ],
      "metadata": {
        "id": "ChgZiRyISYSS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Depois de ter os dados necessários para calcular o erro, é preciso lembrar que os dados foram transformados para a escala logarítmica para o modelo de previsão. Portanto, eles precisam ser revertidos para a escala original para que o erro possa ser calculado na mesma escala dos dados originais.\n",
        "\n",
        "Essa reversão é realizada através da aplicação da transformação exponencial, que é a inversa da transformação logarítmica. A biblioteca NumPy oferece um método conveniente para isso, np.expm1(), que é aplicado tanto nas vendas quanto nas previsões feitas pelo modelo."
      ],
      "metadata": {
        "id": "W5u0tV-USbVy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# rescale\n",
        "df9['sales'] = np.expm1(df9['sales'])\n",
        "df9['predictions'] = np.expm1(yhat_xgb_tuned)"
      ],
      "metadata": {
        "id": "j6VtskGtSciE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neste ponto, as vendas previstas ('predictions') são derivadas de yhat_xgb_tuned, que são as previsões feitas pelo modelo de aprendizado de máquina otimizado ('tuned').\n",
        "\n",
        "Em suma, esses passos são cruciais para avaliar corretamente o erro do modelo de previsão e garantir que os dados estejam na escala correta para a interpretação dos resultados e tomada de decisões empresariais."
      ],
      "metadata": {
        "id": "EaP5-j0oSepq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 9.1 Business Performance\n",
        "O principal objetivo é traduzir os resultados das análises de dados em termos que possam ser facilmente compreendidos pelo time de negócios. Portanto, em vez de apenas apresentar métricas de acurácia do modelo, procuramos apresentar as informações de forma que correlacionem diretamente com o impacto financeiro da empresa.\n",
        "\n",
        "Primeiro, é importante sumarizar as predições de vendas para cada loja, pois estamos interessados no valor total previsto de vendas para cada uma delas. Para fazer isso, criamos uma nova variável, df91, que contém as somas das predições para cada loja."
      ],
      "metadata": {
        "id": "2rbXorvk35G8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df91 = df9[['store', 'predictions']].groupby('store').sum().reset_index()"
      ],
      "metadata": {
        "id": "gP7FEoKZTpaP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Em seguida, calculamos o erro médio absoluto (MAE) e o erro percentual absoluto médio (MAPE) para cada loja. Essas métricas são importantes para entender o desempenho do modelo em termos de negócios. O MAE indica o erro absoluto de cada previsão, enquanto o MAPE representa esse erro em termos percentuais."
      ],
      "metadata": {
        "id": "yhentA_8TrKU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df9_aux1 = df9[['store', 'sales', 'predictions']].groupby('store').apply(lambda x: mean_absolute_error(x['sales'], x['predictions'])).reset_index().rename(columns = {0: 'MAE'})\n",
        "df9_aux2 = df9[['store', 'sales', 'predictions']].groupby('store').apply(lambda x: mean_absolute_percentage_error(x['sales'], x['predictions'])).reset_index().rename(columns = {0: 'MAPE'})"
      ],
      "metadata": {
        "id": "SQC0fis_TsjI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Em seguida, combinamos essas métricas em um único dataframe para facilitar a análise."
      ],
      "metadata": {
        "id": "ywoGea9YTuwo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df9_aux3 = pd.merge(df9_aux1,  df9_aux2, how = 'inner', on = 'store')\n",
        "df92 = pd.merge(df91, df9_aux3, how = 'inner', on = 'store')"
      ],
      "metadata": {
        "id": "0Ei6venrTy6a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Com isso, é possível fornecer ao time de negócios uma previsão de vendas, juntamente com o MAE e o MAPE para cada loja. Além disso, calculamos o melhor e o pior cenário para as previsões, subtraindo e adicionando o MAE, respectivamente, ao valor previsto. Isso permite que o time de negócios tenha uma ideia mais concreta dos possíveis resultados.\n",
        "\n",
        "O nosso objetivo é calcular a receita total das próximas seis semanas para cada loja. Nesse cálculo, estamos levando em conta todas as vendas que serão realizadas no período indicado.\n",
        "\n",
        "Contudo, é importante notar que toda previsão possui um certo grau de erro, algo inerente a qualquer modelo preditivo. Por exemplo, para a Loja 1, identificamos no MAE um erro de 306 unidades na previsão. Isso representa 7% das vendas reais que esta loja faz em média.\n",
        "\n",
        "Vamos considerar um outro exemplo. Para a Loja 4, a previsão é de que serão vendidos 345 mil reais nas próximas seis semanas. Mas é preciso considerar que este valor pode conter um erro de 855 unidades, o que corresponde a 8% do total.\n",
        "\n",
        "Aqui, estamos falando do Erro Médio Absoluto (MAE), que é uma medida que quantifica a média dos erros absolutos entre as previsões e as observações reais. Ele é útil para entender o quão próximas (ou distantes) estão as previsões da realidade, podendo o erro ser tanto positivo quanto negativo.\n",
        "\n",
        "Assim, ao apresentar a previsão de vendas, o que pretendemos é oferecer também a margem de erro, ou seja, o pior e o melhor cenário possível. Isto permite que o gestor da loja faça uma análise mais completa, considerando a variação que pode ocorrer nas vendas. Por exemplo, uma previsão de vendas de 162 mil reais pode apresentar uma margem de erro de 7%. Parece razoável? Então, o gestor precisa considerar qual é a variação possível para essa previsão, ou seja, quais são os cenários mais otimista e pessimista que poderiam ocorrer."
      ],
      "metadata": {
        "id": "uYQSK_O0UcU2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df92['worst_scenario'] = df92['predictions'] - df92['MAE']\n",
        "df92['best_scenario'] = df92['predictions'] + df92['MAE']\n",
        "df92 = df92[['store', 'predictions', 'worst_scenario', 'best_scenario', 'MAE', 'MAPE']]"
      ],
      "metadata": {
        "id": "8oZFzny6UaOa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df92.sample()"
      ],
      "metadata": {
        "id": "1yMI_xIqZI7g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para tornar isso compreensível, vamos considerar a loja 638 como exemplo. Segundo as nossas projeções, esperamos gerar uma receita de 232.000 reais nas próximas seis semanas. No entanto, é importante lembrar que toda previsão tem um certo grau de erro. Neste caso, o erro é de 6%. Isso significa que se tivéssemos uma previsão de venda média de 100 reais, na realidade poderíamos vender entre 94 e 106 reais. Essa diferença de 6% representa um valor de 437 reais. Portanto, no pior cenário, venderíamos 232.000 reais e no melhor, 233.000 reais.\n",
        "\n",
        "Tal análise ajuda o gestor da loja a tomar uma decisão mais informada. Se o erro do modelo é relativamente baixo, por exemplo, 7%, o gestor pode se inclinar para o cenário mais otimista. Se o erro é maior, como 18% para a loja 642, o gestor pode preferir o cenário mais pessimista.\n",
        "\n",
        "A chave para fazer essa transição entre as métricas do modelo de machine learning e o mundo dos negócios é traduzir os termos técnicos para uma linguagem mais compreensível. Ao invés de discutir sobre o Erro Médio Absoluto (MAE), é mais produtivo discutir em termos de receita, melhores e piores cenários, e a porcentagem de erro.\n",
        "\n",
        "É importante esclarecer porque não usamos a métrica de acurácia em previsões de regressão. Acurácia é geralmente utilizada em problemas de classificação, como distinguir entre fotos de gatos e cachorros. Em uma previsão de regressão, como a que estamos trabalhando, estamos interessados em quão próximas nossas previsões estão do valor real. Para medir isso, usamos o erro, que nos diz quão distantes estamos do valor real. Portanto, a acurácia não é apropriada nesse caso, pois estamos trabalhando com valores próximos do real, como 98, 100, ou 102, e não com valores binários de sim ou não.\n",
        "\n",
        "Em resumo, o que importa é entender o quão próximas as previsões estão do valor real e quão certo o algoritmo está sobre o valor. Quanto mais próximo de zero o erro, mais confiável a previsão. Quanto maior o erro, menos confiável. Portanto, a chave para uma boa comunicação entre os cientistas de dados e os gestores de negócios é traduzir as métricas de performance do modelo para termos de negócio compreensíveis.\n",
        "\n",
        "No processo de desenvolvimento de um projeto de previsão de vendas, encontramos algumas lojas que são mais desafiadoras em termos de previsão. Por exemplo, podemos observar que temos um erro percentual absoluto médio (MAPE) de 7% para a loja 932 e 18% para a loja 642. Essa variação indica que algumas lojas podem ser mais difíceis de prever do que outras.\n",
        "\n",
        "Uma forma eficaz de visualizar isso é ordenar os dados de acordo com o valor do MAPE. Para fazer isso, utilizamos um comando de classificação em nosso dataframe 'df92'. Queremos ordenar os dados de forma decrescente para ver as lojas com os maiores erros de previsão primeiro. Portanto, a sintaxe do código seria a seguinte:"
      ],
      "metadata": {
        "id": "gSuSgRw8awIL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df92.sort_values('MAPE', ascending = False).head()"
      ],
      "metadata": {
        "id": "31uyK5DucBWP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "descobrimos que a loja 292 possui um Erro Percentual Absoluto Médio (MAPE) de 56%, indicando que nossas previsões para esta loja podem estar off em mais da metade do valor real. Isso é bastante significativo, pois um erro de 50% poderia significar uma previsão que está 50% acima ou abaixo do valor real.\n",
        "\n",
        "Este cenário claramente requer estratégias alternativas para melhorar a precisão das previsões. Poderíamos, por exemplo, criar modelos específicos para as lojas que apresentam maior desafio, ou incluir mais variáveis em nossos modelos existentes para melhor compreender a complexidade dessas lojas específicas.\n",
        "\n",
        "Para visualizar estas diferenças entre as lojas, podemos usar um gráfico de dispersão (scatterplot). No eixo x, colocamos as lojas ('store') e, no eixo y, o valor do MAPE. Cada ponto no gráfico representa uma loja, e a posição do ponto ao longo do eixo y indica o valor do MAPE para essa loja. O código seria o seguinte:"
      ],
      "metadata": {
        "id": "1zCbLARgY8ST"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(x='store', y='MAPE', data=df92)"
      ],
      "metadata": {
        "id": "k4Opn0VofCHr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No gráfico gerado, vemos que, embora a maioria das lojas tenha um MAPE em torno de 10%, existem outliers significativos, como as lojas 292 e 900, que têm um MAPE maior que 50%. Algumas lojas também apresentam um MAPE em torno de 30%. Essa visualização fornece uma visão clara das lojas que exigem maior atenção para melhorar nossas previsões de vendas."
      ],
      "metadata": {
        "id": "DcPjcwXRY8Or"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 9.2 Total Performance\n",
        "Para fornecer uma visão geral da previsão de vendas, é útil resumir os melhores e piores cenários para todas as lojas. Isso pode ser útil, por exemplo, para fornecer uma visão geral rápida para os stakeholders do projeto.\n",
        "\n",
        "Primeiro, extraímos três colunas do nosso dataframe 'df92', que são 'predictions', 'worst_scenario', e 'best_scenario'. Essas colunas contêm nossas previsões, bem como os piores e melhores cenários de vendas, respectivamente.\n",
        "\n",
        "Em seguida, aplicamos uma função lambda para somar todos os valores de cada uma dessas colunas. A função 'apply' é usada junto com a função 'lambda', que percorre e soma os valores ao longo do eixo zero (ou seja, somando os valores de cada linha para cada coluna). O resultado é um novo dataframe 'df93', onde cada linha representa um cenário e a soma total de valores para esse cenário.\n",
        "\n",
        "Depois disso, redefinimos o índice do dataframe para facilitar a leitura e renomeamos as colunas para 'Scenario' e 'Values'.\n",
        "\n",
        "Finalmente, formatamos a coluna 'Values' para exibir os valores em formato de moeda real brasileira (R$). Isso torna os resultados mais legíveis e fornece uma visão clara do valor total previsto para cada cenário. O código é o seguinte:"
      ],
      "metadata": {
        "id": "q6JCdg-lSEq3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "NpoU9lqVY8Iv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "v636lXARY8E2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Fazendo a soma para as colunas 'predictions', 'worst_scenario', 'best_scenario'\n",
        "df93 = df92[['predictions', 'worst_scenario', 'best_scenario']].apply(lambda x: np.sum(x), axis = 0).reset_index().rename(columns = {'index': 'Scenario', 0: 'Values'})\n",
        "\n",
        "# Formatando a coluna 'Values' para exibir os valores em formato de moeda\n",
        "df93['Values'] = df93['Values'].map('R${:,.2f}'.format)\n",
        "\n",
        "# Visualizando o dataframe df93\n",
        "df93"
      ],
      "metadata": {
        "id": "8BCHKnhyYT4R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nosso dataframe 'df93' agora nos permite visualizar as previsões para as próximas seis semanas em todas as lojas.\n",
        "\n",
        "Nas previsões, esperamos fazer vendas de R285 milhões. No pior cenário, projetamos vendas de R285 milhões e 115 mil. No melhor cenário, a previsão sobe para R$286 milhões e 605 mil. É importante lembrar que, apesar da tentação de subtrair um cenário de outro para determinar a acurácia, isso não é apropriado neste contexto, pois a \"acurácia\" é um termo melhor aplicado a problemas de classificação, não de regressão.\n",
        "\n",
        "Após essas etapas, queremos visualizar os dados em gráficos. Ao trabalhar com dados, especialmente em um projeto de ciência de dados, a visualização gráfica pode ser uma ferramenta extremamente útil. Os gráficos não só nos permitem entender melhor os dados, como também são uma forma eficaz de comunicar nossas descobertas a outras pessoas, especialmente aquelas que não têm experiência técnica no assunto."
      ],
      "metadata": {
        "id": "3m9Vwzy_TyS2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 9.3 Machine Learning Performance\n",
        "Neste etapa criamos duas colunas que visam facilitar a construção de gráficos para análise dos resultados. Essas colunas, denominadas 'error' e 'error_rate', são calculadas da seguinte maneira:"
      ],
      "metadata": {
        "id": "Pg29BOI4iUwF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df9['error'] = df9['sales'] - df9['predictions']\n",
        "df9['error_rate'] = df9['predictions'] / df9['sales']"
      ],
      "metadata": {
        "id": "vamvIkpxSDUO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O 'error' representa a diferença entre as vendas reais e as vendas previstas, enquanto o 'error_rate' é a proporção das previsões em relação às vendas reais.\n",
        "\n",
        "Utilizamos quatro gráficos distintos para a visualização e interpretação dos dados. O código abaixo descreve a geração desses gráficos:"
      ],
      "metadata": {
        "id": "FbHEr73YiiqL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(2, 2, 1)\n",
        "sns.lineplot(x = 'date', y = 'sales', data = df9, label = 'SALES')\n",
        "sns.lineplot(x = 'date', y = 'predictions', data = df9, label = 'PREDICTIONS')\n",
        "\n",
        "plt.subplot(2, 2, 2)\n",
        "sns.lineplot(x = 'date', y = 'error_rate', data = df9)\n",
        "\n",
        "plt.subplot(2, 2, 3)\n",
        "sns.distplot(df9['error'])\n",
        "\n",
        "plt.subplot(2, 2, 4)\n",
        "sns.scatterplot(df9['predictions'], df9['error'])"
      ],
      "metadata": {
        "id": "opi4ppxgSGNV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No primeiro gráfico, usamos linhas para traçar as vendas e as previsões ao longo do tempo. O gráfico ilustra a proximidade entre as vendas e as previsões durante um período de seis semanas, mostrando que a previsão se mantém próxima das vendas.\n",
        "\n",
        "O segundo gráfico é um line plot do 'error_rate' ao longo do tempo. Este gráfico ajuda a visualizar o desempenho do modelo. Se o 'error_rate' for igual a um, significa que a previsão é perfeita. Se for maior que um, o modelo está superestimando as vendas, e se for menor que um, está subestimando.\n",
        "\n",
        "O terceiro gráfico é um 'distplot' que mostra a distribuição do erro. Uma distribuição próxima da normal é um bom indicativo, sugerindo que o erro está bem distribuído.\n",
        "\n",
        "O quarto e último gráfico é um 'scatterplot' de previsões versus erros. Este gráfico é importante na análise de resíduos, um método utilizado para identificar pontos fracos no modelo e orientar aprimoramentos futuros.\n",
        "\n",
        "Esses gráficos e cálculos servem como uma tradução do erro do modelo para a performance de negócio, facilitando a compreensão e análise por profissionais da área."
      ],
      "metadata": {
        "id": "WoxRudZSinTn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Rossmann Project Status\n",
        "O projeto de previsão de vendas teve dez etapas principais, baseadas na metodologia CRISP-DM. As etapas seguem uma linha lógica de desenvolvimento, desde a compreensão do negócio até a implantação do modelo final. Aqui está uma descrição mais detalhada de cada etapa:\n",
        "\n",
        "1. **Definição da questão de negócio:** Gerentes de lojas precisavam prever as vendas das próximas seis semanas para orçamentar reformas. Entender essa necessidade foi fundamental para alinhar o projeto à estratégia do negócio.\n",
        "\n",
        "2. **Entendimento do negócio:** Antes de começar qualquer atividade técnica, houve um esforço para entender a natureza do problema. Isso envolveu conversas com as partes interessadas para compreender a essência do problema.\n",
        "\n",
        "3. **Coleta de dados:** O conjunto de dados para este projeto foi baixado da plataforma Kaggle. Na prática, essa etapa poderia envolver a coleta de dados de vários sistemas e bancos de dados, mas neste caso, o foco estava em um conjunto de dados mais próximo do ambiente real de trabalho.\n",
        "\n",
        "4. **Limpeza dos dados:** Esta etapa envolveu a descrição dos dados para obter um resumo geral do que está sendo enfrentado. Depois, novas variáveis foram criadas a partir das originais (feature engineering) e os dados foram filtrados com base em seu significado antes de começar qualquer desenvolvimento.\n",
        "\n",
        "5. **Exploração de dados:** A análise exploratória de dados foi feita para entender o negócio do ponto de vista dos dados e encontrar as variáveis que poderiam ser relevantes para o modelo. Isso envolveu a análise univariada, bivariada e multivariada, e a validação das hipóteses.\n",
        "\n",
        "6. **Preparação dos dados:** Depois de explorar os dados, foi necessário prepará-los para o aprendizado de máquina. As variáveis categóricas foram codificadas para numéricas e outras transformações foram aplicadas. Em seguida, as variáveis relevantes foram selecionadas usando o algoritmo Boruta.\n",
        "\n",
        "7. **Modelagem:** Nessa etapa, cinco algoritmos de aprendizado de máquina foram implementados, incluindo algoritmos lineares e não lineares. A performance de cada um foi calculada e comparada.\n",
        "\n",
        "8. **Avaliação do modelo:** O desempenho dos modelos foi avaliado usando validação cruzada para obter uma medição real da performance.\n",
        "\n",
        "9. **Interpretação do resultado do modelo:** O erro do modelo foi analisado do ponto de vista de performance e traduzido em termos de impacto no negócio. A ideia era entender quanto valor o modelo poderia trazer para o negócio em termos financeiros, aquisição de clientes ou redução de custos.\n",
        "\n",
        "10. **Implantação do modelo (deploy):** O modelo foi colocado em um ambiente de produção na nuvem para ser acessado por usuários. A ideia aqui era permitir que o modelo fosse usado para gerar previsões úteis para a empresa.\n",
        "\n",
        "Lembrando que o objetivo principal do primeiro ciclo do CRISP-DM é entregar uma primeira versão da solução o mais rápido possível, para que as partes interessadas entendam o valor do Machine Learning. Após esta entrega inicial, feedbacks são coletados e utilizados para refinar o modelo em iterações futuras."
      ],
      "metadata": {
        "id": "6ti9Ksm116Eg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 10.0 Model Deployment in Production\n",
        "No contexto de um projeto de previsão de vendas, uma das etapas essenciais é a implementação do modelo em um ambiente de produção. Isso torna as predições do modelo acessíveis a qualquer consumidor, que pode ser um indivíduo, um aplicativo móvel, um site, ou qualquer software conectado à Internet.\n",
        "\n",
        "### • Termos Importantes\n",
        "\n",
        "- **API (Application Programming Interface):** Em termos simplificados, uma API é um contrato entre duas partes de software, que especifica como elas devem interagir entre si. A API é como um manual de utilização que especifica funções e métodos que podem ser utilizados para interagir com o software.\n",
        "\n",
        "- **Request (Requisição):** Uma requisição é um pedido de dados a uma API. É como o software 'solicita' uma interação com o software do outro lado.\n",
        "\n",
        "- **EndPoint (Ponto de Acesso):** Este é basicamente o URL ou o endereço da API. É onde a requisição é enviada.\n",
        "\n",
        "- **Deploy (Implementação):** Este termo refere-se ao ato de mover o software de um ambiente de desenvolvimento para um ambiente de produção, geralmente hospedado na nuvem, onde ele pode ser acessado por qualquer dispositivo conectado à Internet.\n",
        "\n",
        "### • Ciclo de Desenvolvimento\n",
        "\n",
        "- **Ambiente Local:** Este é o ambiente de desenvolvimento local, geralmente o computador do desenvolvedor.\n",
        "\n",
        "- **Ambiente de Produção:** Estes são servidores que geralmente são hospedados na nuvem, que fornecem serviços ou dados aos usuários.\n",
        "\n",
        "- **Ambiente de Desenvolvimento:** Este é uma cópia idêntica do ambiente de produção, mas é mais controlado e não é acessível ao público. É onde os desenvolvedores testam suas alterações antes de serem aplicadas no ambiente de produção.\n",
        "\n",
        "\n",
        "### • Arquitetura de Produção\n",
        "\n",
        "Na arquitetura de produção de nosso modelo de previsão de vendas, temos três componentes principais:\n",
        "\n",
        "- **Handler (Manipulador):** Este é o componente que recebe as requisições dos usuários e as encaminha para o modelo de aprendizado de máquina.\n",
        "\n",
        "- **Data Preparation (Preparação de Dados):** Este componente é responsável por preparar os dados para a entrada no modelo de aprendizado de máquina. Isto envolve a realização de todas as transformações e limpezas de dados necessárias, assim como a criação de variáveis. Este componente é crucial para garantir que os dados do mundo real estejam na mesma forma que os dados usados para treinar o modelo.\n",
        "\n",
        "- **Modelo de Aprendizado de Máquina Treinado:** Este é o coração da previsão de vendas. Depois de receber os dados preparados pelo componente de Preparação de Dados, este modelo faz a previsão e retorna os resultados ao Handler, que então os envia ao usuário que fez a requisição.\n",
        "\n",
        "Este projeto será desenvolvido em etapas sequenciais. Primeiramente, será realizado um desenvolvimento local. Em seguida, o modelo será testado em um ambiente de desenvolvimento que simula o ambiente de produção. Finalmente, o modelo será implantado no ambiente de produção, onde estará acessível aos usuários."
      ],
      "metadata": {
        "id": "HdwpQNKU2Cck"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **10.1 Rossmann Class**\n",
        "O projeto está centrado em uma classe específica - a classe Rosmann - que comporta todas as limpezas, transformações e codificações aplicadas durante o treinamento do modelo. Esta classe é essencial para garantir a consistência quando aplicamos o modelo a novos dados recebidos.\n",
        "\n",
        "Vamos começar salvando nosso modelo treinado. Para isso, usamos a biblioteca Python pickle, que permite serializar o modelo em um arquivo único. Este arquivo pode ser salvo e posteriormente descompactado para uso em produção. O código para esta etapa é:"
      ],
      "metadata": {
        "id": "6YUkG-TWqQNH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pickle\n",
        "\n",
        "# Salvar o modelo treinado\n",
        "pickle.dump(model_xgb_tuned, open('.../model_rossmann.pkl', 'wb'))"
      ],
      "metadata": {
        "id": "DHC5VnRfqoyn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Além do modelo, precisamos também salvar os parâmetros de transformação utilizados nos dados durante o treinamento. Isso é importante para garantir que aplicaremos as mesmas transformações aos novos dados que chegam, mantendo assim a consistência.\n",
        "\n",
        "### **5.1 Normalização (Retornar)**\n",
        "\n",
        "Os parâmetros de transformação foram aplicados usando a biblioteca de escalonamento RobustScaler e MinMaxScaler. Em nossa classe Rosmann, por exemplo, aplicamos RobustScaler na variável competition_distance, e usamos pickle para salvar esta transformação:"
      ],
      "metadata": {
        "id": "F0j_3LkqraVk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import RobustScaler, MinMaxScaler\n",
        "\n",
        "# Redimensionamento\n",
        "rs = RobustScaler()\n",
        "mms = MinMaxScaler()\n",
        "\n",
        "# Distância da competição\n",
        "df5['competition_distance'] = rs.fit_transform(df5[['competition_distance']].values)\n",
        "pickle.dump(rs, open('parameter/encoding_competition_distance.pkl', 'wb'))"
      ],
      "metadata": {
        "id": "BVRVCthHrgjy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Repetimos esse processo para as variáveis competition_time_month e promo_time_week, aplicando a transformação RobustScaler e salvando cada uma delas usando pickle:"
      ],
      "metadata": {
        "id": "fD628BLKrmBV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tempo de competição do mês\n",
        "df5['competition_time_month'] = rs.fit_transform(df5[['competition_time_month']].values)\n",
        "pickle.dump(rs, open('parameter/encoding_competition_time_month.pkl', 'wb'))\n",
        "\n",
        "# Semana promocional\n",
        "df5['promo_time_week'] = rs.fit_transform(df5[['promo_time_week']].values)\n",
        "pickle.dump(rs, open('parameter/encoding_promo_time_week.pkl', 'wb'))"
      ],
      "metadata": {
        "id": "xbY7-DvkrnUI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para a variável year, aplicamos a transformação MinMaxScaler:"
      ],
      "metadata": {
        "id": "r1yx-FzzrpUz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ano\n",
        "df5['year'] = mms.fit_transform(df5[['year']].values)"
      ],
      "metadata": {
        "id": "2lxgrn_osPFm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **5.3 Encoding (Retornar)**\n",
        " Esta etapa é essencial para converter dados categóricos em um formato que possa ser melhor compreendido e utilizado pelos modelos de aprendizado de máquina.\n",
        "\n",
        "O processo de codificação inclui diferentes técnicas, dependendo da natureza das variáveis categóricas. Neste projeto, usamos três métodos: one-hot encoding, label encoding e ordinal encoding.\n",
        "\n",
        "No caso da variável state_holiday, utilizamos a técnica de one-hot encoding. Esta técnica cria novas colunas correspondentes a cada categoria única na variável original. Cada uma dessas novas colunas contém apenas os valores 0 ou 1, indicando a presença ou ausência da categoria em questão na entrada original. O código para essa etapa é:"
      ],
      "metadata": {
        "id": "Wb2YeaeCsQoZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# One hot encoding para 'state_holiday'\n",
        "df5 = pd.get_dummies(df5, prefix = ['state_holiday'], columns = ['state_holiday'])"
      ],
      "metadata": {
        "id": "xuFZr7EwtonE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para a variável store_type, utilizamos a técnica de label encoding. Esta técnica substitui cada categoria única na variável original por um valor inteiro único. Este método é útil quando as categorias não têm uma ordem específica. Utilizamos a classe LabelEncoder da biblioteca sklearn.preprocessing para essa tarefa e salvamos o codificador para uso futuro:"
      ],
      "metadata": {
        "id": "aLQ_qDxNtrLP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "import pickle\n",
        "\n",
        "# Label Encoding para 'store_type'\n",
        "le = LabelEncoder()\n",
        "df5['store_type'] = le.fit_transform(df5['store_type'])\n",
        "pickle.dump(le, open('parameter/store_type_scaler', 'wb'))"
      ],
      "metadata": {
        "id": "1Ysyc8bGtsf0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finalmente, para a variável assortment, utilizamos a técnica de ordinal encoding. Esta técnica é útil quando as categorias têm uma ordem específica. Nesse caso, mapeamos cada categoria para um valor inteiro único, seguindo a ordem desejada:"
      ],
      "metadata": {
        "id": "BmjVHsrZtv8l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ordinal encoding para 'assortment'\n",
        "assortment_dict = {'basic':1, 'extra':2, 'extended':3}\n",
        "df5['assortment'] = df5['assortment'].map(assortment_dict)"
      ],
      "metadata": {
        "id": "2CVMzCUptxd0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dessa forma, concluímos a fase de codificação das variáveis categóricas do nosso conjunto de dados. Este processo é crucial para garantir que nosso modelo de previsão de vendas possa entender e utilizar adequadamente essas variáveis."
      ],
      "metadata": {
        "id": "gqiMZUHPt0EK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **10.1 Rossmann Class (Continuar)**\n",
        "A classe Rossmann tem a intenção de automatizar e organizar o processo de previsão de vendas para a rede de lojas Rossman. Aqui estão as explicações detalhadas das funcionalidades presentes na classe.\n",
        "\n",
        "Importando bibliotecas necessárias:"
      ],
      "metadata": {
        "id": "dPw1lT2guvoy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pickle\n",
        "import inflection\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import math\n",
        "import datetime"
      ],
      "metadata": {
        "id": "Pdha_snzDju6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Criando a classe Rossmann:"
      ],
      "metadata": {
        "id": "mG6sOYxdDkFq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Rossmann(object):"
      ],
      "metadata": {
        "id": "5oKMSKzDDnuV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No método de inicialização da classe, diversos modelos treinados são carregados do disco. Isso inclui os transformadores para \"competition_distance\", \"competition_time_month\", \"promo_time_week\", \"year\" e \"store_type\". Esses modelos foram treinados previamente e são utilizados para preparar os dados da mesma forma que os dados de treinamento foram preparados."
      ],
      "metadata": {
        "id": "YZuaif7KDuXP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def __init__( self ):\n",
        "    # Definindo o caminho para os arquivos necessários\n",
        "    self.home_path='repos/DataScience_Em_Producao/'\n",
        "\n",
        "    # Carregando o scaler para a distância da competição do arquivo .pkl\n",
        "    self.competition_distance_scaler = pickle.load( open( self.home_path + 'parameter/competition_distance_scaler.pkl', 'rb') )\n",
        "\n",
        "    # Carregando o scaler para o tempo de competição (em meses) do arquivo .pkl\n",
        "    self.competition_time_month_scaler = pickle.load( open( self.home_path + 'parameter/competition_time_month_scaler.pkl', 'rb') )\n",
        "\n",
        "    # Carregando o scaler para o tempo de promoção (em semanas) do arquivo .pkl\n",
        "    self.promo_time_week_scaler = pickle.load( open( self.home_path + 'parameter/promo_time_week_scaler.pkl', 'rb') )\n",
        "\n",
        "    # Carregando o scaler para o ano do arquivo .pkl\n",
        "    self.year_scaler = pickle.load( open( self.home_path + 'parameter/year_scaler.pkl', 'rb') )\n",
        "\n",
        "    # Carregando o scaler para o tipo de loja do arquivo .pkl\n",
        "    self.store_type_scaler = pickle.load( open( self.home_path + 'parameter/store_type_scaler.pkl', 'rb') )\n"
      ],
      "metadata": {
        "id": "yMso8MtCDv-2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Este é o método inicializador da classe. Ele está preparando a classe para ser usada, carregando todas as ferramentas de ajuste necessárias que foram previamente salvas em arquivos. Essas ferramentas serão usadas para transformar novos dados a serem analisados, para que estejam no mesmo formato dos dados com os quais o modelo foi treinado."
      ],
      "metadata": {
        "id": "URitxz23Hwi_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Data Cleaning\n",
        "O método data_cleaning realiza o processo de limpeza dos dados, que inclui a renomeação das colunas para o formato snakecase, preenchimento dos dados ausentes e a correção dos tipos dos dados."
      ],
      "metadata": {
        "id": "3uN6XR10Dx8L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def data_cleaning( self, df1 ):\n",
        "    # Renomeando as colunas do conjunto de dados\n",
        "    # 'Snake case' é um estilo de escrita que usa apenas letras minúsculas e sublinhados para separar palavras em uma frase (por exemplo, 'snake_case').\n",
        "    cols_old = ['Store', 'DayOfWeek', 'Date', 'Open', 'Promo', 'StateHoliday', 'SchoolHoliday',\n",
        "                'StoreType', 'Assortment', 'CompetitionDistance', 'CompetitionOpenSinceMonth',\n",
        "                'CompetitionOpenSinceYear', 'Promo2', 'Promo2SinceWeek', 'Promo2SinceYear', 'PromoInterval']\n",
        "    snakecase = lambda x: inflection.underscore( x )\n",
        "    cols_new = list( map( snakecase, cols_old ) )\n",
        "    df1.columns = cols_new\n",
        "\n",
        "    # Convertendo a coluna 'date' (data) para o formato correto de data.\n",
        "    df1['date'] = pd.to_datetime( df1['date'] )\n",
        "\n",
        "    # Tratando valores ausentes (NA) no conjunto de dados\n",
        "    # O número '200000.0' é utilizado para substituir os valores NA na coluna 'competition_distance' (distância da competição).\n",
        "    df1['competition_distance'] = df1['competition_distance'].apply( lambda x: 200000.0 if math.isnan( x ) else x )\n",
        "\n",
        "    # Preenchendo os valores NA nas colunas 'competition_open_since_month' (mês que a competição começou)\n",
        "    # e 'competition_open_since_year' (ano que a competição começou) com o mês e ano da data da coluna 'date', respectivamente.\n",
        "    df1['competition_open_since_month'] = df1.apply( lambda x: x['date'].month if math.isnan( x['competition_open_since_month'] ) else x['competition_open_since_month'], axis=1 )\n",
        "    df1['competition_open_since_year'] = df1.apply( lambda x: x['date'].year if math.isnan( x['competition_open_since_year'] ) else x['competition_open_since_year'], axis=1 )\n",
        "\n",
        "    # Preenchendo os valores NA nas colunas 'promo2_since_week' (semana que a promoção começou)\n",
        "    # e 'promo2_since_year' (ano que a promoção começou) com a semana do ano e o ano da data da coluna 'date', respectivamente.\n",
        "    df1['promo2_since_week'] = df1.apply( lambda x: x['date'].week if math.isnan( x['promo2_since_week'] ) else x['promo2_since_week'], axis=1 )\n",
        "    df1['promo2_since_year'] = df1.apply( lambda x: x['date'].year if math.isnan( x['promo2_since_year'] ) else x['promo2_since_year'], axis=1 )\n",
        "\n",
        "    # Preenchendo os valores NA na coluna 'promo_interval' (intervalo de promoção) com 0 e criando uma nova coluna 'month_map'\n",
        "    # que mapeia os números dos meses para os seus respectivos nomes.\n",
        "    month_map = {1: 'Jan', 2: 'Fev', 3: 'Mar', 4: 'Abr', 5: 'Mai', 6: 'Jun', 7: 'Jul', 8: 'Ago', 9: 'Set', 10: 'Out', 11: 'Nov', 12: 'Dez'}\n",
        "    df1['promo_interval'].fillna(0, inplace=True )\n",
        "    df1['month_map'] = df1['date'].dt.month.map( month_map )\n",
        "    df1['is_promo'] = df1[['promo_interval', 'month_map']].apply( lambda x: 0 if x['promo_interval'] == 0 else 1 if x['month_map'] in x['promo_interval'].split( ',' ) else 0, axis=1 )\n",
        "\n",
        "    # Convertendo os tipos de dados das colunas 'competition_open_since_month', 'competition_open_since_year', 'promo2_since_week',\n",
        "    # e 'promo2_since_year' para int (número inteiro), pois essas colunas não deveriam conter números fracionados.\n",
        "    df1['competition_open_since_month'] = df1['competition_open_since_month'].astype( int )\n",
        "    df1['competition_open_since_year'] = df1['competition_open_since_year'].astype( int )\n",
        "    df1['promo2_since_week'] = df1['promo2_since_week'].astype( int )\n",
        "    df1['promo2_since_year'] = df1['promo2_since_year'].astype( int )\n",
        "\n",
        "    # Ao final, retornamos o conjunto de dados já limpo\n",
        "    return df1"
      ],
      "metadata": {
        "id": "b25X11aODzI8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Este código é responsável por limpar um conjunto de dados. Ele renomeia colunas, preenche os valores ausentes com informações significativas, converte dados para os tipos corretos e cria novas colunas a partir de colunas existentes para melhor análise dos dados."
      ],
      "metadata": {
        "id": "XKPRoRraIeKV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Feature Engineering\n",
        "O método feature_engineering realiza o processo de criação e modificação de variáveis, chamado de engenharia de atributos. Aqui, atributos como ano, mês, dia, semana do ano, desde quando a competição começou, desde quando a promoção começou, etc., são criados para ajudar na previsão de vendas."
      ],
      "metadata": {
        "id": "IVxX8HOcD077"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def feature_engineering( self, df2 ):\n",
        "    # Criação de novas colunas relacionadas à data.\n",
        "    df2['year'] = df2['date'].dt.year  # Ano da data.\n",
        "    df2['month'] = df2['date'].dt.month  # Mês da data.\n",
        "    df2['day'] = df2['date'].dt.day  # Dia da data.\n",
        "    df2['week_of_year'] = df2['date'].dt.weekofyear  # Semana do ano da data.\n",
        "    df2['year_week'] = df2['date'].dt.strftime( '%Y-%W' )  # Combinação do ano e a semana.\n",
        "\n",
        "    # Cria uma nova coluna 'competition_since' que representa quando a competição começou.\n",
        "    df2['competition_since'] = df2.apply( lambda x: datetime.datetime(year=x['competition_open_since_year'],month=x['competition_open_since_month'],day=1 ), axis=1 )\n",
        "    df2['competition_time_month'] = ( ( df2['date'] - df2['competition_since'] )/30 ).apply( lambda x: x.days ).astype( int )\n",
        "\n",
        "    # Cria uma nova coluna 'promo_since' que representa quando a promoção começou.\n",
        "    df2['promo_since'] = df2['promo2_since_year'].astype( str ) + '-' + df2['promo2_since_week'].astype( str )\n",
        "    df2['promo_since'] = df2['promo_since'].apply( lambda x: datetime.datetime.strptime( x + '-1', '%Y-%W-%w' ) - datetime.timedelta( days=7 ) )\n",
        "    df2['promo_time_week'] = ( ( df2['date'] - df2['promo_since'] )/7 ).apply( lambda x: x.days ).astype( int )\n",
        "\n",
        "    # Transforma os valores da coluna 'assortment' de codificados para descritivos.\n",
        "    df2['assortment'] = df2['assortment'].apply( lambda x: 'basic' if x == 'a' else 'extra' if x == 'b' else 'extended' )\n",
        "\n",
        "    # Transforma os valores da coluna 'state_holiday' de codificados para descritivos.\n",
        "    df2['state_holiday'] = df2['state_holiday'].apply( lambda x: 'public_holiday' if x == 'a' else 'easter_holiday' if x == 'b' else 'christmas' if x == 'c' else 'regular_day' )\n",
        "\n",
        "    # Filtra linhas onde 'open' é diferente de 0. Ou seja, remove os registros em que a loja estava fechada.\n",
        "    df2 = df2[df2['open'] != 0]\n",
        "\n",
        "    # Remove as colunas 'open', 'promo_interval' e 'month_map'.\n",
        "    cols_drop = ['open', 'promo_interval', 'month_map']\n",
        "    df2 = df2.drop( cols_drop, axis=1 )\n",
        "\n",
        "    # Retorna o DataFrame após todas essas modificações.\n",
        "    return df2"
      ],
      "metadata": {
        "id": "zprINPXWD4TG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Este código é responsável pela engenharia de recursos em um conjunto de dados. Ele cria novas colunas que podem ser úteis para análise posterior, transforma os valores codificados em algumas colunas para uma representação mais descritiva e remove as linhas e colunas que não são necessárias para a análise posterior."
      ],
      "metadata": {
        "id": "rpmxWRWSI64A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Data Preparation\n",
        "O método data_preparation realiza a preparação final dos dados antes do processo de previsão. Isso inclui a reescala dos dados, a codificação de variáveis categóricas e a transformação de algumas variáveis."
      ],
      "metadata": {
        "id": "VaK0P3eSD7fW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def data_preparation(self, df5):\n",
        "    '''\n",
        "    Esta função realiza diversas operações de pré-processamento nos dados\n",
        "    '''\n",
        "\n",
        "    # 5.2. Reescalando valores\n",
        "\n",
        "    # Competição de distância\n",
        "    df5['competition_distance'] = self.competition_distance_scaler.fit_transform(\n",
        "        df5[['competition_distance']].values\n",
        "    )\n",
        "\n",
        "    # Tempo de competição em meses\n",
        "    df5['competition_time_month'] = self.competition_time_month_scaler.fit_transform(\n",
        "        df5[['competition_time_month']].values\n",
        "    )\n",
        "\n",
        "    # Tempo de promoção em semanas\n",
        "    df5['promo_time_week'] = self.promo_time_week_scaler.fit_transform(\n",
        "        df5[['promo_time_week']].values\n",
        "    )\n",
        "\n",
        "    # Ano\n",
        "    df5['year'] = self.year_scaler.fit_transform(df5[['year']].values)\n",
        "\n",
        "    # 5.3.1. Codificação das variáveis categóricas\n",
        "\n",
        "    # 'state_holiday' para One Hot Encoding\n",
        "    df5 = pd.get_dummies(df5, prefix=['state_holiday'], columns=['state_holiday'])\n",
        "\n",
        "    # 'store_type' para Label Encoding\n",
        "    df5['store_type'] = self.store_type_scaler.fit_transform(df5['store_type'])\n",
        "\n",
        "    # 'assortment' para Ordinal Encoding\n",
        "    assortment_dict = {'basic': 1, 'extra': 2, 'extended': 3}\n",
        "    df5['assortment'] = df5['assortment'].map(assortment_dict)\n",
        "\n",
        "    # 5.3.3. Transformações cíclicas\n",
        "\n",
        "    # Dia da semana\n",
        "    df5['day_of_week_sin'] = df5['day_of_week'].apply(\n",
        "        lambda x: np.sin(x * (2. * np.pi/7))\n",
        "    )\n",
        "    df5['day_of_week_cos'] = df5['day_of_week'].apply(\n",
        "        lambda x: np.cos(x * (2. * np.pi/7))\n",
        "    )\n",
        "\n",
        "    # Mês\n",
        "    df5['month_sin'] = df5['month'].apply(lambda x: np.sin(x * (2. * np.pi/12)))\n",
        "    df5['month_cos'] = df5['month'].apply(lambda x: np.cos(x * (2. * np.pi/12)))\n",
        "\n",
        "    # Dia\n",
        "    df5['day_sin'] = df5['day'].apply(lambda x: np.sin(x * (2. * np.pi/30)))\n",
        "    df5['day_cos'] = df5['day'].apply(lambda x: np.cos(x * (2. * np.pi/30)))\n",
        "\n",
        "    # Semana do ano\n",
        "    df5['week_of_year_sin'] = df5['week_of_year'].apply(\n",
        "        lambda x: np.sin(x * (2. * np.pi/52))\n",
        "    )\n",
        "    df5['week_of_year_cos'] = df5['week_of_year'].apply(\n",
        "        lambda x: np.cos(x * (2. * np.pi/52))\n",
        "    )\n",
        "\n",
        "    # Colunas selecionadas para o modelo\n",
        "    cols_selected = ['store', 'promo', 'store_type', 'assortment', 'competition_distance',\n",
        "                     'competition_open_since_month', 'competition_open_since_year', 'promo2',\n",
        "                     'promo2_since_week', 'promo2_since_year', 'competition_time_month',\n",
        "                     'promo_time_week', 'day_of_week_sin', 'day_of_week_cos', 'month_sin',\n",
        "                     'month_cos', 'day_sin', 'day_cos', 'week_of_year_sin', 'week_of_year_cos']\n",
        "\n",
        "    return df5[cols_selected]"
      ],
      "metadata": {
        "id": "p21WL6cRD8ZK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        " função em questão realiza uma série de operações para preparar os dados para a modelagem. Inicialmente, reescala determinadas variáveis numéricas com o intuito de alcançar uma distribuição mais uniforme, o que facilita o uso desses dados em um modelo de aprendizado de máquina.\n",
        "\n",
        "Em seguida, a função codifica variáveis categóricas para que elas possam ser corretamente interpretadas e utilizadas pelo modelo. Essa codificação inclui a transformação de categorias distintas em colunas binárias, um processo conhecido como \"one-hot encoding\", e a atribuição de números únicos a cada categoria, uma técnica denominada \"label encoding\".\n",
        "\n",
        "Além disso, para preservar a natureza cíclica de variáveis como o dia da semana, mês, dia do mês e semana do ano, a função realiza transformações cíclicas. Este passo é crucial porque estas variáveis apresentam um comportamento cíclico - por exemplo, após o sétimo dia da semana, a contagem retorna ao primeiro dia. Ao transformar estas variáveis para uma representação cíclica, o modelo pode capturar e entender esta característica.\n",
        "\n",
        "Por fim, a função seleciona as colunas finais que serão usadas no modelo, finalizando a preparação dos dados para a modelagem."
      ],
      "metadata": {
        "id": "E9djFGULJzQE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Get Prediction\n",
        "Por fim, o método get_prediction utiliza o modelo treinado para fazer a previsão das vendas e anexa essas previsões aos dados originais."
      ],
      "metadata": {
        "id": "n8lGng4kJ03B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_prediction( self, model, original_data, test_data ):\n",
        "    # prediction\n",
        "    pred = model.predict( test_data )\n",
        "    # join pred into the original data\n",
        "    original_data['prediction'] = np.expm1( pred )\n",
        "    return original_data.to_json( orient='records', date_format='iso' )\n"
      ],
      "metadata": {
        "id": "ok9duXBLD_Z8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A função \"get_prediction\" é responsável por realizar previsões utilizando um modelo de machine learning previamente definido e aplicá-las ao conjunto de dados originais. Primeiramente, as previsões são realizadas sobre um conjunto de dados de teste e armazenadas na variável \"pred\". Em seguida, essas previsões são transformadas para sua escala original e adicionadas ao conjunto de dados originais como uma nova coluna denominada \"previsao\". Finalmente, o DataFrame, agora com os dados originais e as previsões, é convertido para o formato JSON, um formato de texto comumente utilizado para a troca de dados. A estrutura desse JSON será tal que cada registro corresponda a uma linha dos dados originais, complementada pela previsão realizada pelo modelo."
      ],
      "metadata": {
        "id": "YsBC4jdAEBJs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **10.2 API Handler**\n",
        "Nesta parte do projeto de previsão de vendas, estamos trabalhando na implementação de uma API que tornará nosso modelo de aprendizado de máquina acessível para uso em produção.\n",
        "\n",
        "Primeiramente, importamos as bibliotecas necessárias, como o Flask, que nos permite criar e gerenciar nossa aplicação web, a biblioteca pickle para carregar nosso modelo treinado e a pandas para manipulação de dados.\n",
        "\n",
        "A biblioteca Flask fornece um conjunto de funcionalidades para manipular solicitações da web e responder de maneira apropriada. Instanciamos a aplicação Flask com a linha app = Flask(__name__). Em seguida, criamos um endpoint, ou rota, que é essencialmente um URL que a aplicação irá responder.\n",
        "\n",
        "Neste caso, definimos a rota '/rossmann/predict' com o método POST, que será responsável por receber os dados e retornar as previsões do nosso modelo de vendas.\n",
        "\n",
        "Na função 'rossmann_predict()', começamos obtendo o JSON da solicitação. Este JSON contém os dados necessários para a previsão. Se o JSON contiver dados, o código verificará se é um único exemplo (um dicionário) ou múltiplos exemplos (uma lista de dicionários), criando um DataFrame pandas apropriado em ambos os casos.\n",
        "\n",
        "A partir daí, entramos no pipeline de previsão. Primeiramente, limpamos os dados usando o método 'data_cleaning()' da classe Rossmann que implementamos anteriormente. A seguir, executamos a engenharia de características com o método 'feature_engineering()', e então preparamos os dados para a previsão com 'data_preparation()'. Finalmente, fazemos a previsão com 'get_prediction()' e retornamos a resposta.\n",
        "\n",
        "Se o JSON não contiver dados, retornamos uma resposta com status 200 e um corpo vazio, indicando que a solicitação foi recebida com sucesso, mas nenhuma ação foi tomada devido à ausência de dados.\n",
        "\n",
        "Finalmente, se o script for executado diretamente (ou seja, não importado como um módulo), ele iniciará a aplicação Flask para ouvir as solicitações na porta padrão.\n",
        "\n",
        "Essa explicação detalha a implementação de uma API para disponibilizar o modelo de previsão de vendas para produção, onde receberá dados, processará e retornará as previsões do modelo."
      ],
      "metadata": {
        "id": "GDrJr-2zqZ9w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importação das bibliotecas necessárias\n",
        "import pickle\n",
        "import pandas as pd\n",
        "from flask import Flask, request, Response\n",
        "from rossmann.Rossmann import Rossmann\n",
        "\n",
        "# Carregamento do modelo treinado\n",
        "model = pickle.load(open('/repos/DataScience_Em_Producao/model/model_rossmann.pkl', 'rb'))\n",
        "\n",
        "# Inicialização da API\n",
        "app = Flask(__name__)\n",
        "\n",
        "# Definição da rota da API para a previsão\n",
        "@app.route('/rossmann/predict', methods=['POST'])\n",
        "def rossmann_predict():\n",
        "    # Obtém o JSON da solicitação\n",
        "    test_json = request.get_json()\n",
        "\n",
        "    # Verifica se há dados no JSON\n",
        "    if test_json:\n",
        "        # Se for um exemplo único, transforma em um dataframe\n",
        "        if isinstance(test_json, dict):\n",
        "            test_raw = pd.DataFrame(test_json, index=[0])\n",
        "        # Se forem exemplos múltiplos, também transforma em um dataframe\n",
        "        else:\n",
        "            test_raw = pd.DataFrame(test_json, columns=test_json[0].keys())\n",
        "\n",
        "        # Instanciação da classe Rossmann\n",
        "        pipeline = Rossmann()\n",
        "\n",
        "        # Limpeza dos dados\n",
        "        df1 = pipeline.data_cleaning(test_raw)\n",
        "\n",
        "        # Engenharia de características\n",
        "        df2 = pipeline.feature_engineering(df1)\n",
        "\n",
        "        # Preparação dos dados\n",
        "        df3 = pipeline.data_preparation(df2)\n",
        "\n",
        "        # Realização da previsão\n",
        "        df_response = pipeline.get_prediction(model, test_raw, df3)\n",
        "\n",
        "        return df_response\n",
        "    else:\n",
        "        # Se não há dados, retorna uma resposta com status 200 e corpo vazio\n",
        "        return Response('{}', status=200, mimetype='application/json')\n",
        "\n",
        "# Inicia a aplicação Flask para ouvir as solicitações na porta padrão\n",
        "if __name__ == '__main__':\n",
        "    app.run('0.0.0.0')\n"
      ],
      "metadata": {
        "id": "i0wqciaYhalo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **10.3 API Tester**\n",
        "Para tornar nosso modelo disponível para uso, implementamos uma API (Interface de Programação de Aplicações) usando o Flask, que é uma biblioteca de Python preparada para a Web. Esta API pode lidar com a entrada de dados, processá-los através do modelo, e retornar as previsões.\n",
        "\n",
        "Para testar nossa API, usamos um conjunto de dados de teste que o modelo nunca viu antes. Este conjunto de dados de teste imita os dados novos que o modelo irá encontrar na vida real. Para fazer uma previsão, precisamos criar um dataframe com as mesmas colunas que usamos para treinar o modelo."
      ],
      "metadata": {
        "id": "ojg-3rayqf_7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Carregar o conjunto de dados de teste e o conjunto de dados da loja\n",
        "df10 = pd.read_csv('/repos/DataScience_Em_Producao/data/test.csv')\n",
        "df_store_raw = pd.read_csv('/repos/DataScience_Em_Producao/data/store.csv')\n",
        "\n",
        "# Fazer o merge dos conjuntos de dados\n",
        "df_test = pd.merge(df10, df_store_raw, how='left', on='Store')\n",
        "\n",
        "# Escolher uma loja para previsão\n",
        "df_test = df_test[df_test['Store'].isin([22])]\n",
        "\n",
        "# Remover os dias em que a loja estava fechada\n",
        "df_test = df_test[df_test['Open'] != 0]\n",
        "df_test = df_test[~df_test['Open'].isnull()]\n",
        "df_test = df_test.drop('Id', axis=1)\n",
        "\n",
        "# Converter o dataframe para json\n",
        "data = json.dumps(df_test.to_dict(orient='records'))\n",
        "\n",
        "# Fazer uma chamada para a API\n",
        "url = 'http://0.0.0.0:5000/rossmann/predict'\n",
        "header = {'Content-type': 'application/json'}\n",
        "r = requests.post(url, data=data, headers=header)\n",
        "\n",
        "# Imprimir as previsões\n",
        "d1 = pd.DataFrame(r.json(), columns=r.json()[0].keys())\n",
        "d2 = d1[['store', 'prediction']].groupby('store').sum().reset_index()\n",
        "for i in range(len(d2)):\n",
        "    print('Store Number {} will sell R${:,.2f} in the next 6 weeks'.format(d2.loc[i, 'store'], d2.loc[i, 'prediction']))"
      ],
      "metadata": {
        "id": "KasZZ0ua27Hw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para testar a API no projeto de previsão de vendas, iniciamos carregando os dados de teste e as informações específicas das lojas. Posteriormente, unimos estes conjuntos de dados em um único dataframe. Visando otimizar o processo, escolhemos realizar as previsões para apenas uma loja e eliminamos os dias nos quais a loja estava fechada. O dataframe é então convertido para o formato JSON, permitindo que seja enviado através da API. Realizamos uma chamada para a API usando o método POST, incluindo os dados no corpo da solicitação. Finalmente, a API retorna as previsões que são, então, exibidas.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "R6O8NLRImiis"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Implementação no Heroku\n",
        "A implementação de um modelo de previsão de vendas no Heroku acontece em etapas detalhadas:\n",
        "\n",
        "1. **Preparação do ambiente** Após criar uma conta gratuita no Heroku, é necessário instalar o cliente Heroku, que permite a interação com a plataforma através do terminal. O cliente pode ser instalado utilizando o comando de instalação específico para o seu sistema operacional. Após a instalação, faça login no Heroku utilizando o comando heroku login.\n",
        "\n",
        "2. **Configuração dos arquivos para deploy:** Para publicar o modelo, é necessário preparar três arquivos principais:\n",
        "\n",
        "- 'Procfile': Este arquivo contém o comando que o Heroku executa para inicializar a API.\n",
        "- 'requirements.txt': Este arquivo lista todas as bibliotecas usadas no projeto. Pode ser criado utilizando o comando pip freeze > requirements.txt.\n",
        "- A pasta do projeto deve ser configurada como um repositório Git. Isso pode ser feito com git init.\n",
        "\n",
        "3. **Publicação do modelo:**\n",
        "\n",
        "- Inicie o processo com o comando git status para visualizar os arquivos disponíveis.\n",
        "- Adicione todos os arquivos com git add ..\n",
        "- Registre as alterações com git commit -m \"primeiro commit\".\n",
        "- Agora, ao invés de usar git push origin master, que enviaria as alterações para o repositório Git, use git push heroku master para enviar para o Heroku.\n",
        "\n",
        "4. **Criação da aplicação no Heroku:** Antes de enviar os arquivos, é necessário criar a aplicação no Heroku com heroku apps:create nome_da_aplicacao, substituindo 'nome_da_aplicacao' pelo nome desejado.\n",
        "\n",
        "5. **Verificação da aplicação:** Após a criação, a aplicação será visível na sua conta Heroku. Pode-se visualizar os registros da aplicação clicando em 'more' e em 'view logs'.\n",
        "\n",
        "6. **Envio dos arquivos ao Heroku:** Com a aplicação criada, envie os arquivos com git push heroku master. O Heroku receberá os arquivos, instalará as bibliotecas listadas em 'requirements.txt' e executará o comando especificado em 'Procfile'.\n",
        "\n",
        "7. **Teste da aplicação:** Após a construção da aplicação, teste-a substituindo a URL local pela URL do Heroku em seu arquivo Jupyter.\n",
        "\n",
        "8. **Realização de requisições à aplicação:** Com a aplicação disponível, é possível realizar requisições de qualquer lugar, seja através de um notebook, softwares como Postman ou Telegram.\n",
        "\n",
        "9. **Monitoramento do uso de recursos:** Na conta gratuita do Heroku, existe um limite de 500MB. É importante monitorar o uso para não ultrapassar esse limite.\n",
        "\n",
        "Finalizadas estas etapas, a aplicação estará operacional no Heroku, permitindo a realização de previsões de vendas de qualquer local com acesso à internet. Essas etapas são genéricas e podem variar dependendo do projeto específico"
      ],
      "metadata": {
        "id": "U4IQwzr5mofx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 12. Bot no Telegram\n",
        "Este projeto tem como objetivo criar um modelo de previsão de vendas que poderá ser acessado por meio de um bot no Telegram. O modelo em execução está hospedado na plataforma Heroku, um ambiente de produção na nuvem.\n",
        "\n",
        "Depois de passar pelas etapas iniciais do projeto, temos um modelo de previsão de vendas operacional. A importância de um modelo não reside apenas na sua construção técnica, mas também na forma como os resultados são apresentados aos usuários finais - neste caso, os gerentes de loja. Por isso, é importante disponibilizá-lo de forma apropriada, como por meio de um bot do Telegram, facilitando o acesso à previsão por qualquer pessoa, em qualquer dispositivo.\n",
        "\n",
        "Os passos básicos do projeto foram:\n",
        "\n",
        "Identificação da questão de negócio: Os gerentes de loja precisavam de previsões de vendas para as próximas seis semanas.\n",
        "\n",
        "Entendimento do negócio: Identificamos que o problema central estava na falta de conhecimento sobre a receita que a loja faria nas próximas seis semanas, o que é crucial para planejar reformas e outras decisões de negócio.\n",
        "\n",
        "Coleta de dados: Os dados foram obtidos em formato CSV e tratados para a análise subsequente.\n",
        "\n",
        "Limpeza e preparação dos dados: Removemos erros e inconsistências, resultando em um conjunto de dados limpo e preparado para modelagem.\n",
        "\n",
        "Análise exploratória dos dados (EDA): Realizamos uma análise detalhada para entender o comportamento das variáveis e validar nossas hipóteses.\n",
        "\n",
        "Modelagem: Testamos vários algoritmos e avaliamos seu desempenho.\n",
        "\n",
        "Avaliação da performance do modelo: Confirmamos que nosso modelo tem um bom desempenho, tanto do ponto de vista técnico quanto do ponto de vista do negócio.\n",
        "\n",
        "Neste ponto, implementamos o modelo em produção na plataforma Heroku e criamos um bot do Telegram para tornar as previsões acessíveis. O bot recebe a solicitação, envia a previsão ao modelo no Heroku, e depois retorna a previsão ao usuário.\n",
        "\n",
        "Agora, estamos trabalhando para melhorar a interação com o bot, de modo que os usuários possam solicitar previsões de vendas para lojas específicas apenas inserindo o código da loja. Com essa implementação, qualquer pessoa será capaz de acessar as previsões de vendas de um celular ou qualquer outra plataforma.\n",
        "\n",
        "Em resumo, a conclusão deste projeto nos permitirá demonstrar a utilidade prática de um projeto de ciência de dados e sua capacidade de agregar valor ao negócio, algo mais importante e impactante do que simplesmente deter conhecimentos teóricos.\n",
        "\n",
        "### Criando o Rossmann API\n",
        "Este processo é iniciado pela abertura do terminal, navegação para a pasta do projeto e ativação do ambiente virtual. Dentro deste ambiente, é criado um diretório chamado \"rossmann_telegram_api\" e, em seguida, um arquivo Python vazio chamado \"rossmann-bot.py\".\n",
        "\n",
        "O próximo passo é a escrita do código que vai carregar e processar os dados de teste. Para tal, são usadas bibliotecas como Pandas e JSON.\n",
        "\n",
        "Primeiro, carrega-se o conjunto de dados de teste e o conjunto de dados da loja a partir dos respectivos arquivos CSV. Em seguida, estes conjuntos de dados são mesclados com base na coluna 'Store'.\n",
        "\n",
        "Posteriormente, escolhem-se as lojas específicas para as quais se pretende prever as vendas. Além disso, são removidos os dias em que as lojas estavam fechadas e a coluna 'Id' é descartada.\n",
        "\n",
        "A seguir, o conjunto de dados é convertido para o formato JSON para que possa ser usado para fazer uma chamada de API. A chamada de API é feita para um endpoint específico que recebe os dados de entrada e devolve as previsões de vendas.\n",
        "\n",
        "As previsões retornadas pela API são, então, transformadas de volta em um dataframe, somando-se todas as previsões por loja. O resultado final, que é a previsão de vendas para as próximas seis semanas para cada loja selecionada, é exibido no console.\n",
        "\n",
        "Este código é bem modularizado e encapsulado em funções para facilitar a reutilização e a manutenção. Uma das funções criadas é uma que recebe como parâmetros o número da loja e o dia e retorna a previsão de vendas para aquela loja.\n",
        "\n",
        "É importante ressaltar que o modelo de previsão de vendas está hospedado no Heroku, uma plataforma que permite que o modelo seja acessado através de uma API. Este serviço pode entrar em um modo \"adormecido\" quando não é utilizado por um determinado período de tempo, mas é reativado assim que uma nova requisição é feita."
      ],
      "metadata": {
        "id": "Y9Xb76Kfw36C"
      }
    }
  ]
}