projeto_previsao_vendas_rossmann_final_model_11_08.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyNT4KJRWz3p4W4oXRj/j0Xt",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "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_final_model_11_08.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 silenciosamente\n",
        "!pip install scikit-learn -q\n",
        "!pip install inflection -q\n",
        "!pip install tabulate -q\n",
        "!pip install seaborn -q\n",
        "!pip install --upgrade seaborn -q\n",
        "!pip install sklearn -q\n",
        "!pip install Ipython -q\n",
        "!pip install boruta -q\n",
        "!pip install scipy -q\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\n"
      ],
      "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().astype(int)"
      ],
      "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)"
      ],
      "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**.\n",
        "\n",
        "### **1.5.2 Competition Open Since Month**"
      ],
      "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 ou mais frequente.\n"
      ],
      "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": [
        "### **Central Tendency Measures**"
      ],
      "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": [
        "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": [
        "# Definindo o tamanho do gráfico, aumentando para ocupar mais espaço\n",
        "plt.figure(figsize=(17, 10))\n",
        "\n",
        "# Criando o boxplot\n",
        "sns.boxplot(x='state_holiday', y='sales', data=df1)\n",
        "\n",
        "# Adicionando um título ao gráfico com uma fonte maior\n",
        "plt.title('Comparação das vendas em diferentes estados de férias', fontsize=18)\n",
        "\n",
        "# Removendo margens\n",
        "plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)\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",
        "# Definindo a ordem para cada variável\n",
        "state_holiday_order = ['a', 'b', 'c']\n",
        "store_type_order    = ['a', 'b', 'c', 'd']\n",
        "assortment_order    = ['a', 'b', 'c']\n",
        "\n",
        "# Inicializando a figura para os gráficos com tamanho maior\n",
        "fig, axes = plt.subplots(1, 3, figsize=(24, 6))\n",
        "\n",
        "# Adicionando um título global para a figura com uma fonte maior\n",
        "fig.suptitle('Distribuição de Vendas por Estado de Férias, Tipo de Loja e Variedade de Produtos', fontsize=18, y=1.02)\n",
        "\n",
        "# Criando o primeiro subplot para mostrar a distribuição de vendas por estado de férias\n",
        "sns.boxplot(ax=axes[0], x = 'state_holiday', y = 'sales', data = aux1, order=state_holiday_order)\n",
        "axes[0].set_title('Estado de Férias', fontsize=16)\n",
        "\n",
        "# Criando o segundo subplot para mostrar a distribuição de vendas por tipo de loja\n",
        "sns.boxplot(ax=axes[1], x = 'store_type', y = 'sales', data = aux1, order=store_type_order)\n",
        "axes[1].set_title('Tipo de Loja', fontsize=16)\n",
        "\n",
        "# Criando o terceiro subplot para mostrar a distribuição de vendas por variedade de produtos\n",
        "sns.boxplot(ax=axes[2], x = 'assortment', y = 'sales', data = aux1, order=assortment_order)\n",
        "axes[2].set_title('Variedade de Produtos', fontsize=16)\n",
        "\n",
        "# Ajustando o layout para adicionar espaçamento e evitar sobreposição\n",
        "fig.tight_layout(pad=3.0)\n",
        "\n",
        "# Exibindo os gráficos\n",
        "plt.show()\n"
      ],
      "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",
        "## **Rossmann Project Status**\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",
        "### **Hyphoteses Mind Map**\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": [
        "---\n",
        "### **Elements of the Hypotheses Mind Map**\n",
        "\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": [
        "---\n",
        "### **How ​​to write the Hypotheses?**\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 Mental Map of Hypotheses**"
      ],
      "metadata": {
        "id": "S3rBEvQB9Z-K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **2.1.1 Store Hyphoteses**\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 Product Hyphoteses**\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. Time Hypotheses**\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": [
        "---\n",
        "## **2.2 Final List of Hypotheses**\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": [
        "---\n",
        "## **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": [
        "---\n",
        "### **2.3.1 Derivation of Dates**\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 usando o método **strftime**.\n",
        "\n",
        "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')"
      ],
      "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', 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)"
      ],
      "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",
        "df2['competition_time_month'] = ((df2['date'] - df2['competition_since']).dt.days / 30).astype(int)\n",
        "\n",
        "# Preenche NaNs com 0 ou outro valor apropriado para seu contexto\n",
        "df2['competition_time_month'].fillna(0, inplace=True)\n",
        "df2['competition_time_month'] = df2['competition_time_month'].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": [
        "# Importando a biblioteca necessária\n",
        "import datetime\n",
        "\n",
        "# Criando a coluna 'promo_since'\n",
        "df2['promo_since'] = pd.to_datetime(df2['promo2_since_year'].astype(str) + '-W' +\n",
        "                                    df2['promo2_since_week'].astype(str) + '-1', format='%Y-W%W-%w')\n",
        "\n",
        "# Ajustando 'promo_since' em uma semana\n",
        "df2['promo_since'] -= pd.DateOffset(weeks=1)\n",
        "\n",
        "# Criando 'promo_time_week'\n",
        "df2['promo_time_week'] = ((df2['date'] - df2['promo_since']) / np.timedelta64(1, 'W')).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**\n",
        "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": "5ORlKejtEqQa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cria um dicionário de mapeamento para 'assortment'\n",
        "assortment_dict = {'a': 'basic', 'b': 'extra', 'c': 'extended'}\n",
        "\n",
        "# Atualiza a coluna 'assortment' usando o dicionário\n",
        "df2['assortment'] = df2['assortment'].map(assortment_dict)"
      ],
      "metadata": {
        "id": "lIp0mdAFFh15"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **2.3.5 State Holiday**\n",
        "Aqui aplicamos a mesma lógica anterior de Assortment para State Holiday:"
      ],
      "metadata": {
        "id": "xOyGIcmpGJ2W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cria um dicionário de mapeamento para 'state_holiday'\n",
        "state_holiday_dict = {'a': 'public_holiday', 'b': 'easter_holiday', 'c': 'christmas', '0': 'regular_day'}\n",
        "\n",
        "# Atualiza a coluna 'state_holiday' usando o dicionário\n",
        "df2['state_holiday'] = df2['state_holiday'].map(state_holiday_dict)"
      ],
      "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": [
        "# Define condições para seleção de dados\n",
        "lojas_abertas = df3['open'] != 0\n",
        "vendas_positivas = df3['sales'] > 0\n",
        "\n",
        "# Seleciona os dados que atendem às condições\n",
        "df3 = df3[lojas_abertas & vendas_positivas]"
      ],
      "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",
        "df3 = df3.drop(['customers', 'open', 'promo_interval', 'month_map'], axis=1)\n",
        "\n",
        "# Exibindo as colunas restantes\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('white')\n",
        "\n",
        "# Define o tamanho do gráfico\n",
        "plt.figure(figsize=(24, 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": [
        "# Configura o estilo do gráfico\n",
        "sns.set_style('white')\n",
        "\n",
        "# Cria uma figura para conter os subplots\n",
        "plt.figure(figsize=(24, 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=(24, 6))\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)"
      ],
      "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": [
        "# Define o estilo do gráfico como um fundo branco\n",
        "sns.set_style('white')\n",
        "\n",
        "# Função para gerar o gráfico kde\n",
        "def generate_kdeplot(df, label, ax):\n",
        "    sns.kdeplot(data=df['sales'], label=label, shade=True, ax=ax)\n",
        "\n",
        "# Cria uma figura para conter os subplots\n",
        "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(24, 6))\n",
        "\n",
        "# Calcula os dataframes para serem reutilizados\n",
        "df_holiday = df4[df4['state_holiday'] != 'regular_day']\n",
        "df_public_holiday = df4[df4['state_holiday'] == 'public_holiday']\n",
        "df_easter_holiday = df4[df4['state_holiday'] == 'easter_holiday']\n",
        "df_christmas = df4[df4['state_holiday'] == 'christmas']\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=df_holiday, 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",
        "\n",
        "# Usando a função para gerar gráficos kde\n",
        "generate_kdeplot(df_public_holiday, 'Public Holiday', ax2)\n",
        "generate_kdeplot(df_easter_holiday, 'Easter Holiday', ax2)\n",
        "generate_kdeplot(df_christmas, 'Christmas', 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": [
        "# Função para gerar o gráfico de barras\n",
        "def generate_countplot(df, column, ax, title, xlabel, ylabel, order=None):\n",
        "    ax = sns.countplot(x=column, data=df, palette='viridis', order=order, ax=ax)\n",
        "    ax.set_title(title, fontsize=16)\n",
        "    ax.set_xlabel(xlabel, fontsize=12)\n",
        "    ax.set_ylabel(ylabel, fontsize=12)\n",
        "    ax.grid(False)\n",
        "\n",
        "    # Anotação de texto para cada barra do gráfico\n",
        "    for p in ax.patches:\n",
        "        ax.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",
        "# Função para gerar o gráfico kde\n",
        "def generate_kdeplot(df, column, value, label, ax, xlabel):\n",
        "    sns.kdeplot(data=df[df[column] == value]['sales'], label=label, shade=True, ax=ax)\n",
        "    ax.set_title('Distribuição de Vendas por ' + xlabel, fontsize=16)\n",
        "    ax.set_xlabel('Vendas', fontsize=12)\n",
        "    ax.set_ylabel('Densidade', fontsize=12)\n",
        "    ax.legend(title=xlabel)\n",
        "    ax.grid(False)\n",
        "\n",
        "# Definindo o tamanho da figura\n",
        "fig, axes = plt.subplots(2, 2, figsize=(24, 6))\n",
        "\n",
        "# Gráfico 1 - state_holiday\n",
        "df_holiday = df4[df4['state_holiday'] != 'regular_day']\n",
        "generate_countplot(df_holiday, 'state_holiday', axes[0, 0], 'Contagem de Dias por Tipo de Feriado', 'Tipo de Feriado', 'Contagem')\n",
        "\n",
        "# Gráfico 2 - state_holiday\n",
        "generate_kdeplot(df4, 'state_holiday', 'public_holiday', 'Feriado público', axes[0, 1], 'Tipo de Feriado')\n",
        "generate_kdeplot(df4, 'state_holiday', 'easter_holiday', 'Páscoa', axes[0, 1], 'Tipo de Feriado')\n",
        "generate_kdeplot(df4, 'state_holiday', 'christmas', 'Natal', axes[0, 1], 'Tipo de Feriado')\n",
        "\n",
        "# Gráfico 3 - store_type\n",
        "generate_countplot(df4, 'store_type', axes[1, 0], 'Contagem de Lojas por Tipo', 'Tipo de Loja', 'Contagem', ['a', 'b', 'c', 'd'])\n",
        "\n",
        "# Gráfico 4 - store_type\n",
        "generate_kdeplot(df4, 'store_type', 'a', 'Loja a', axes[1, 1], 'Tipo de Loja')\n",
        "generate_kdeplot(df4, 'store_type', 'b', 'Loja b', axes[1, 1], 'Tipo de Loja')\n",
        "generate_kdeplot(df4, 'store_type', 'c', 'Loja c', axes[1, 1], 'Tipo de Loja')\n",
        "generate_kdeplot(df4, 'store_type', 'd', 'Loja d', axes[1, 1], 'Tipo de Loja')\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": [
        "# Função para gerar os gráficos de barras\n",
        "def plot_bar(df, column, title, xlabel, ylabel, subplot, order=None):\n",
        "    plt.subplot(3, 2, subplot)\n",
        "    sns.countplot(data=df, x=column, order=order)\n",
        "    plt.title(title, fontsize=16)\n",
        "    plt.xlabel(xlabel, fontsize=14)\n",
        "    plt.ylabel(ylabel, fontsize=14)\n",
        "\n",
        "# Função para gerar os gráficos de densidade de probabilidade\n",
        "def plot_kde(df, column, values, labels, title, xlabel, ylabel, subplot):\n",
        "    plt.subplot(3, 2, subplot)\n",
        "    for value, label in zip(values, labels):\n",
        "        sns.kdeplot(data=df[df[column] == value]['sales'], label=label, shade=True)\n",
        "    plt.title(title, fontsize=16)\n",
        "    plt.xlabel(xlabel, fontsize=14)\n",
        "    plt.ylabel(ylabel, fontsize=14)\n",
        "    plt.legend()\n",
        "\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de barras e gráfico de densidade de probabilidade para 'state_holiday'\n",
        "plot_bar(df4[df4['state_holiday'] != 'regular_day'], 'state_holiday', 'Contagem de Feriados', 'Tipo de Feriado', 'Contagem', 1)\n",
        "plot_kde(df4, 'state_holiday', ['public_holiday', 'easter_holiday', 'christmas'], ['Feriado Público', 'Páscoa', 'Natal'],\n",
        "         'Distribuição de Vendas por Tipo de Feriado', 'Vendas', 'Densidade', 2)\n",
        "\n",
        "# Gráfico de barras e gráfico de densidade de probabilidade para 'store_type'\n",
        "plot_bar(df4, 'store_type', 'Contagem de Tipos de Loja', 'Tipo de Loja', 'Contagem', 3, ['a', 'b', 'c', 'd'])\n",
        "plot_kde(df4, 'store_type', ['a', 'b', 'c', 'd'], ['a', 'b', 'c', 'd'],\n",
        "         'Distribuição de Vendas por Tipo de Loja', 'Vendas', 'Densidade', 4)\n",
        "\n",
        "# Gráfico de barras e gráfico de densidade de probabilidade para 'assortment'\n",
        "plot_bar(df4, 'assortment', 'Contagem de Sortimentos', 'Tipo de Sortimento', 'Contagem', 5)\n",
        "plot_kde(df4, 'assortment', ['extended', 'basic', 'extra'], ['Estendido', 'Básico', 'Extra'],\n",
        "         'Distribuição de Vendas por Tipo de Sortimento', 'Vendas', 'Densidade', 6)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "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": [
        "def plot_total_sales(df, group_column, x_label, y_label, title, color_palette=\"viridis\"):\n",
        "    # Agrupando e redefinindo o índice\n",
        "    aux = df[[group_column, 'sales']].groupby(group_column).sum().reset_index()\n",
        "\n",
        "    # Definindo um esquema de cores mais suave\n",
        "    sns.set_palette('Set2')\n",
        "\n",
        "    # Configurando o tamanho do gráfico para ocupar a área do notebook\n",
        "    fig, ax = plt.subplots(figsize=(24, 6))  # Ajuste as dimensões da figura conforme necessário\n",
        "\n",
        "    # Criando o gráfico de barras com Seaborn\n",
        "    sns.barplot(x = group_column, y = 'sales', data = aux, palette=color_palette, ax=ax)\n",
        "\n",
        "    # Definindo o título do gráfico e dos eixos\n",
        "    ax.set_title(title, fontsize=16)\n",
        "    ax.set_xlabel(x_label, fontsize=14)\n",
        "    ax.set_ylabel(y_label, fontsize=14)\n",
        "\n",
        "    # Removendo as bordas do gráfico\n",
        "    sns.despine()\n",
        "\n",
        "    # Ajustando o layout para otimizar o uso do espaço\n",
        "    plt.subplots_adjust(left=0.1, right=0.9, bottom=0.1, top=0.9)\n",
        "\n",
        "    # Exibindo o gráfico\n",
        "    plt.show()\n",
        "\n",
        "# Chamando a função\n",
        "plot_total_sales(df4, 'assortment', 'Tipo de Sortimento', 'Vendas Totais', 'Vendas Totais por Tipo de Sortimento')"
      ],
      "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": [
        "# 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=(24, 6))\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=(24, 6))\n",
        "\n",
        "# Definindo um esquema de cores mais suave\n",
        "sns.set_palette('Set2')\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=(24, 6))\n",
        "\n",
        "# Configura o estilo e paleta de cores do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\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 (em metros)', fontsize=14, color=label_color)\n",
        "plt.ylabel('Vendas', fontsize=14, color=label_color)\n",
        "\n",
        "# Reduzindo a frequência dos labels no eixo X\n",
        "ticks = plt.xticks()[0]\n",
        "n = len(ticks)\n",
        "step = n // 10  # Mostra aproximadamente 10 labels no eixo X\n",
        "plt.xticks(ticks[::step], aux1['competition_distance'].iloc[::step], rotation=45, color=label_color, ha='right')\n",
        "\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()\n"
      ],
      "metadata": {
        "id": "8kbh7ygJYY0C"
      },
      "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": [
        "# Configura o estilo e paleta de cores do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "\n",
        "# Define os limites dos bins para agrupamento das distâncias\n",
        "bins = list(np.arange(0, 20000, 1000))\n",
        "\n",
        "# Agrupa as vendas por distância dos competidores e cria coluna com a distância agrupada\n",
        "aux = (df4[['competition_distance', 'sales']]\n",
        "       .groupby('competition_distance')\n",
        "       .sum()\n",
        "       .reset_index())\n",
        "aux['competition_distance_binned'] = pd.cut(aux['competition_distance'], bins=bins)\n",
        "\n",
        "# Reagrupa as vendas pela distância agrupada\n",
        "aux = (aux[['competition_distance_binned', 'sales']]\n",
        "       .groupby('competition_distance_binned')\n",
        "       .sum()\n",
        "       .reset_index())\n",
        "\n",
        "# Plota o gráfico de barras com o DataFrame auxiliar\n",
        "plt.figure(figsize=(24, 6))\n",
        "sns.barplot(x=aux['competition_distance_binned'].astype(str), y='sales', data=aux, palette='viridis')\n",
        "\n",
        "# Configura títulos e rótulos\n",
        "plt.title('Vendas Totais em Relação à Distância dos Competidores', fontsize=16)\n",
        "plt.xlabel('Distância dos Competidores Agrupada (em unidades de 1000)', fontsize=14)\n",
        "plt.ylabel('Vendas Totais', fontsize=14)\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": [
        "# Configura o estilo e paleta de cores do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "\n",
        "# Agrupa as vendas por distância dos competidores\n",
        "aux = df4[['competition_distance', 'sales']].groupby('competition_distance').sum().reset_index()\n",
        "\n",
        "# Configurações do gráfico\n",
        "plt.figure(figsize=(24, 6))\n",
        "sns.scatterplot(x='competition_distance', y='sales', data=aux, palette='viridis')\n",
        "\n",
        "# Configura títulos e rótulos\n",
        "plt.title('Vendas Totais em Relação à Distância dos Competidores', fontsize=16)\n",
        "plt.xlabel('Distância dos Competidores', fontsize=14)\n",
        "plt.ylabel('Vendas Totais', fontsize=14)\n",
        "\n",
        "# Configura os ticks do eixo\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Configura os limites dos eixos, adicionando uma margem de 1000 para os valores máximos\n",
        "plt.xlim(0, aux['competition_distance'].max() + 1000)\n",
        "plt.ylim(0, aux['sales'].max() + 1000)\n",
        "\n",
        "# Exibe o gráfico\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Agrupa as vendas por distância dos competidores\n",
        "aux = df4[['competition_distance', 'sales']].groupby('competition_distance').sum().reset_index()\n",
        "\n",
        "# Cria 'bins' para a distância da competição\n",
        "bins = list(np.arange(0, 20000, 1000))\n",
        "aux['competition_distance_binned'] = pd.cut(aux['competition_distance'], bins = bins)\n",
        "\n",
        "# Agrupa os dados de acordo com os bins\n",
        "aux_binned = aux[['competition_distance_binned', 'sales']].groupby('competition_distance_binned').sum().reset_index()\n",
        "\n",
        "# Configurações da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Subplot 1: Scatterplot\n",
        "plt.subplot(2, 2, 1)\n",
        "sns.scatterplot(x='competition_distance', y='sales', data=aux)\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",
        "# Subplot 2: Barplot\n",
        "plt.subplot(2, 2, 2)\n",
        "sns.barplot(x='competition_distance_binned', y='sales', data=aux_binned, 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: Heatmap\n",
        "plt.subplot(2, 2, 3)\n",
        "sns.heatmap(aux.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": [
        "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 concorrentes há mais tempo apresentam 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ções do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\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",
        "vendas_por_mes = 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=(24, 6))\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=vendas_por_mes['sales'] / 1_000_000, data=vendas_por_mes, 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",
        "    altura = p.get_height()\n",
        "    barplot.text(p.get_x()+p.get_width()/2., altura, f'{altura:.3f}', 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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Filtra as linhas onde 'competition_time_month' é diferente de 0 e menor que 120\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",
        "\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'].to_list()[::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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Filtra os dados e agrupa por 'competition_time_month'\n",
        "aux = df4.loc[(df4['competition_time_month'] < 120) & (df4['competition_time_month'] != 0)]\n",
        "aux = aux[['competition_time_month', 'sales']].groupby('competition_time_month').sum().reset_index()\n",
        "\n",
        "# Gráfico de barras mostrando vendas por mês de competição\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.barplot(x='competition_time_month', y='sales', data=aux)\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",
        "plt.xticks(range(0, aux.shape[0], 10), aux['competition_time_month'].tolist()[::10], rotation=45)\n",
        "\n",
        "# Regressão linear entre meses de competição e vendas\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.regplot(x='competition_time_month', y='sales', data=aux, scatter_kws={'s': 5})\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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Filtra os dados e agrupa por 'competition_time_month'\n",
        "aux = df4.loc[(df4['competition_time_month'] < 120) & (df4['competition_time_month'] != 0)]\n",
        "aux = aux[['competition_time_month', 'sales']].groupby('competition_time_month').sum().reset_index()\n",
        "\n",
        "# Gráfico de barras mostrando vendas por mês de competição\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x='competition_time_month', y='sales', data=aux)\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",
        "plt.xticks(range(0, aux.shape[0], 10), aux['competition_time_month'].tolist()[::10], rotation=45)\n",
        "\n",
        "# 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=aux, scatter_kws={'s': 5})\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",
        "# Mapa de calor das correlações\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux.corr(), annot=True, cmap='coolwarm')\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": [
        "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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 8))\n",
        "\n",
        "# Preparação dos dados\n",
        "aux = df4[['promo_time_week', 'sales']].groupby('promo_time_week').sum().reset_index()\n",
        "\n",
        "# Primeiro gráfico de barras para vendas por semana de promoção estendida\n",
        "plt.subplot(2, 1, 1)\n",
        "sns.barplot(x='promo_time_week', y='sales', data=aux[aux['promo_time_week'] > 0])\n",
        "plt.title('Vendas vs. Semanas de Promoção Estendida', fontsize=14)\n",
        "plt.xlabel('Semanas de Promoção Estendida', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.xticks(range(0, aux[aux['promo_time_week'] > 0].shape[0], 10), aux['promo_time_week'][aux['promo_time_week'] > 0].tolist()[::10], rotation=45)\n",
        "\n",
        "# Segundo gráfico de barras para vendas por semana de promoção regular\n",
        "plt.subplot(2, 1, 2)\n",
        "sns.barplot(x='promo_time_week', y='sales', data=aux[aux['promo_time_week'] < 0])\n",
        "plt.title('Vendas vs. Semanas de Promoção Regular', fontsize=14)\n",
        "plt.xlabel('Semanas de Promoção Regular', fontsize=12)\n",
        "plt.ylabel('Vendas', fontsize=12)\n",
        "plt.xticks(range(0, aux[aux['promo_time_week'] < 0].shape[0], 10), aux['promo_time_week'][aux['promo_time_week'] < 0].tolist()[::10], rotation=45)\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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set(style='white', palette='Set2', font_scale=1.4)\n",
        "\n",
        "# Preparação dos dados\n",
        "aux = df4[['promo_time_week', 'sales']].groupby('promo_time_week').sum().reset_index()\n",
        "promo_extended = aux[aux['promo_time_week'] > 0]  # promoção estendida\n",
        "promo_regular = aux[aux['promo_time_week'] < 0]  # promoção regular\n",
        "\n",
        "fig, axs = plt.subplots(2, 2, figsize=(24, 10))\n",
        "\n",
        "# Primeiro gráfico: barras para vendas por semana de promoção estendida\n",
        "sns.barplot(x='promo_time_week', y='sales', data=promo_extended, ax=axs[0, 0])\n",
        "axs[0, 0].set_title('Vendas vs. Semanas de Promoção Estendida')\n",
        "axs[0, 0].set_xlabel('Semanas de Promoção Estendida')\n",
        "axs[0, 0].set_ylabel('Vendas')\n",
        "axs[0, 0].set_xticks(range(0, promo_extended.shape[0], 10))\n",
        "axs[0, 0].set_xticklabels(promo_extended['promo_time_week'].tolist()[::10], rotation=90)\n",
        "\n",
        "# Segundo gráfico: regressão linear para vendas por semana de promoção estendida\n",
        "sns.regplot(x='promo_time_week', y='sales', data=promo_extended, scatter_kws={'s': 5}, ax=axs[0, 1])\n",
        "axs[0, 1].set_title('Regressão Linear: Vendas vs. Semanas de Promoção Estendida')\n",
        "axs[0, 1].set_xlabel('Semanas de Promoção Estendida')\n",
        "axs[0, 1].set_ylabel('Vendas')\n",
        "\n",
        "# Terceiro gráfico: barras para vendas por semana de promoção regular\n",
        "sns.barplot(x='promo_time_week', y='sales', data=promo_regular, ax=axs[1, 0])\n",
        "axs[1, 0].set_title('Vendas vs. Semanas de Promoção Regular')\n",
        "axs[1, 0].set_xlabel('Semanas de Promoção Regular')\n",
        "axs[1, 0].set_ylabel('Vendas')\n",
        "axs[1, 0].set_xticks(range(0, promo_regular.shape[0], 10))\n",
        "axs[1, 0].set_xticklabels(promo_regular['promo_time_week'].tolist()[::10], rotation=90)\n",
        "\n",
        "# Quarto gráfico: regressão linear para vendas por semana de promoção regular\n",
        "sns.regplot(x='promo_time_week', y='sales', data=promo_regular, scatter_kws={'s': 5}, ax=axs[1, 1])\n",
        "axs[1, 1].set_title('Regressão Linear: Vendas vs. Semanas de Promoção Regular')\n",
        "axs[1, 1].set_xlabel('Semanas de Promoção Regular')\n",
        "axs[1, 1].set_ylabel('Vendas')\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": [
        "from matplotlib.ticker import MaxNLocator\n",
        "\n",
        "# Definindo os dados\n",
        "aux1 = df4[['promo_time_week', 'sales']].groupby('promo_time_week').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 10\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 10))\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.5, 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.xaxis.set_major_locator(MaxNLocator(nbins=5))  # Ajustar o número de ticks visíveis no eixo x\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.xaxis.set_major_locator(MaxNLocator(nbins=5))  # Ajustar o número de ticks visíveis no eixo x\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()\n"
      ],
      "metadata": {
        "id": "uZIiJam4BU7Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "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)"
      ],
      "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": [
        "# Selecionando dados onde 'promo' e 'promo2' são 1 e agrupando por 'year_week'\n",
        "aux1 = df4[(df4['promo'] == 1) & (df4['promo2'] == 1)][['year_week', 'sales']].groupby('year_week').sum().reset_index()\n",
        "\n",
        "# Configurando a figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 10\n",
        "\n",
        "# Criando o gráfico de linhas\n",
        "sns.lineplot(x='year_week', y='sales', data=aux1)\n",
        "\n",
        "# Adicionando título e legendas aos eixos\n",
        "plt.title('Vendas Totais por Semana do Ano', fontsize=18)\n",
        "plt.xlabel('Semana do Ano', fontsize=14)\n",
        "plt.ylabel('Vendas Totais', fontsize=14)\n",
        "\n",
        "# Configurando os limites do eixo x para ocupar toda a área do gráfico\n",
        "plt.xlim(min(aux1['year_week']), max(aux1['year_week']))\n",
        "\n",
        "# Rotacionando e ajustando os rótulos do eixo x para melhor visualização\n",
        "plt.xticks(np.arange(0, len(aux1['year_week']), step=10), rotation=45)\n",
        "\n",
        "# Exibindo o gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "K4R2fnjsrSsM"
      },
      "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=(24, 6))\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 10\n",
        "\n",
        "# Definindo os dados\n",
        "aux1 = df4[['promo_time_week', 'sales', 'year_week']].groupby(['promo_time_week', 'year_week']).sum().reset_index()\n",
        "\n",
        "# Filtrando os dados para promoções estendidas e regulares\n",
        "aux2 = aux1[aux1['promo_time_week'] > 0]  # Promoção estendida\n",
        "aux3 = aux1[aux1['promo_time_week'] <= 0]  # Promoção regular\n",
        "\n",
        "# Criando o primeiro gráfico de linha\n",
        "ax = sns.lineplot(x='year_week', y='sales', data=aux2, label='Extendida', linewidth=2.5)\n",
        "\n",
        "# Adicionando o segundo gráfico de linha\n",
        "sns.lineplot(x='year_week', y='sales', data=aux3, label='Regular', linewidth=2.5, ax=ax)\n",
        "\n",
        "# Configurações adicionais\n",
        "plt.title('Vendas ao Longo do Tempo: Promoções Regular 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": [
        "# Definindo os dados\n",
        "aux1 = df4[['state_holiday', 'sales']].groupby('state_holiday').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\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"
      ],
      "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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 10\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\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",
        "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()"
      ],
      "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": [
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "aux = df4[df4['state_holiday'] != 'regular_day']\n",
        "\n",
        "# Criar figura que cobre toda a área do notebook\n",
        "fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(20, 7))\n",
        "\n",
        "# Subplot 1\n",
        "aux1 = aux[['state_holiday', 'sales']].groupby('state_holiday').sum().reset_index()\n",
        "sns.barplot(x='state_holiday', y='sales', data=aux1, ax=axs[0])\n",
        "axs[0].set_title('Vendas Totais por Feriado')\n",
        "\n",
        "# Subplot 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, ax=axs[1])\n",
        "axs[1].set_title('Vendas Totais por Ano e Feriado')\n",
        "\n",
        "# Mostrar o plot\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "iQd1pIcbjwMH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Os três principais feriados analisados foram Natal, Páscoa e feriados públicos. Ao longo dos anos estudados (2013-2015), as vendas do Natal foram consistentemente mais baixas em comparação com os outros feriados, contrariando nossa hipótese inicial de um volume maior de vendas nesse período.\n",
        "\n",
        "Vale salientar que, para o ano de 2015, os dados estão disponíveis apenas até agosto, portanto, a performance de vendas no Natal ainda não está contabilizada.\n",
        "\n",
        "Dessa forma, nosso estudo permitiu invalidar a hipótese inicial: **o Natal, contrariamente ao esperado, não é o período de maiores vendas**. Este é um insight crítico para direcionar futuras estratégias e gerir de forma mais precisa as expectativas relacionadas às vendas nos períodos de feriados.\n"
      ],
      "metadata": {
        "id": "Ki6H8For_W9P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **8. As vendas nas lojas aumentam ao longo dos anos**\n",
        "Nosso foco agora é entender a evolução das vendas ao longo dos anos. Para isso, trabalhamos com as colunas **year** e **sales** do nosso conjunto de dados. Ao agruparmos as vendas por ano e somarmos todos os valores correspondentes, **obtemos o total de vendas anual**. Isso nos permitirá analisar o desempenho de vendas de cada ano."
      ],
      "metadata": {
        "id": "TzoZF_R6_m5z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criação do DataFrame 'aux1', agrupando dados por 'year' e somando as 'sales', com índice resetado.\n",
        "aux1 = df4[['year', 'sales']].groupby('year').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Crie a visualização do gráfico de barras com a paleta padrão\n",
        "ax = sns.barplot(x='year', y='sales', data=aux1)\n",
        "\n",
        "# Remova as bordas do gráfico\n",
        "sns.despine()\n",
        "\n",
        "# Configure o rótulo (label) do eixo x\n",
        "ax.set_xlabel('Ano', fontsize=13, weight='bold')\n",
        "\n",
        "# Configure o rótulo (label) do eixo y\n",
        "ax.set_ylabel('Vendas Totais', fontsize=13, weight='bold')\n",
        "\n",
        "# Adicione um título ao gráfico\n",
        "ax.set_title('Evolução das Vendas Totais ao Longo dos Anos', fontsize=16, weight='bold')\n",
        "\n",
        "# Exiba o gráfico de forma eficiente\n",
        "plt.tight_layout()"
      ],
      "metadata": {
        "id": "yewXKKGamVc8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para decifrar a tendência, trocamos o gráfico de barras por um **gráfico de regressão**, um recurso visual que nos permite identificar intuitivamente se existe uma inclinação positiva ou negativa nas vendas ao longo dos anos.\n",
        "\n",
        "Complementarmente, utilizamos o método **heatmap**, uma técnica eficaz para representar a **correlação entre variáveis**. Através do cálculo do coeficiente de **correlação de Pearson** - somos capazes de visualizar a interdependência e relação direta ou inversa entre as variáveis."
      ],
      "metadata": {
        "id": "g6KwIEBKAunz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criação do DataFrame 'aux1', agrupando dados por 'month' e somando as 'sales', com índice resetado.\n",
        "aux1 = df4[['month', 'sales']].groupby('month').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de barras de vendas por mês\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x='month', y='sales', data=aux1, palette=\"viridis\")\n",
        "plt.title('Vendas Totais por Mês')\n",
        "plt.xlabel('Mês')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Gráfico de regressão linear de vendas por mês\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x='month', y='sales', data=aux1, color='green')\n",
        "plt.title('Tendência de Vendas ao Longo dos Meses')\n",
        "plt.xlabel('Mês')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Heatmap da correlação entre as variáveis\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='coolwarm')\n",
        "plt.title('Correlação entre Mês e Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "IJfZuLfPAvF3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A análise revela uma **tendência decrescente nas vendas ao longo dos anos**, evidenciada pelo gráfico de regressão. Uma correlação robusta de **-0.92** comprova essa tendência descendente - **à medida que os anos avançam, as vendas mostram uma inclinação para diminuir**.\n",
        "\n",
        "É crucial lembrar que os dados de 2015 podem não fornecer um panorama completo, pois só abrangem até meados do ano. Em análises como essa, é essencial considerar períodos fechados para minimizar distorções.\n",
        "\n",
        "Mesmo com uma correlação tão significativa, a variável **year** pode não trazer um impacto surpreendente. É prática comum nas empresas acompanhar métricas de crescimento anual. Portanto, embora a descoberta seja relevante, ela pode não representar um insight surpreendente.\n",
        "\n",
        "Com essa análise, podemos invalidar a hipótese inicial de que \"lojas deveriam vender mais ao longo dos anos\". Os dados demonstram uma tendência oposta - **as vendas tendem a decrescer com o passar dos anos**."
      ],
      "metadata": {
        "id": "bIKR-g8pCzRS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **9. O Maior Volume de Vendas é Observado no 2° Semestre do Ano**\n",
        "A partir da avaliação dos dados mensais, constatamos que as vendas apresentam valores elevados desde o mês 1 (janeiro) até o mês 6 (junho). No entanto, é a partir do mês 7 (julho) que percebemos um declínio significativo no volume de vendas.\n"
      ],
      "metadata": {
        "id": "dL0RE0GvCYvV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criação do DataFrame 'aux1', agrupando dados por 'month' e somando as 'sales', com índice resetado.\n",
        "aux1 = df4[['month', 'sales']].groupby('month').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Crie a visualização do gráfico de barras com a paleta padrão\n",
        "plt.subplot(1, 3, 1)\n",
        "ax1 = sns.barplot(x='month', y='sales', data=aux1, palette=\"viridis\")\n",
        "ax1.set_title('Vendas Totais por Mês', fontsize=16, weight='bold')\n",
        "ax1.set_xlabel('Mês', fontsize=13, weight='bold')\n",
        "ax1.set_ylabel('Vendas Totais', fontsize=13, weight='bold')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Crie a visualização do gráfico de regressão\n",
        "plt.subplot(1, 3, 2)\n",
        "ax2 = sns.regplot(x='month', y='sales', data=aux1, color='green')\n",
        "ax2.set_title('Tendência de Vendas ao Longo dos Meses', fontsize=16, weight='bold')\n",
        "ax2.set_xlabel('Mês', fontsize=13, weight='bold')\n",
        "ax2.set_ylabel('Vendas Totais', fontsize=13, weight='bold')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Crie a visualização do heatmap para análise de correlação\n",
        "plt.subplot(1, 3, 3)\n",
        "ax3 = sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='coolwarm')\n",
        "ax3.set_title('Correlação entre Mês e Vendas Totais', fontsize=16, weight='bold')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Otimize o layout e exiba a figura\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "LfBhHnMNDnCj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A observação de uma tendência decrescente nas vendas ao longo dos meses é corroborada por uma análise quantitativa mais robusta. O gráfico de regressão apresenta uma inclinação descendente, confirmando a tendência de queda. Além disso, **o coeficiente de correlação de -0.75**, obtido através da análise de correlação, aponta para uma **forte correlação negativa entre o mês do ano e as vendas**.\n",
        "\n",
        "Este indicativo forte sugere que o **mês em que a venda ocorre é um fator significativo na determinação do volume de vendas**. Isso significa que nosso modelo de previsão deve levar em consideração que as vendas tendem a ser menores no segundo semestre do ano.\n",
        "\n",
        "Com base nessas constatações, a hipótese de que \"lojas deveriam vender mais no segundo semestre do ano\" é refutada. Ao contrário, nossa análise mostra que **as lojas tendem a registrar volumes de vendas menores no segundo semestre**. Dessa forma, estamos prontos para avançar e testar a próxima hipótese."
      ],
      "metadata": {
        "id": "pUTahKyaE77_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 10. **O Volume de Vendas Aumenta Após o Dia 10 de Cada Mês**\n",
        "Na tentativa de verificar a hipótese de que \"As lojas tendem a registrar maiores vendas após o dia 10 de cada mês\", adotaremos uma abordagem analítica semelhante à utilizada nas seções anteriores para os anos e meses.\n",
        "\n",
        "Para isso, realizaremos uma substituição na nossa base de código, **trocando a variável 'year' por 'day'**. Isso nos permitirá criar um novo conjunto tríptico de visualizações, com a finalidade de examinar se há um aumento nas vendas depois do décimo dia de cada mês. Acompanhe a seguir os resultados desta análise."
      ],
      "metadata": {
        "id": "6pPo400gFPY2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Agrupando os dados por dia e somando as vendas\n",
        "aux1 = df4[['day', 'sales']].groupby('day').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de barras de vendas por dia\n",
        "plt.subplot(1, 3, 1)\n",
        "bp = sns.barplot(x='day', y='sales', data=aux1, palette='viridis')\n",
        "bp.set_xticklabels(bp.get_xticklabels(), rotation=90, horizontalalignment='right', fontsize=10) # Rotação de 90 graus e redução do tamanho da fonte\n",
        "plt.title('Vendas Totais por Dia')\n",
        "plt.xlabel('Dia')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Gráfico de regressão linear de vendas por dia\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x='day', y='sales', data=aux1, color='green')\n",
        "plt.title('Tendência de Vendas ao Longo dos Dias')\n",
        "plt.xlabel('Dia')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Heatmap da correlação entre as variáveis\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='coolwarm')\n",
        "plt.title('Correlação entre Dia e Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "ipgyOdjHFngA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para explorar detalhadamente a hipótese, devemos subdividir os nossos dados em duas categorias distintas: **dias anteriores e posteriores ao dia 10 de cada mês**. Para efetuar essa classificação, aplicamos a função **apply** ao nosso conjunto de dados, associada a uma função **lambda**. Com isso, criamos uma nova coluna denominada **before_after**, que categoriza os dias em **before_10_days** (antes do dia 10) e **after_10_days** (após o dia 10).\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "9Eei80fhIk40"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Adicionando uma nova coluna 'before_after' que verifica se o dia é antes ou depois do dia 10\n",
        "aux1['before_after'] = ['before_10_days' if dia <= 10 else 'after_10_days' for dia in aux1['day']]"
      ],
      "metadata": {
        "id": "oRE_vBpuIFqo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Assim, estamos estratificando nossos dados de acordo com a premissa que desejamos examinar. Agora para uma análise detalhada do desempenho das vendas nestes dois conjuntos distintos de dias.\n"
      ],
      "metadata": {
        "id": "5hWc1HqpI5-b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Agrupando os dados por 'before_after' e somando as 'sales', com índice resetado.\n",
        "aux2 = aux1[['before_after', 'sales']].groupby('before_after').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 8))\n",
        "\n",
        "# Gráfico de barras de vendas por dia\n",
        "plt.subplot(2, 2, 1)\n",
        "sns.barplot(x='day', y='sales', data=aux1)\n",
        "plt.title('Vendas Totais por Dia')\n",
        "plt.xlabel('Dia')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Gráfico de regressão linear de vendas por dia\n",
        "plt.subplot(2, 2, 2)\n",
        "sns.regplot(x='day', y='sales', data=aux1, color='green')\n",
        "plt.title('Tendência de Vendas ao Longo do Dia')\n",
        "plt.xlabel('Dia')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Heatmap da correlação entre as variáveis\n",
        "plt.subplot(2, 2, 3)\n",
        "sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='coolwarm')\n",
        "plt.title('Correlação entre Dia e Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Gráfico de barras de vendas Antes e Depois do dia 10\n",
        "plt.subplot(2, 2, 4)\n",
        "sns.barplot(x='before_after', y='sales', data=aux2)\n",
        "plt.title('Vendas Totais Antes e Depois do Dia 10')\n",
        "plt.xlabel('Período')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Ajustando o layout para melhor visualização\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "IYskmdiGsy8L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "A análise dos dados revela um padrão intrigante, que desafia a noção convencional de que os consumidores tendem a gastar mais imediatamente após receberem seus salários. Nossos dados indicam que **o volume de vendas é maior após o décimo dia de cada mês**, sugerindo um comportamento de compra diferenciado dos consumidores.\n",
        "\n",
        "Este insight pode ter implicações estratégicas significativas para ações de marketing e vendas. As empresas poderiam, por exemplo, **programar suas promoções e campanhas publicitárias para coincidir com este período de maior atividade de compra, potencialmente aumentando sua eficácia e impacto nas vendas**.\n"
      ],
      "metadata": {
        "id": "poRH4_OdL1H2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **11. As lojas apresentam uma diminuição no volume de vendas aos finais de semana**\n",
        "Estamos analisando a hipótese que postula uma redução no volume de vendas durante os finais de semana. Para verificar essa suposição, examinaremos a distribuição das vendas em relação aos dias da semana."
      ],
      "metadata": {
        "id": "wkX_cQOwMEbf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criação do DataFrame 'aux1', agrupando dados por 'day_of_week' e somando as 'sales', com índice resetado.\n",
        "aux1 = df4[['day_of_week', 'sales']].groupby('day_of_week').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 8))\n",
        "\n",
        "# Criação do gráfico de barras\n",
        "plt.subplot(1, 3, 1)\n",
        "sns.barplot(x='day_of_week', y='sales', data=aux1, palette='viridis')\n",
        "plt.title('Vendas Totais por Dia da Semana')\n",
        "plt.xlabel('Dia da Semana')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Criação do gráfico de regressão\n",
        "plt.subplot(1, 3, 2)\n",
        "sns.regplot(x='day_of_week', y='sales', data=aux1, color='green')\n",
        "plt.title('Tendência de Vendas ao Longo da Semana')\n",
        "plt.xlabel('Dia da Semana')\n",
        "plt.ylabel('Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Criação do heatmap para análise de correlação\n",
        "plt.subplot(1, 3, 3)\n",
        "sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='coolwarm')\n",
        "plt.title('Correlação entre Dia da Semana e Vendas Totais')\n",
        "sns.despine(bottom=True, left=True)\n",
        "\n",
        "# Mostrar a figura com todos os subplots\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "RF_oFEd5MkV7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Os resultados da análise confirmam a nossa hipótese. Há um declínio significativo nos volumes de venda durante os finais de semana, sendo o domingo o dia de menor movimentação nas lojas. Este insight é crucial, pois aponta para a necessidade de estratégias diferenciadas para impulsionar as vendas nestes dias.\n",
        "\n",
        "Além disso, identificamos uma **correlação negativa na distribuição das vendas ao longo da semana**. Isso indica que, conforme os dias avançam, existe uma tendência à redução das vendas. Esse comportamento padrão nos dá um panorama sobre o hábito de compra dos consumidores e pode ser estrategicamente utilizado para otimizar ações promocionais e de marketing.\n",
        "\n",
        "Em resumo, essas informações trazem a compreensão do comportamento de compra dos clientes e podem ser chave para estratégias comerciais mais efetivas e personalizadas para cada dia da semana.\n",
        "\n"
      ],
      "metadata": {
        "id": "VoAo5TZ8ODYp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **12. As lojas apresentam um volume de vendas reduzido durante os períodos de férias escolares**\n",
        "A seguir, vamos direcionar nossa análise para investigar o possível impacto das férias escolares no volume de vendas. Para explorar essa perspectiva, faremos uso de **school_holiday** presente em nosso conjunto de dados. Desta forma, buscaremos evidências que correlacionem o **período de férias escolares com alterações significativas nas vendas**."
      ],
      "metadata": {
        "id": "cnvkkNfsPqAE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Agrupando os dados por 'school_holiday' e somando as 'sales'\n",
        "aux1 = df4[['school_holiday', 'sales']].groupby('school_holiday').sum().reset_index()\n",
        "\n",
        "# Configurações do estilo\n",
        "sns.set_style('white')\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Configurando a área de plotagem\n",
        "fig, axs = plt.subplots(ncols=3, figsize=(22, 7))\n",
        "\n",
        "# Gráfico de barras das vendas durante as férias escolares\n",
        "sns.barplot(x='school_holiday', y='sales', data=aux1, ax=axs[0]).set_title('Vendas Totais Durante as Férias Escolares')\n",
        "\n",
        "# Gráfico de regressão das vendas durante as férias escolares\n",
        "sns.regplot(x='school_holiday', y='sales', data=aux1, ax=axs[1]).set_title('Tendência das Vendas Durante as Férias Escolares')\n",
        "\n",
        "# Mapa de calor da correlação entre as férias escolares e as vendas\n",
        "sns.heatmap(aux1.corr(method='pearson'), annot=True, cmap='Blues', ax=axs[2]).set_title('Correlação Entre Férias Escolares e Vendas')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "Byk34v-mPv7K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O **volume de vendas é notavelmente superior nos dias que não coincidem com as férias escolares** (**school_holiday = 0**), em comparação aos dias que são de férias escolares (**school_holiday' = 1**). Embora essa observação possa parecer intuitiva, dado que a quantidade de dias não relacionados às férias escolares é maior, o contraste notável entre os dois conjuntos reforça a relevância dessa distinção para a previsão de vendas.\n",
        "\n",
        "Para uma compreensão ainda mais profunda, introduzimos o **mês** como uma segunda variável na nossa análise. Essa nova abordagem permite **identificar se existem meses específicos onde as vendas durante as férias escolares chegam a rivalizar ou mesmo superar as vendas em dias comuns de aula**. Esta perspectiva adicional poderia desvendar padrões ocultos e insights valiosos para aprimorar estratégias de vendas e promoções."
      ],
      "metadata": {
        "id": "5aA3bAz4TAtF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Preparando os dados para visualização, agrupando as vendas por férias escolares\n",
        "aux1 = df4[['school_holiday', 'sales']].groupby('school_holiday').sum().reset_index()\n",
        "\n",
        "# Renomeando os valores 0 e 1 para 'Período Letivo' e 'Férias Escolares' em 'school_holiday'\n",
        "aux1['school_holiday'] = aux1['school_holiday'].map({0: 'Período Letivo', 1: 'Férias Escolares'})\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 10\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(24, 8))\n",
        "\n",
        "# Criação do gráfico de barras para férias escolares\n",
        "plt.subplot(2, 1, 1)\n",
        "sns.set_style(\"white\")\n",
        "sns.barplot(x='school_holiday', y='sales', data=aux1)\n",
        "plt.title('Vendas Durante as Férias Escolares')\n",
        "\n",
        "# Preparando os dados para visualização, agrupando as vendas por mês e por férias escolares\n",
        "aux2 = df4[['month', 'school_holiday', 'sales']].groupby(['month', 'school_holiday']).sum().reset_index()\n",
        "\n",
        "# Renomeando os valores 0 e 1 para 'Período Letivo' e 'Férias Escolares' em 'school_holiday'\n",
        "aux2['school_holiday'] = aux2['school_holiday'].map({0: 'Período Letivo', 1: 'Férias Escolares'})\n",
        "\n",
        "# Criação do gráfico de barras para vendas por mês, segmentado por férias escolares\n",
        "plt.subplot(2, 1, 2)\n",
        "sns.set_style(\"white\")\n",
        "g = sns.barplot(x='month', y='sales', hue='school_holiday', data=aux2)\n",
        "plt.title('Vendas por Mês Durante as Férias Escolares')\n",
        "\n",
        "# Movendo a legenda para fora do gráfico\n",
        "g.legend(loc='center left', bbox_to_anchor=(1, 0.5), ncol=1)\n",
        "\n",
        "# Mostrar a figura com todos os subplots\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "Q2VDFMULR2In"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao aprofundar nossa análise sobre o impacto dos feriados escolares no volume de vendas, percebemos um padrão intrigante ao longo do ano. A princípio, **os dias letivos apresentam um volume de vendas significativamente maior**, o que se mantém **consistente até chegarmos ao mês de julho**.\n",
        "\n",
        "No entanto, é no mês de julho, um tradicionalmente um período de férias escolares, as vendas nos dias de feriado aproximam-se das registradas em dias de aula. Esta mudança sinaliza a **influência das férias escolares no comportamento de compra**, provavelmente devido ao fato de que a maior parte das vendas ocorre durante este período.\n",
        "\n",
        "A descoberta mais surpreendente surge em agosto. Neste mês, contra todas as expectativas, **as vendas durante os feriados escolares ultrapassam as realizadas em dias letivos**. Esse comportamento reflete um desvio do padrão observado nos outros meses, indicando uma dinâmica de vendas diferente em agosto.\n",
        "\n",
        "Após esse pico, a situação se normaliza e as vendas em dias letivos voltam a superar as ocorridas em feriados escolares."
      ],
      "metadata": {
        "id": "b98uP2C1UQYF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Sumário das Hipóteses Avaliadas**\n",
        "\n",
        "1. **Lojas com maior sortimento deveriam vender mais**: Contrariando a expectativa, nossa análise mostrou que lojas com maior sortimento tendem a ter um volume de vendas menor, o que nos desafia a reconsiderar suposições comuns.\n",
        "\n",
        "2. **Lojas com competidores mais próximos deveriam vender menos**: A realidade provou ser o oposto do esperado. Descobrimos que as lojas com competidores mais próximos tendem a vender mais, o que indica a influência do ambiente competitivo sobre o comportamento do consumidor.\n",
        "\n",
        "3. **Lojas com competidores a mais tempo deveriam vender mais**: Aqui, a hipótese foi refutada. Na verdade, as lojas com competidores presentes por mais tempo tendem a vender menos, sugerindo que a maturidade do mercado pode impactar negativamente as vendas.\n",
        "\n",
        "4. **Lojas com promoções ativas por mais tempo deveriam vender mais**: Descobrimos que a duração das promoções não impulsiona necessariamente as vendas. Lojas com promoções ativas por períodos mais longos apresentaram, na verdade, um volume de vendas menor.\n",
        "\n",
        "5. **Lojas com mais promoções consecutivas deveriam vender mais**: Outro contrassenso. Lojas que realizaram mais promoções consecutivas demonstraram vendas reduzidas, o que pode indicar uma possível saturação de promoções aos olhos do consumidor.\n",
        "\n",
        "6. **Lojas abertas durante o Natal deveriam vender mais**: Nossa análise refutou essa hipótese. Lojas que permaneceram abertas durante o Natal apresentaram vendas menores.\n",
        "\n",
        "7. **Lojas deveriam vender mais ao longo dos anos**: Essa expectativa também foi contradita. Verificou-se uma tendência de queda nas vendas ao longo dos anos.\n",
        "\n",
        "8. **Lojas deveriam vender mais no segundo semestre do ano**: Novamente, a hipótese foi refutada. As lojas demonstraram ter um volume de vendas menor no segundo semestre do ano.\n",
        "\n",
        "9. **Após o décimo dia de cada mês, as lojas deveriam vender mais**: Neste caso, a hipótese foi validada. As lojas de fato vendem mais após o décimo dia de cada mês.\n",
        "\n",
        "10. **Lojas deveriam vender menos aos finais de semana**: A hipótese se mostrou verdadeira. As vendas são, em média, menores durante os finais de semana.\n",
        "\n",
        "11. **Lojas deveriam vender menos durante os feriados escolares**: Confirmamos essa hipótese, com uma exceção interessante para os meses de julho e agosto, quando as vendas aumentam durante os feriados escolares.\n",
        "\n",
        "A análise dessas hipóteses desvendou diversos padrões contraintuitivos que podem ser valiosos na formulação de estratégias de negócios."
      ],
      "metadata": {
        "id": "iDQTjyOaV6nz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Criando o DataFrame\n",
        "df = pd.DataFrame(\n",
        "    [\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",
        "    columns=['Hipóteses', 'Conclusão', 'Relevância'])\n",
        "\n",
        "# Mostrando o DataFrame\n",
        "print(df)\n"
      ],
      "metadata": {
        "id": "7is6yPd1zFOR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **4.3 Multivariate Analysis**\n",
        "Na Análise Multivariada, exploramos relações mútuas entre várias variáveis, além daquelas entre variáveis individuais e a variável resposta. Ela permite identificar correlações e auxilia na decisão de quais variáveis podem ser eliminadas para simplificar modelos de Machine Learning, sem comprometer a qualidade das informações.\n",
        "\n",
        "Este processo segue o Princípio da Parsimônia ou \"Navalha de Occam\", que opta pela preferência por modelos menos complexos para uma melhor generalização do aprendizado. A remoção de variáveis redundantes ou que carregam informações similares contribui para a redução da dimensionalidade dos dados, diminuindo a complexidade do modelo.\n",
        "\n",
        "Logo, a Análise Multivariada é uma ferramenta essencial para aprimorar a eficiência dos modelos de Machine Learning e obter insights mais profundos a partir dos dados."
      ],
      "metadata": {
        "id": "OKO7CgzgXim5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **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": [
        "# Cálculo da matriz de correlação\n",
        "correlation_num = num_attributes.corr(method='pearson')\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 10\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(30, 15))\n",
        "\n",
        "# Configurações para aprimorar a visualização\n",
        "sns.heatmap(correlation_num, annot=True, cmap='coolwarm', fmt=\".2f\", linewidths=0.5, square=True, cbar_kws={\"shrink\": 0.75}, annot_kws={\"size\": 10})\n",
        "plt.title('Matriz de Correlação dos Atributos Numéricos', fontsize=14)\n",
        "plt.xticks(rotation=45, fontsize=9)\n",
        "plt.yticks(rotation=0, fontsize=9)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "VeyNrBtgilk8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A matriz de correlação é representada por um espectro de cores: o **azul profundo simboliza uma forte correlação negativa**, enquanto o **vermelho sinaliza uma intensa correlação positiva**. As nuances intermediárias sugerem correlações menos expressivas.\n",
        "\n",
        "Por exemplo, se observarmos a correlação entre as variáveis **store** (loja) e **is_promo** (promoção ativa), notaremos um valor de **0.0046**. O mesmo valor pode ser encontrado em uma posição simétrica na matriz, quando comparando **is_promo** e **store**. A diagonal principal é marcada por quadrados vermelhos, indicando a correlação de uma variável consigo mesma, cujo valor é sempre 1.\n"
      ],
      "metadata": {
        "id": "kE_g-0n5oGIA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **4.3.2 Categorical Attributes**\n"
      ],
      "metadata": {
        "id": "Jn7C70eliWfA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df_cat = df4.select_dtypes(include='object')\n",
        "df_cat.head()"
      ],
      "metadata": {
        "id": "WxCPh-QRqF_5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Importação da biblioteca necessária\n",
        "from scipy import stats\n",
        "\n",
        "# Definição da função para calcular o coeficiente de Cramér-V\n",
        "def cramer_v(x, y):\n",
        "    # Criação da matriz de contingência a partir das duas variáveis categóricas\n",
        "    matriz_contingencia = pd.crosstab(x, y).values\n",
        "\n",
        "    # Cálculo do total de observações\n",
        "    total_observacoes = matriz_contingencia.sum()\n",
        "\n",
        "    # Identificação do número de linhas e colunas na matriz de contingência\n",
        "    num_linhas, num_colunas = matriz_contingencia.shape\n",
        "\n",
        "    # Cálculo do qui-quadrado a partir da matriz de contingência\n",
        "    qui_quadrado = stats.chi2_contingency(matriz_contingencia)[0]\n",
        "\n",
        "    # Cálculo e retorno do coeficiente de Cramér-V\n",
        "    return np.sqrt((qui_quadrado/total_observacoes) / (min(num_colunas-1, num_linhas-1)))\n"
      ],
      "metadata": {
        "id": "yjIZNlS8tZ-e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O Coeficiente V de Cramer, também conhecido como V de Kramer, é uma medida padronizada que avalia a **correlação entre duas variáveis categóricas**. Esta métrica é derivada do coeficiente qui-quadrado (χ²), porém leva em consideração o tamanho da amostra e o número de categorias envolvidas. O valor do Coeficiente V de Cramer oscila entre 0 e 1, onde:\n",
        "\n",
        "- O valor 0 representa a inexistência de qualquer associação entre as variáveis categóricas.\n",
        "- O valor 1 indica uma associação perfeita entre as variáveis.\n",
        "\n",
        "Esse coeficiente é, portanto, uma ferramenta importante na análise de dados, capaz de mostrar a intensidade da relação entre variáveis de natureza categórica."
      ],
      "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. 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": [
        "# Seleciona apenas os dados categóricos\n",
        "a = df4.select_dtypes(include='object')\n",
        "\n",
        "# Calcula o Cramer V para cada par de variáveis\n",
        "cramer_v_values = {col1: {col2: cramer_v(a[col1], a[col2]) for col2 in a.columns} for col1 in a.columns}\n",
        "\n",
        "# Cria o dataframe final\n",
        "d = pd.DataFrame(cramer_v_values)\n",
        "\n",
        "# Configurações do estilo, paleta de cores e tamanho da fonte do gráfico\n",
        "sns.set_style('white')\n",
        "sns.set_palette('Set2')\n",
        "plt.rcParams['font.size'] = 14\n",
        "\n",
        "# Ajustar o tamanho da figura\n",
        "plt.figure(figsize=(30, 6))\n",
        "\n",
        "# Cria o heatmap\n",
        "sns.heatmap(d, annot=True, cmap='coolwarm')  # usa a paleta de cores 'coolwarm'\n",
        "\n",
        "# Adiciona títulos\n",
        "plt.title(\"Correlação de Cramer V Entre Variáveis Categóricas\")  # título principal\n",
        "plt.xlabel(\"Variáveis\")  # título do eixo x\n",
        "plt.ylabel(\"Variáveis\")  # título do eixo y\n",
        "\n",
        "plt.show()  # mostra o gráfico\n"
      ],
      "metadata": {
        "id": "pcVf7dhLeZSn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **5. Data Wrangling**\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": "code",
      "source": [
        "# Concatena os DataFrames\n",
        "m = pd.concat([d2, d3, d4, ct1, ct2, d1, d5, d6]).T.reset_index()\n",
        "\n",
        "# Renomeia as colunas\n",
        "m.columns = ['Atributos', 'Mínimo', 'Máximo', 'Intervalo', 'Média', 'Mediana', 'Desvio Padrão', 'Assimetria', 'Curtose']\n",
        "\n",
        "# Ajusta a largura das células e o alinhamento do texto para melhor visualização\n",
        "m_styled = m.style.set_properties(**{'text-align': 'left', 'width':'10em'})\n",
        "\n",
        "# Adiciona formatação condicional para destacar a célula de maior valor em cada coluna\n",
        "m_styled = m_styled.highlight_max(color='green')\n",
        "\n",
        "# Exibe o DataFrame\n",
        "m_styled"
      ],
      "metadata": {
        "id": "MKTgDbX5iG1T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A fase de preparação de dados é um elemento crucial no processo de aprendizado de máquina. Se fosse necessário condensar a importância da preparação de dados em uma única frase, seria a seguinte: a maioria dos algoritmos de aprendizado de máquina são **projetados para trabalhar com dados numéricos e em escala uniforme**. Por isso, a preparação dos dados implica principalmente duas tarefas: a **conversão de dados categóricos em numéricos** e a **normalização da escala dos dados**.\n",
        "\n",
        "Tais algoritmos utilizam métodos de otimização que frequentemente se apoiam em operações matemáticas, como adições e multiplicações. Estes **métodos de otimização buscam encontrar os parâmetros mais eficazes para o conjunto de dados**, e para isso, recorrem a derivadas, que são definidas exclusivamente para variáveis numéricas. Assim sendo, **é necessário converter variáveis categóricas em numéricas** sem que isso signifique a perda de informações vitais.\n",
        "\n",
        "Outro ponto crucial é a normalização da escala dos dados. Por exemplo, ao analisarmos duas variáveis, **day_of_week** que varia de 1 a 7 e **competition_distance** que varia de 20 metros a 200 mil metros, percebemos que as escalas são enormemente distintas. Essa discrepância pode afetar o aprendizado do modelo, uma vez que métodos de otimização, como o gradiente descendente, tendem a priorizar variáveis com maior amplitude. Isso pode levar **o modelo a atribuir excessiva importância a variáveis com escalas maiores**. Para contornar essa questão, precisamos normalizar os dados, assegurando que todas as variáveis estejam na mesma escala."
      ],
      "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": [
        " ---\n",
        "## **5.2 [Data Normalization](https://www.kaggle.com/code/discdiver/guide-to-scaling-and-standardizing/notebook)**\n",
        "Quando falamos de **normalização**, estamos falando sobre uma maneira de fazer com que todos os números de um conjunto **tenham uma escala similar**. Imagine que você tenha alturas de pessoas em metros e pesos em quilogramas. Se você olhar para os números diretamente, os pesos parecerão muito maiores que as alturas, simplesmente porque as alturas são medidas em metros (geralmente menos que 2) e os pesos em quilos (frequentemente acima de 40 ou 50).\n",
        "\n",
        "A normalização é como **converter tudo para uma moeda comum**, tornando mais fácil comparar diferentes tipos de números. No nosso método de normalização, o que fazemos é ajustar os números para que, **em média, eles sejam 0 e tenham uma variação padrão**. Isso significa que estamos **redimensionando os números**, mas mantendo suas relações relativas intactas.\n",
        "\n",
        "Para conseguir isso, pegamos cada número, subtraímos a média de todos os números do conjunto e depois dividimos pelo quanto eles geralmente variam (desvio padrão). Existem ferramentas e programas, como o Scikit-Learn, que fazem isso para nós de forma eficiente.\n",
        "\n",
        "![non-normalized.png](data:image/png;base64,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)\n",
        "\n",
        "Contudo, é **crucial** destacar que a **normalização pode alterar a característica da distribuição original dos dados**. Por exemplo, ao considerarmos distribuições variadas como **Beta (na cor vermelha), exponencial (em azul)** e **duas distribuições normais (nas cores roxa e verde)**, ao normalizarmos, todas convergirão 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": [
        "Antes de iniciar a normalização, é essencial determinar quais variáveis necessitam desse processo. Esta decisão é baseada na distribuição dessas variáveis, observadas previamente durante a **análise exploratória de dados**.\n",
        "\n",
        "Desse modo, retornamos à seção de **Análise Univarida** no notebook, onde já estudamos a distribuição de todas as variáveis.\n",
        "\n",
        "Nossa atenção deve se concentrar nas **Variáveis Numéricas**. Assim, revisaremos a subseção \"Análise Univarida - Variáveis Numéricas\".\n",
        "\n",
        "O passo crucial agora é **reconhecer as variáveis com distribuição normal**. Vale reforçar que **a normalização é mais impactante quando direcionada a variáveis que já apresentam essa distribuição**. Logo, o desafio é identificar quais variáveis possuem esse perfil."
      ],
      "metadata": {
        "id": "Dc773lFTWIOs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configurações iniciais para melhorar a estética dos gráficos\n",
        "sns.set_style(\"white\")\n",
        "sns.set_palette(\"Set2\")\n",
        "\n",
        "# Plotando os histogramas\n",
        "fig = plt.figure(figsize=(25, 10))\n",
        "\n",
        "for i, column in enumerate(num_attributes.columns, start=1):\n",
        "    ax = fig.add_subplot(4, 4, i)  # Supondo que temos até 16 colunas no DataFrame\n",
        "    sns.histplot(num_attributes[column], bins=25, kde=True, ax=ax)\n",
        "\n",
        "    # Ajustando os títulos e eixos\n",
        "    ax.set_title(f'Distribuição de {column}', fontsize=15)\n",
        "    ax.set_xlabel(column, fontsize=12)\n",
        "    ax.set_ylabel('Frequência', fontsize=12)\n",
        "    ax.tick_params(axis='x', labelsize=10)\n",
        "    ax.tick_params(axis='y', labelsize=10)\n",
        "\n",
        "# Ajustando o layout para garantir que os gráficos não se sobreponham e maximizar a clareza\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "I8stEJUOV-4Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Embora se possa observar que certas variáveis, como **\"sales\"**, tendem a uma distribuição mais próxima da normal, ainda assim não se configuram como uma distribuição genuinamente normal. Por conta das peculiaridades e qualidade de nossos dados, seria mais prudente **não aplicar a normalização**, evitando assim impor um formato que poderia não ser o mais apropriado.\n",
        "\n",
        "Assim sendo, nossa próxima etapa será a **aplicação da técnica de Rescaling** em todas as variáveis. Esta estratégia tem o propósito de padronizar as variáveis para um mesmo intervalo, otimizando a performance dos algoritmos de aprendizado de máquina na sequência do projeto."
      ],
      "metadata": {
        "id": "zeS_CS0FeoVn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **5.3 Rescaling**\n",
        "Antes de avançarmos, é vital entender a **motivação por trás da preparação de dados** em contextos de ciência de dados.\n",
        "\n",
        "1. **Variáveis categóricas:** Nosso conjunto apresenta três dessas variáveis que necessitam ser transformadas em formatos numéricos. Isso se deve ao fato de que os algoritmos de aprendizado de máquina operam primordialmente com entradas numéricas, tornando essa conversão essencial.\n",
        "\n",
        "2. **Variáveis numéricas:** Observamos em nosso dataset uma ampla variedade de intervalos. Os algoritmos tendem a dar maior relevância a variáveis com valores absolutos mais elevados, o que pode ser enganoso. Para ilustrar, a variável **competition_distance** possui valores mais expressivos que **day_of_week**, mas isso não necessariamente sinaliza que ela seja intrinsecamente mais relevante. Dessa maneira, é necessário nivelar esses intervalos, assegurando que o algoritmo reconheça a verdadeira significância de cada variável.\n",
        "\n",
        "Desta forma, a **técnica de Rescaling** surge como uma ferramenta para **padronizar todas as variáveis em um range comum**, otimizando a performance dos algoritmos de aprendizado de máquina."
      ],
      "metadata": {
        "id": "HvZnyVSmUt1X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.3.1 Min-Max Scaler**\n",
        "A técnica de **escalonamento** denominada **Min-Max Scaler** é fundamental ao trabalhar com conjuntos de dados que não seguem uma distribuição normal. Esta técnica ajusta os valores de uma variável de modo que eles fiquem dentro de uma escala estabelecida, **geralmente entre 0 e 1**. Ao fazer isso, ainda **mantemos a estrutura original dos dados, mas eles são transformados para uma escala padronizada**. Esta padronização facilita a análise subsequente, especialmente quando utilizamos algoritmos que são sensíveis à magnitude dos valores.\n",
        "\n",
        "![non-normalized.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "nw9y68FVgvjB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Após a implementação do 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": [
        "---\n",
        "### **5.3.2 Robust Scaler**\n",
        "O Robust Scaler é uma técnica utilizada para ajustar a escala de variáveis, **especialmente quando há a presença de valores atípicos**, ou **outliers**. Enquanto o método Min-Max Scaler pode ser influenciado por esses outliers (pois considera os valores mínimos e máximos), o **Robust Scaler é mais estável** nesse aspecto.\n",
        "\n",
        "Ao invés de usar os valores extremos, o Robust Scaler **baseia-se nos quartis da distribuição** dos dados. Basicamente, ele ajusta os dados usando o primeiro (25º percentil) e terceiro quartis (75º percentil), que são pontos da distribuição menos afetados por outliers.\n",
        "\n",
        "Essa abordagem é particularmente útil quando queremos **manter a estrutura original dos dados**, evitando distorções provocadas por valores muito discrepantes. Contudo, é importante notar que, apesar de ser menos sensível a outliers, o Robust Scaler **pode alterar a característica da distribuição de alguns conjuntos** de dados."
      ],
      "metadata": {
        "id": "yuj9p1NQis_0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **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.\n",
        "\n",
        "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": [
        "No código em questão, pedimos ao pandas para nos mostrar colunas que são, predominantemente, numéricas, ou seja, aquelas do tipo 'int64' ou 'float64'. Ao visualizarmos as primeiras linhas, confirmamos se a seleção foi feita corretamente.\n",
        "\n",
        "**Decisão de Escalonamento:** A natureza dos seus dados guia se deve aplicar o MinMaxScaler ou o RobustScaler. No nosso caso, optamos por usar estas técnicas nas variáveis como **day_of_week**, **competition_distance** e outras, totalizando oito variáveis específicas.\n",
        "\n",
        "**Variáveis Cíclicas:** Algumas variáveis têm um padrão que se repete ao longo do tempo, como **month** ou **day_of_week**. Chamamos essas variáveis de cíclicas. Em preparação para modelagem, essas variáveis beneficiam-se de uma transformação especial, levando em conta sua **natureza repetitiva**.\n",
        "\n",
        "**Variáveis Não Cíclicas:** Por outro lado, temos variáveis que não seguem esse ciclo repetitivo, por exemplo, **competition_distance** e **year**. A grande questão é decidir qual técnica de escalonamento é a mais apropriada. E aqui, **a decisão frequentemente se baseia na presença ou ausência de outliers**, que são valores extremos que podem distorcer análises.\n",
        "\n",
        "**Identificação de Outliers:** Uma ferramenta visual, como o **boxplot**, nos ajuda nesse processo. Ao visualizar, por exemplo, a variável **competition_distance** por meio de um boxplot, podemos rapidamente identificar a presença de outliers e, assim, tomar decisões mais informadas sobre a técnica de escalonamento a ser aplicada."
      ],
      "metadata": {
        "id": "qLBkccrpmgeq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 1. **Robust Scaler em 'competition_distance'**"
      ],
      "metadata": {
        "id": "kN2pY-xCrmKT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configuração do tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Primeiro Gráfico - Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_distance'], color='skyblue')\n",
        "plt.title('Boxplot da Distância de Concorrência', fontsize=15)\n",
        "plt.xlabel('Distância de Concorrência', fontsize=12)\n",
        "plt.ylabel('Distribuição', fontsize=12)\n",
        "\n",
        "# Segundo Gráfico - Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['competition_distance'], color='salmon', bins=20, kde=True)\n",
        "plt.title('Distribuição da Distância de Concorrência', fontsize=15)\n",
        "plt.xlabel('Distância de Concorrência', fontsize=12)\n",
        "plt.ylabel('Densidade', fontsize=12)\n",
        "\n",
        "# Ajuste do layout para evitar sobreposição e melhor apresentação\n",
        "plt.tight_layout()\n",
        "\n",
        "# Exibir a figura\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "ww_dLcaLp6Em"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No contexto dos nossos dados, detectamos **outliers** marcantes na variável **competition_distance**. Diante disso, a escolha mais acertada é o **RobustScaler**, que se destaca justamente por sua menor sensibilidade a outliers. Essa característica o torna especialmente indicado para o nosso cenário.\n",
        "\n",
        "Para começarmos a usar o **RobustScaler**, o primeiro passo é trazê-lo para o nosso código. Isso é feito importando-o da renomada biblioteca **Scikit-learn** em Python."
      ],
      "metadata": {
        "id": "BtbY5pEfqx9T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando a ferramenta necessária\n",
        "from sklearn.preprocessing import RobustScaler\n",
        "\n",
        "# Instanciando o RobustScaler\n",
        "robust_scaler = RobustScaler()\n",
        "\n",
        "# Aplicando a transformação na coluna desejada\n",
        "df5['competition_distance'] = robust_scaler.fit_transform(df5[['competition_distance']])"
      ],
      "metadata": {
        "id": "3oE7sKkPqkug"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Quando falamos sobre o **RobustScaler**, estamos basicamente discutindo uma ferramenta que ajuda a ajustar nossos dados, especialmente quando temos alguns valores outliers que se desviam muito da média. Imagine que você esteja tentando nivelar um terreno, mas há algumas pedras grandes no caminho. O RobustScaler ajuda a \"achatar\" essas pedras para que elas não interfiram muito na paisagem geral.\n",
        "\n",
        "A mágica acontece com o método **fit_transform()**. A primeira parte, **fit**, é como se estivéssemos medindo as pedras, entendendo seu tamanho e localização. A segunda parte, **transform**, é onde nivelamos tudo.\n",
        "\n",
        "Então, depois de usar o RobustScaler, a coluna **competition_distance** ainda tem seus valores originais, mas são apresentados de uma maneira que faz mais sentido para nossas análises, pois as \"grandes pedras\" já não são mais um problema tão grande."
      ],
      "metadata": {
        "id": "55B8YbUurGSM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configurando o tamanho geral da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_distance'], color='skyblue')\n",
        "plt.title('Boxplot da Distância de Competição com Robust Scaler', fontsize=16)\n",
        "plt.xlabel('Distância de Competição', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Gráfico de Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df5['competition_distance'], color='salmon', bins=30, kde=True)\n",
        "plt.title('Distribuição da Distância de Competição com Robust Scaler', fontsize=16)\n",
        "plt.xlabel('Distância de Competição', fontsize=14)\n",
        "plt.ylabel('Densidade', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Ajustando os gráficos para não se sobrepor\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "kppIDAgAVGKP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Quando observamos o gráfico de **competition_distance**, notamos uma mudança. **Antes, os valores iam de 0 até 200 mil**. Mas, depois que aplicamos uma técnica chamada **Robust Scaler**, a história mudou um pouco: os valores agora variam entre 0 e 1.\n",
        "\n",
        "Mas eis o detalhe: **a forma da distribuição não muda**, apenas o intervalo de valores. Se você imaginar que os dados são como uma borracha, esticamos ou comprimimos essa borracha para que ela caiba entre 0 e 1. Ela ainda **tem o mesmo formato**, mas **em um tamanho diferente**.\n",
        "\n",
        "Por que fazer isso? Bem, ao trazer todas as variáveis para a mesma escala, entre 0 e 1, **garantimos que nenhuma delas seja mais \"importante\" do que outra apenas por ter números maiores**. É como se estivéssemos nivelando o campo de jogo para todos os dados. Assim, quando vamos construir um modelo, cada variável contribui de maneira justa.\n",
        "\n",
        "Isso é o que torna o **Robust Scaler** tão valioso. Ele permite que as variáveis conversem entre si em igualdade de condições, mas sem mudar a essência de como cada uma é distribuída."
      ],
      "metadata": {
        "id": "-fe1Gl80VVcQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 2. **Robust Scaler em 'competition_time_month'**\n",
        "Adotaremos o mesmo procedimento para a variável 'competition_time_month'.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "bUO-YkQ1sDS7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configurando o tamanho geral da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_time_month'], color='skyblue')\n",
        "plt.title('Boxplot dos Meses de Competição com Robust Scaler', fontsize=16)\n",
        "plt.xlabel('Meses de Competição', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Gráfico de Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['competition_time_month'], color='salmon', bins=30, kde=True)\n",
        "plt.title('Distribuição dos Meses de Competição com Robust Scaler', fontsize=16)\n",
        "plt.xlabel('Meses de Competição', fontsize=14)\n",
        "plt.ylabel('Densidade', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Ajustando os gráficos para não se sobrepor\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "nhO5yzofsG03"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import RobustScaler\n",
        "\n",
        "# Aplicando o RobustScaler à coluna\n",
        "rs = RobustScaler()\n",
        "df5['competition_time_month'] = rs.fit_transform(df5[['competition_time_month']])\n",
        "\n",
        "# Configurando o tamanho geral da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['competition_time_month'], color='skyblue')\n",
        "plt.title('Boxplot dos Meses de Competição com Robust Scaler', fontsize=16)\n",
        "plt.xlabel('Meses de Competição (Escalado)', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Gráfico de Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df5['competition_time_month'], color='salmon', bins=30, kde=True)\n",
        "plt.title('Distribuição dos Meses de Competição', fontsize=16)\n",
        "plt.xlabel('Meses de Competição', fontsize=14)\n",
        "plt.ylabel('Densidade', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Ajustando os gráficos para não se sobrepor\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "wsnkFxQ1scpV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 3. **MinMaxScaler em promo_time_week**\n"
      ],
      "metadata": {
        "id": "556yVdUOs9Lo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configurando o tamanho geral da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['promo_time_week'], color='skyblue')\n",
        "plt.title('Boxplot das Semanas de Promoção', fontsize=16)\n",
        "plt.xlabel('Semanas de Promoção', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Gráfico de Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['promo_time_week'], color='salmon', bins=30, kde=True)\n",
        "plt.title('Distribuição das Semanas de Promoção', fontsize=16)\n",
        "plt.xlabel('Semanas de Promoção', fontsize=14)\n",
        "plt.ylabel('Densidade', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Ajustando os gráficos para não se sobrepor\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "DuQt6Nx5uYoz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import MinMaxScaler\n",
        "\n",
        "# Aplicando a transformação MinMaxScaler\n",
        "mms = MinMaxScaler()\n",
        "df5['promo_time_week'] = mms.fit_transform(df5[['promo_time_week']])\n",
        "\n",
        "# Configurando o tamanho geral da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['promo_time_week'], color='skyblue')\n",
        "plt.title('Boxplot das Semanas de Promoção com MinMax Scaler', fontsize=16)\n",
        "plt.xlabel('Semanas de Promoção', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Gráfico de Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['promo_time_week'], color='salmon', bins=30, kde=True)\n",
        "plt.title('Distribuição das Semanas de Promoção', fontsize=16)\n",
        "plt.xlabel('Semanas de Promoção', fontsize=14)\n",
        "plt.ylabel('Densidade', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Ajustando os gráficos para não se sobrepor\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "VJsD-Oqdv2NM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **4. MinMaxScaler em 'year'**\n"
      ],
      "metadata": {
        "id": "mQHLnkKUUqY6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Configurando o tamanho geral da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['year'], color='skyblue')\n",
        "plt.title('Boxplot do Ano', fontsize=16)\n",
        "plt.xlabel('Ano', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Gráfico de Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['year'], color='salmon', bins=30, kde=True)\n",
        "plt.title('Distribuição do Ano', fontsize=16)\n",
        "plt.xlabel('Ano', fontsize=14)\n",
        "plt.ylabel('Densidade', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Ajustando os gráficos para não se sobrepor\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "RieVLz6NU0ZQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import MinMaxScaler\n",
        "\n",
        "# Normalizando a coluna 'year' com MinMaxScaler\n",
        "mms = MinMaxScaler()\n",
        "df5['year'] = mms.fit_transform(df5[['year']])\n",
        "\n",
        "# Configurando o tamanho geral da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Gráfico de Boxplot\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.boxplot(df5['year'], color='skyblue')\n",
        "plt.title('Boxplot do Ano com MinMaxScaler', fontsize=16)\n",
        "plt.xlabel('Ano Normalizado', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Gráfico de Distribuição\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df4['year'], color='salmon', bins=30, kde=True)\n",
        "plt.title('Distribuição do Ano', fontsize=16)\n",
        "plt.xlabel('Ano', fontsize=14)\n",
        "plt.ylabel('Densidade', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "\n",
        "# Ajustando os gráficos para não se sobrepor\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "MlvpUSjgUscY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **5.4 Encoding**\n",
        "Ao preparar os dados para modelos de aprendizado de máquina, precisamos converter as variáveis categóricas em numéricas. Isso é conhecido como **codificação (encoding)**. Por exemplo, transformar uma variável \"cor\" que tem valores como \"vermelho\", \"azul\" e \"verde\" em números 1, 2 e 3.\n",
        "\n",
        "Por que fazer isso? A maioria dos modelos só entende números. Não sabe como lidar com palavras ou categorias diretamente.\n",
        "\n",
        "Existem muitos métodos para fazer essa codificação. Cada um tem sua utilidade, e a escolha do melhor método depende da natureza dos seus dados. Aqui vão duas recomendações:\n",
        "\n",
        "1. **Estude seus dados:** Veja os diferentes valores que sua variável categórica pode ter e como eles se relacionam com o que você quer prever.\n",
        "2. **Teste diferentes abordagens:** A melhor maneira de saber o que funciona para seus dados é experimentar. Aplique diferentes métodos de codificação e veja qual oferece os melhores resultados.\n",
        "\n",
        "Lembre-se: o que funciona bem para um conjunto de dados pode não ser ideal para outro. Portanto, conhecer e experimentar é a chave."
      ],
      "metadata": {
        "id": "SD3mff_DVZM_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Tipos de Encoding**\n",
        "Existem diferentes formas de transformar palavras ou categorias em números para que nossos modelos de máquina possam entendê-las. Aqui estão seis métodos comuns para isso:\n",
        "\n",
        "- **One-Hot Encoding:** Cria uma coluna para cada categoria. Se a categoria estiver presente, o valor é 1, se não, é 0.\n",
        "\n",
        "- **Label Encoding:** Atribui um número diferente a cada categoria. Útil quando há muitas categorias.\n",
        "\n",
        "- **Ordinal Encoding:** Como o Label, mas respeita a ordem das categorias. Por exemplo, \"baixo\", \"médio\" e \"alto\" podem virar 1, 2 e 3.\n",
        "\n",
        "- **Target Encoding:** Usa a média do valor alvo de cada categoria como seu número.\n",
        "\n",
        "- **Frequency Encoding:** Em vez de média, este método usa a frequência de aparição da categoria.\n",
        "\n",
        "- **Binary Encoding:** Converte as categorias em códigos binários. Bom para muitas categorias.\n",
        "\n",
        "Quer se aprofundar? Há um [artigo](https://towardsdatascience.com/all-about-categorical-variable-encoding-305f3361fd02) excelente sobre o tema. E se estiver programando em Python, o pacote [category_encoders](https://contrib.scikit-learn.org/category_encoders/) pode ser útil."
      ],
      "metadata": {
        "id": "EjpIIHVdckUe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.4.1 One-Hot Encoding**\n",
        "O One-Hot Encoding é como criar uma \"caixinha de seleção\" para cada categoria de uma variável.\n",
        "\n",
        "Imagine que temos uma variável chamada 'Temperatura', que pode ser 'Frio', 'Morno', 'Quente' ou 'Muito Quente'. Ao usar One-Hot Encoding, faremos uma coluna para cada uma destas opções.\n",
        "\n",
        "Agora, pense que você tem uma linha onde a 'Temperatura' é 'Quente'. Nesse caso, você vai \"marcar\" a caixinha (ou coluna) 'Quente' com '1' e deixar todas as outras (Frio, Morno, Muito Quente) como '0'.\n",
        "\n",
        "É como se cada opção tivesse sua própria caixinha e nós marcássemos a que se aplica em cada caso.\n",
        "\n"
      ],
      "metadata": {
        "id": "-2AZMn4jfgs3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = {'Temperatura': ['Quente'], 'Frio': [0], 'Morno': [0], 'Quente': [1], 'Muito Quente': [0]}\n",
        "df = pd.DataFrame(data)\n",
        "print(df)"
      ],
      "metadata": {
        "id": "LSdoKdN9hqAl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Imagine que você tem um conjunto de lápis coloridos. Usar a técnica do One-Hot Encoding é como separar cada lápis por sua cor em caixinhas diferentes.\n",
        "\n",
        "**Vantagens:**\n",
        "- É como se você tivesse uma caixinha para cada cor, tornando fácil identificar qual lápis você possui (ou seja, é simples de aplicar).\n",
        "- Seu conjunto inicial de lápis (variáveis categóricas) agora pode ser representado de forma numérica.\n",
        "\n",
        "**Desvantagens:**\n",
        "- Se você tiver muitas cores de lápis, acabará com muitas caixinhas! Isso pode ocupar muito espaço (aumenta a dimensionalidade dos dados).\n",
        "- Ter muitas caixinhas pode complicar quando você for desenhar algo (ou seja, tornar o aprendizado do modelo mais complexo).\n",
        "\n",
        "**Exemplo Prático:**\n",
        "Pense em dias comuns e feriados. Os feriados são como cores especiais em seu conjunto. Ao usar One-Hot Encoding, você pode separar os feriados em sua própria caixinha, destacando sua importância. Isso ajuda a perceber as diferenças de comportamento entre um dia comum e um feriado, o que pode ser valioso para modelos que preveem eventos nessas datas.\n",
        "\n"
      ],
      "metadata": {
        "id": "ye1N2k-7hor6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.4.2 Label Encoding**\n",
        "Imagine que você tem um conjunto de figurinhas de animais. Usar o Label Encoding é como dar um número de identificação para cada animal, como se estivesse catalogando sua coleção.\n",
        "\n",
        "**O que acontece?**\n",
        "- Cada animal (categoria) recebe um número único, como um código.\n",
        "- Esse número não diz nada sobre o animal. Por exemplo, dar o número 1 para um gato e 2 para um cachorro não significa que um é \"melhor\" ou \"maior\" que o outro. É apenas um código!\n",
        "\n",
        "**Exemplo Prático:**\n",
        "Se pensarmos em uma coleção com figurinhas de temperaturas como 'Cold' (Frio), 'Warm' (Morno), 'Hot' (Quente) e 'Very Hot' (Muito Quente), a técnica de Label Encoding poderia catalogá-las assim:\n",
        "\n",
        "- Frio: 1\n",
        "- Morno: 2\n",
        "- Quente: 3\n",
        "- Muito Quente: 4\n",
        "\n",
        "Lembre-se: Os números são apenas códigos. No nosso exemplo, não significa que \"Muito Quente\" é 4 vezes mais quente que \"Frio\". Eles são apenas identificadores."
      ],
      "metadata": {
        "id": "ml_efcR4gabf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = {'Temperatura': ['Quente', 'Frio', 'Muito Quente', 'Morno'], 'Codificação (Label Encoding)': [1, 2, 3, 4]}\n",
        "df = pd.DataFrame(data)\n",
        "df"
      ],
      "metadata": {
        "id": "e0sxcE5phbQa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao usar o Label Encoding, atribuímos um número único para cada categoria da variável 'Temperatura'. Esses números não refletem uma ordem ou hierarquia; são apenas representações numéricas das categorias.\n",
        "\n",
        "Esta técnica é especialmente valiosa quando estamos trabalhando com categorias que não têm uma sequência ou relação clara entre elas, como nomes de cidades ou marcas de produtos. Porém, precisamos ter cautela: se a variável categórica tiver uma sequência lógica (como 'baixo', 'médio', 'alto'), o uso do Label Encoding pode confundir o modelo. Isso porque, nesse método, os números são apenas etiquetas e não refletem a ordem real das categorias."
      ],
      "metadata": {
        "id": "yhZLlqQxhUdi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.4.3 Ordinal Encoding**\n",
        "O Ordinal Encoding é uma técnica especial de codificação que leva em conta a ordem ou hierarquia das categorias. Isso é essencial quando as categorias têm uma sequência lógica, como em graduações ou intensidades.\n",
        "\n",
        "Por exemplo, a variável 'Temperatura', que possui as categorias 'Cold' (Frio), 'Warm' (Morno), 'Hot' (Quente) e 'Very Hot' (Muito Quente). Diferentemente do Label Encoding, que apenas etiqueta as categorias, o Ordinal Encoding respeita a ordem natural. Portanto, ao codificar, 'Cold' teria um valor menor que 'Warm', que seria menor que 'Hot', que, por fim, seria menor que 'Very Hot'.\n",
        "\n",
        "Em resumo, o Ordinal Encoding é como se estivéssemos dando notas em uma escala para cada categoria, respeitando sua posição ou intensidade na sequência."
      ],
      "metadata": {
        "id": "vlnHaa9EiA4S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from sklearn.preprocessing import OrdinalEncoder\n",
        "\n",
        "# Dados iniciais\n",
        "data = {'Temperatura': ['Cold', 'Warm', 'Hot', 'Very Hot']}\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Codificando a coluna 'Temperatura' respeitando a ordem das categorias\n",
        "encoder = OrdinalEncoder(categories=[['Cold', 'Warm', 'Hot', 'Very Hot']])\n",
        "df['Temperatura_codificada'] = encoder.fit_transform(df[['Temperatura']])\n",
        "print(df)"
      ],
      "metadata": {
        "id": "D0teC3wwi2JP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O Ordinal Encoding reflete a sequência das categorias categóricas na sua representação numérica, tornando os dados mais relevantes para alguns algoritmos de aprendizado de máquina.\n",
        "\n",
        "Porém, é crucial usá-lo somente quando há uma ordem clara entre as categorias. Caso contrário, poderíamos induzir uma hierarquia inexistente, comprometendo a precisão do modelo de aprendizado."
      ],
      "metadata": {
        "id": "zhTHvtyQi81I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.4.4 Target Encoding**\n",
        "A codificação *target* transforma categorias categóricas baseando-se na média do valor alvo associado a cada categoria.\n",
        "\n",
        "Imagine que temos uma variável categórica \"Temperatura\" com categorias como 'Quente', 'Frio', 'Muito Quente' e 'Morno'. E também, temos uma variável alvo, como \"Vendas\".\n",
        "\n",
        "Ao usarmos a codificação *target* na \"Temperatura\", substituímos cada categoria pela média de \"Vendas\" correspondente a ela."
      ],
      "metadata": {
        "id": "LDyouBpOjHcg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "data = {\n",
        "    'Temperatura': ['Quente', 'Frio', 'Muito Quente', 'Morno', 'Quente', 'Morno', 'Morno', 'Quente', 'Quente', 'Frio'],\n",
        "    'Valor_Alvo': [0.7, 0.5, 0.2, 0.3, 0.7, 0.3, 0.3, 0.7, 0.7, 0.5]\n",
        "}\n",
        "\n",
        "df = pd.DataFrame(data)\n",
        "df\n"
      ],
      "metadata": {
        "id": "zZfKHYvijJ5Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Quando temos uma variável categórica com muitas categorias diferentes, usar a codificação target é uma mão na roda! Por quê? Imagine que cada categoria virasse uma coluna nova, como acontece no método one-hot. Teríamos um monte de colunas!\n",
        "\n",
        "Mas com a codificação target, a gente evita essa \"explosão\" de colunas, tornando a análise mais simples e eficaz."
      ],
      "metadata": {
        "id": "PnGQp6-qlKpr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.4.5 Frequency Encoding**\n",
        "Vamos falar da codificação por frequência, um jeito bem prático de lidar com variáveis cheias de categorias diferentes. A ideia é simples: ao invés de se preocupar com o nome da categoria, vamos ver a frequência que ela aprece.\n",
        "\n",
        "Imagine que estamos falando sobre temperaturas: 'Quente', 'Frio', 'Muito Quente' e 'Morno'. No lugar de cada \"Quente\", por exemplo, colocaríamos o número de vezes que \"Quente\" aparece ou a proporção dele no nosso conjunto todo."
      ],
      "metadata": {
        "id": "55e-IEGKlbRF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Dados sobre temperaturas\n",
        "dados = {\n",
        "    'Temperatura': ['Quente', 'Frio', 'Muito Quente', 'Morno', 'Quente', 'Morno', 'Morno', 'Quente', 'Quente', 'Frio'],\n",
        "    'Valor_Correspondente': [0.4, 0.2, 0.1, 0.3, 0.4, 0.3, 0.3, 0.4, 0.4, 0.2]\n",
        "}\n",
        "\n",
        "# Transformando os dados em uma tabela (DataFrame)\n",
        "df_temperaturas = pd.DataFrame(dados)\n",
        "\n",
        "# Vamos ver como ficou!\n",
        "print(df_temperaturas)\n"
      ],
      "metadata": {
        "id": "4KUnrTIjk6Ms"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A técnica de codificação por frequência é bem prática quando lidamos com variáveis categóricas que representam, por exemplo, \"nomes\" ou \"etiquetas\" sem uma ordem ou relação clara entre eles. Imagine que você está trabalhando em um projeto relacionado a marcas de carros. Aqui, nomes como 'Chevrolet', 'Ford' e outros não têm uma hierarquia ou ordem específica entre si.\n",
        "\n",
        "Neste cenário, a codificação por frequência pode funcionar. Com ela, em vez de trabalhar diretamente com os nomes das marcas, você representaria cada marca pela quantidade de vezes que ela aparece no seu conjunto de dados. Dessa forma, 'Chevrolet' poderia ser substituído pelo número de vezes que essa marca aparece, o mesmo valendo para 'Ford' e assim por diante.\n",
        "\n",
        "Assim, conseguimos dar um tratamento numérico à nossa informação, mantendo a relevância dos dados e facilitando o trabalho dos algoritmos."
      ],
      "metadata": {
        "id": "aWO4_s88mnX1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.4.6 Embeding Encoding**\n",
        "A técnica de \"Embedding Encoding\" (ou Codificação de Incorporação) é como uma varinha mágica no mundo do Deep Learning, especialmente quando estamos falando de Processamento de Linguagem Natural (NLP). Seu objetivo principal é transformar palavras ou categorias em pequenos vetores cheios de números. As palavras ou categorias com significados ou usos parecidos acabam por se aproximar nesse espaço formado pelos vetores.\n",
        "\n",
        "Imagine que temos um \"dicionário\" de palavras: \"hot\", \"cold\", \"very hot\" e \"warm\". Se optarmos por representar cada palavra usando dois números (ou seja, em duas dimensões), poderíamos ter algo assim:\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",
        "O que precisamos saber é que os números nestes vetores não são escolhidos ao acaso! Durante o treinamento de um modelo, o algoritmo ajusta esses números com base em como as palavras são usadas juntas no conjunto de dados. Portanto, ao final, palavras com usos ou significados semelhantes terão vetores mais próximos entre si.\n",
        "\n",
        "Essa técnica é super poderosa que consegue pegar o \"sentido\" das palavras e transformar em números de forma inteligente."
      ],
      "metadata": {
        "id": "eAkUNfb7nlVT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **5.5 Encoding na Prática**\n",
        "Imagine que temos uma tabela de dados, chamada **df5**. Esta tabela possui uma coluna denominada **state_holiday**, que indica o tipo de feriado em um determinado dia. Em alguns registros, o valor é **dias regulares**, indicando um dia sem feriado. Em outros, pode ser 'Páscoa', 'Natal' ou outros tipos de feriados.\n",
        "\n",
        "A técnica de codificação One-hot tem a função de criar novas colunas para cada categoria única na coluna original. Assim, para cada registro, atribuímos o valor '1' na coluna correspondente ao seu tipo de feriado e '0' nas outras colunas.\n",
        "\n",
        "Para facilitar este processo, podemos utilizar a biblioteca Pandas. Esta biblioteca oferece uma função chamada **get_dummies()**, que permite realizar essa transformação de maneira eficiente. Utilizando esta função, podemos rapidamente converter nossa coluna **state_holiday** em várias colunas binárias."
      ],
      "metadata": {
        "id": "RsxNhFvroBJ3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df6 = df5.copy()"
      ],
      "metadata": {
        "id": "Y8KJEty8EQkE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.5.1 state_holiday**"
      ],
      "metadata": {
        "id": "r_pRd2xMwx6L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df6.columns"
      ],
      "metadata": {
        "id": "HrJVe1dWoRxD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# state_holiday - One-Hot Encoding\n",
        "df6 = pd.get_dummies(df6, columns=['state_holiday'], prefix='state_holiday')"
      ],
      "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": [
        "---\n",
        "### **5.5.2 store_type**\n",
        "Usando o **LabelEncoder** do sklearn, podemos converter categorias em números. Por exemplo, a variável \"store_type\" tem categorias 'A', 'B' e 'C'. O **LabelEncoder** dá a cada categoria um número. Isso é útil para categorias com uma sequência clara, mas também funciona para outras."
      ],
      "metadata": {
        "id": "WosP-m3Sw1-T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "\n",
        "# Inicializando o LabelEncoder\n",
        "le = LabelEncoder()\n",
        "\n",
        "# Transformando a coluna 'store_type' em valores numéricos\n",
        "df6['store_type'] = le.fit_transform(df6['store_type'])"
      ],
      "metadata": {
        "id": "yKgSG9fawIiM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No código, o `fit_transform` aplica o **LabelEncoder** à coluna `store_type`, atualizando-a com os valores codificados. Se usarmos isso nos dados de treino, o mapeamento é aprendido corretamente. Contudo, se repetirmos no conjunto de teste, ele pode aprender um mapeamento diferente, tornando a representação numérica inconsistente entre treino e teste. Isso prejudica o desempenho do modelo."
      ],
      "metadata": {
        "id": "Xw8eLFq7xzP3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **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."
      ],
      "metadata": {
        "id": "f_YFA0T9zFrk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criando um dicionário para mapear os tipos de 'assortment' para valores numéricos\n",
        "assortment_dict = {'basic':1, 'extra':2, 'extended':3}\n",
        "\n",
        "# Aplicando o mapeamento à coluna 'assortment' do DataFrame df6\n",
        "df6['assortment'] = df6['assortment'].map(assortment_dict)\n",
        "\n",
        "# Exibindo uma amostra aleatória do DataFrame atualizado\n",
        "df6.sample()"
      ],
      "metadata": {
        "id": "b1JinanwxjXW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **5.6 Transformação dos Dados**\n",
        "A transformação de dados é essencial na ciência de dados para otimizar a performance dos modelos. Há duas principais transformações:\n",
        "\n",
        "- **Transformação de Grandeza:** Visa tornar a distribuição da variável mais próxima da normal. Isso beneficia algoritmos que pressupõem distribuição normal nos dados, elevando sua precisão.\n",
        "\n",
        "- **Transformação de Natureza:** Foca em manter características inerentes dos dados. Como no exemplo dos meses: Dezembro (12) e Janeiro (1) são sequenciais, e essa transformação preserva tal relação, apesar da diferença numérica."
      ],
      "metadata": {
        "id": "NXktUVfI6Vzc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **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",
        "- **Logarítmica:** Aplica-se o logaritmo em cada valor da variável. Útil para tornar distribuições enviesadas mais \"normais\".\n",
        "\n",
        "- **Box-Cox:** Ajusta a variável para se aproximar de uma distribuição normal. Esta transformação engloba outras, como a logarítmica e raiz quadrada.\n",
        "\n",
        "- **Raiz Cúbica:** Aplica-se a raiz cúbica em cada valor. Recomendada para dados com assimetria positiva.\n",
        "\n",
        "- **Raiz Quadrada:** Similar à raiz cúbica, mas utiliza a raiz quadrada.\n",
        "\n",
        "Essas técnicas melhoram o tratamento de dados com distribuições atípicas ou assimétricas.\n",
        "\n"
      ],
      "metadata": {
        "id": "9oMalNps67WU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **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": [
        "# Configura o tamanho da figura\n",
        "plt.figure(figsize=(24, 6))\n",
        "\n",
        "# Primeiro subplot: Distribuição original das vendas\n",
        "plt.subplot(1, 2, 1)\n",
        "sns.distplot(df6['sales'])\n",
        "plt.title('Distribuição Original das Vendas')  # Título do gráfico\n",
        "plt.xlabel('Vendas')  # Label do eixo x\n",
        "plt.ylabel('Densidade')  # Label do eixo y\n",
        "\n",
        "# Transforma a coluna de vendas com log1p\n",
        "df6['sales'] = np.log1p(df6['sales'])\n",
        "\n",
        "# Segundo subplot: Distribuição das vendas após transformação logarítmica\n",
        "plt.subplot(1, 2, 2)\n",
        "sns.distplot(df6['sales'])\n",
        "plt.title('Distribuição das Vendas após Transformação Logarítmica')\n",
        "plt.xlabel('Vendas (log)')\n",
        "plt.ylabel('Densidade')\n",
        "\n",
        "plt.tight_layout()  # Ajusta o layout para evitar sobreposições\n",
        "plt.show()  # Exibe o gráfico"
      ],
      "metadata": {
        "id": "6Vvlo698wOfX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No histograma à direita, observamos uma distribuição com formato mais próximo ao de uma curva em sino, típico de uma distribuição normal. Isso sugere que a aplicação da transformação logarítmica foi eficaz em aproximar os dados de uma distribuição normalizada.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "m8ZYBR5A97w6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Transformação Cíclica Temporal**\n",
        "A transformação cíclica visa representar a natureza recorrente de dados temporais. Por exemplo, em uma sequência mensal que vai de Janeiro a Dezembro, observamos uma repetição a cada ano.\n",
        "\n",
        "Pense nos meses como pontos em um círculo. A proximidade de Dezembro e Janeiro é semelhante à de Janeiro e Fevereiro, uma vez que após Dezembro, o ciclo recomeça em Janeiro. Uma representação linear (números de 1 a 12) não capta essa relação cíclica, pois coloca Dezembro e Janeiro em extremos opostos.\n",
        "\n",
        "A solução é a **codificação cíclica** usando o **círculo trigonométrico**. Aqui, cada mês recebe duas coordenadas: o seno e o cosseno do seu ângulo correspondente no círculo. Por exemplo, com o círculo dividido em 12 partes, Janeiro (1) terá seno 0 e cosseno 1, enquanto Fevereiro (2) terá valores diferentes, e assim por diante.\n",
        "\n",
        "Essa técnica representa cada mês com duas coordenadas, capturando a natureza cíclica e preservando a proximidade entre meses consecutivos, como Dezembro e Janeiro."
      ],
      "metadata": {
        "id": "jW2lo26o_Mvi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define uma constante para o cálculo cíclico baseado em um ano com 12 meses\n",
        "CYCLIC_FACTOR_MONTH = 2. * np.pi / 12\n",
        "\n",
        "# Utiliza o seno para transformar a coluna 'month' em uma coordenada cíclica\n",
        "df6['month_sin'] = df6['month'].apply(lambda x: np.sin(x * CYCLIC_FACTOR_MONTH))\n",
        "\n",
        "# Utiliza o cosseno para transformar a coluna 'month' em outra coordenada cíclica\n",
        "df6['month_cos'] = df6['month'].apply(lambda x: np.cos(x * CYCLIC_FACTOR_MONTH))"
      ],
      "metadata": {
        "id": "Y50c9F8O9WCo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos explicar essa etapa de maneira técnica e direta:\n",
        "\n",
        "1. **Seleção da coluna de meses**: Primeiramente, escolhemos a coluna 'month' no DataFrame df6. Essa coluna será sujeita à transformação.\n",
        "\n",
        "2. **Definição da função de transformação**: Em seguida, criamos uma função de transformação que será aplicada a cada valor na coluna de meses. A função utiliza a função seno para transformar cada valor. O valor é multiplicado por **2 * π / ciclo**, onde ciclo representa a duração do ciclo (neste caso, 12 meses).\n",
        "\n",
        "3. **Aplicação da função de transformação**: A função de transformação é aplicada a cada valor na coluna de meses usando o método apply, que executa uma função para cada elemento em uma série ou dataframe. O resultado é guardado em uma nova coluna denominada 'month_sin'.\n",
        "\n",
        "4. **Repetição com a função cosseno**: O processo é repetido, mas agora empregando a função cosseno. O resultado é armazenado em outra nova coluna chamada 'month_cos'.\n",
        "\n",
        "Agora, seguiremos o mesmo procedimento para as outras variáveis cíclicas e seus respectivos períodos."
      ],
      "metadata": {
        "id": "N5_NKY7oCBPB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define uma constante para o cálculo cíclico baseado em uma semana com 7 dias\n",
        "CYCLIC_FACTOR_WEEK = 2. * np.pi / 7\n",
        "\n",
        "# Utiliza o seno para transformar o 'day_of_week' em uma coordenada cíclica\n",
        "df6['day_of_week_sin'] = df6['day_of_week'].apply(lambda x: np.sin(x * CYCLIC_FACTOR_WEEK))\n",
        "\n",
        "# Utiliza o cosseno para transformar o 'day_of_week' em outra coordenada cíclica\n",
        "df6['day_of_week_cos'] = df6['day_of_week'].apply(lambda x: np.cos(x * CYCLIC_FACTOR_WEEK))"
      ],
      "metadata": {
        "id": "3PobnjnJCfRt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define uma constante para o cálculo cíclico baseado em um mês com aproximadamente 30 dias\n",
        "CYCLIC_FACTOR_DAY = 2. * np.pi / 30\n",
        "\n",
        "# Utiliza o seno para transformar a coluna 'day' em uma coordenada cíclica\n",
        "df6['day_sin'] = df6['day'].apply(lambda x: np.sin(x * CYCLIC_FACTOR_DAY))\n",
        "\n",
        "# Utiliza o cosseno para transformar a coluna 'day' em outra coordenada cíclica\n",
        "df6['day_cos'] = df6['day'].apply(lambda x: np.cos(x * CYCLIC_FACTOR_DAY))"
      ],
      "metadata": {
        "id": "8q2-cq0WCf7R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define uma constante para o cálculo cíclico baseado em 52 semanas no ano\n",
        "CYCLIC_FACTOR_YEAR_WEEK = 2. * np.pi / 52\n",
        "\n",
        "# Utiliza o seno para transformar a coluna 'week_of_year' em uma coordenada cíclica\n",
        "df6['week_of_year_sin'] = df6['week_of_year'].apply(lambda x: np.sin(x * CYCLIC_FACTOR_YEAR_WEEK))\n",
        "\n",
        "# Utiliza o cosseno para transformar a coluna 'week_of_year' em outra coordenada cíclica\n",
        "df6['week_of_year_cos'] = df6['week_of_year'].apply(lambda x: np.cos(x * CYCLIC_FACTOR_YEAR_WEEK))\n"
      ],
      "metadata": {
        "id": "nb2USC-eCfra"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- **Transformação Cíclica para Dias da Semana**: Vamos reconhecer que o ciclo de uma semana é composto por sete dias, pois uma semana contém exatamente sete dias. Dessa forma, ao aplicar as funções seno e cosseno, usaremos o número sete como o período do ciclo.\n",
        "\n",
        "- **Transformação Cíclica para Mês**: Em seguida, consideraremos que um mês, em média, tem a duração de 30 dias. Portanto, ao realizar a transformação cíclica para a variável mês, empregaremos o número 30 como o período do ciclo.\n",
        "\n",
        "- **Transformação Cíclica para Semana do Ano**: Por fim, um ano é composto por cerca de 52 semanas. Portanto, ao realizar a transformação cíclica para a variável semana do ano, usaremos o número 52 como o período do ciclo.\n",
        "\n",
        "No entanto, é importante observar que essa transformação cíclica não deve ser aplicada à variável ano, uma vez que esta é considerada linear e não cíclica, a menos que haja um mecanismo de retrocesso no tempo."
      ],
      "metadata": {
        "id": "X9Ru834aDLYW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Rossmann Project Status**\n",
        "Neste relato sobre o projeto de projeção de vendas que seguimos com a metodologia **CRISP-DM**, apresentamos os principais passos:\n",
        "\n",
        "1. **Definição do Problema de Negócio**: A prioridade foi compreender a necessidade dos gerentes de lojas, que buscavam uma previsão de vendas para os próximos seis meses. Essa definição é essencial para determinar os objetivos e parâmetros do projeto.\n",
        "\n",
        "2. **Entendimento do Negócio**: Investigamos a motivação por trás do pedido e identificamos que a meta era definir um orçamento para reformas nas lojas. O montante a ser destinado depende diretamente do faturamento previsto, tornando a projeção de vendas um pilar no planejamento das reformas.\n",
        "\n",
        "3. **Coleta de Dados**: Com a clareza do desafio, coletamos dados a partir da plataforma `Kaggle`. Contudo, a obtenção de dados pode se originar de múltiplas fontes, como bancos de dados ou `API's`.\n",
        "\n",
        "4. **Limpeza de Dados**: Após a coleta, fizemos uma revisão detalhada nos dados. Isso envolveu um panorama geral, a criação de novas `features` a partir de dados brutos e uma filtragem de variáveis considerando regras de negócio.\n",
        "\n",
        "5. **Exploração de Dados**: Com os dados prontos, focamos em analisar correlações e formular hipóteses, visando entender como as informações coletadas poderiam auxiliar na previsão de vendas.\n",
        "\n",
        "6. **Modelagem de Dados**: Preparamos os dados para um modelo de aprendizado de máquina, escolhendo as `variáveis` mais impactantes para a previsão de vendas.\n",
        "\n",
        "Esta é uma síntese dos procedimentos adotados no Projeto 999, priorizando os pontos mais significativos."
      ],
      "metadata": {
        "id": "UGOJmH0iG2LG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **6. Feature Selection**\n",
        "\n",
        "### **6.1 Por que Selecionar Atributos?**\n",
        "A seleção de atributos é uma fase primordial na ciência de dados. Esta prática remonta ao **princípio da Navalha de Occam**, que defende que a versão mais simples de um fenômeno é geralmente a mais adequada.\n",
        "\n",
        "Para exemplificar: se descrevermos um carro, podemos citar elementos como quatro rodas, dois faróis e uma placa. Esse conjunto de características nos dá uma representação básica do carro.\n",
        "\n",
        "Há quem possa adicionar atributos como Bluetooth, wi-fi, câmbio automático e outros. Embora mais detalhado, esse modelo não abrange todos os carros, tornando-o menos universal.\n",
        "\n",
        "Pela Navalha de Occam, **o modelo mais simples é frequentemente o mais eficaz**, visto que generaliza melhor o fenômeno estudado. Essa filosofia orienta a seleção de variáveis em ciência de dados.\n",
        "\n",
        "No contexto de aprendizado de máquina, **a meta é aprimorar a aprendizagem adotando modelos mais enxutos**. A simplicidade do dataset se reflete na quantidade de `variáveis` ou `features` presentes. Algumas dessas podem ser repetitivas ou 'colineares', ou seja, retratam o mesmo aspecto do fenômeno.\n",
        "\n",
        "**Eliminar variáveis colineares torna o modelo mais ágil**. Usando nosso exemplo do carro, \"quatro rodas\" e \"quatro pneus\" retratam o mesmo. Assim como \"lanternas\" e \"faróis\" são equivalentes em essência.\n",
        "\n",
        "Desse modo, selecionar atributos se concentra em detectar e descartar variáveis colineares, gerando um modelo mais conciso e, assim, facilitando a sua assimilação por algoritmos. Técnicas variadas de seleção de variáveis serão exploradas em fases subsequentes deste projeto."
      ],
      "metadata": {
        "id": "DDOFKO2BFQV9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **6.1.2 Feature Selection Methods**\n",
        "\n",
        "### **Why Select Features?**\n",
        "O ato de escolher os atributos certos é central em modelagem de dados. A seleção correta pode acentuar a precisão e eficiência de um modelo. Aqui estão três principais métodos de seleção:\n",
        "\n",
        "- **Univariate Selection (Filter Methods):** Avalia a relação entre cada `variável` individual e a `variável alvo`. Aqueles com **forte correlação são mantidos**, enquanto os de baixa correlação são descartados.\n",
        "\n",
        "- **Feature Importance (Embedded Methods):** Classifica `variáveis` pela sua importância estatística no dataset. Essencialmente, quanto mais uma `variável` influencia o resultado, mais importante ela é.\n",
        "\n",
        "- **Subset Selection (Wrapper Methods):** Examina **combinações de variáveis para determinar conjuntos que otimizam o desempenho**. Útil quando as `variáveis` estão inter-relacionadas.\n",
        "\n",
        "### **Understanding Correlation**\n",
        "A **correlação quantifica o relacionamento** entre duas variáveis. Com valores entre -1 e 1, indica a força e direção da relação. Proximidade de 1 sugere correlação positiva; -1 implica correlação negativa e valores próximos de zero denotam fraca relação.\n",
        "\n",
        "Se tratando de variáveis numéricas, usamos o **coeficiente de correlação**. Já para categóricas, empregamos outros métodos:\n",
        "\n",
        "- **Variáveis contínuas:** correlação de Pearson.\n",
        "- **Variáveis categóricas:** Cramér's V ou Chi-Square.\n",
        "- **Preditora categórica e alvo contínuo:** Análise de Variância (ANOVA).\n",
        "- **Preditora contínua e alvo categórica:** Linear Discriminant Analysis (LDA).\n",
        "\n",
        "### **Univariate Selection Method**\n",
        "Neste método, cada `variável` é avaliada individualmente em relação à `variável resposta`. Ele é direto e rápido. No entanto, sua desvantagem é não considerar interações entre `variáveis`. Por isso, há risco de descartar `variáveis` que poderiam ser relevantes quando combinadas com outras.\n",
        "\n",
        "Ao escolher métodos de seleção, é essencial ponderar sobre as características do dataset e objetivos do projeto. O equilíbrio entre simplicidade e precisão é chave para um modelo robusto.\n",
        "\n",
        "---\n",
        "### **6.1.3 Variable Selection by Importance Method**  \n",
        "(*Seleção de Variáveis pelo Método de Importância*)\n",
        "\n",
        "A **seleção de variáveis** é fundamental na ciência de dados. O método de importância, também conhecido como *método embutido*, é diferenciado pois não foca apenas na correlação entre variáveis. Por exemplo, o algoritmo `Random Forest` seleciona variáveis durante seu aprendizado, tornando esta seleção parte integral do processo. Da mesma forma, algoritmos de regressão regularizados, como `Lasso` e `Ridge`, atribuem pesos às variáveis, indicando sua relevância.\n",
        "\n",
        "Quando falamos em seleção de variáveis pelo método de importância, estamos nos referindo a um processo em que identificamos quais variáveis são mais relevantes para um modelo. Esta abordagem difere da seleção univariada, que analisa a correlação entre as variáveis de forma isolada.\n",
        "\n",
        "Imagine que você está construindo um modelo como o Random Forest. Durante a construção, o modelo já está, por natureza, selecionando as variáveis mais importantes para chegar a um resultado. Assim, ao final, conseguimos saber quais variáveis o modelo considerou mais relevantes. Portanto, esta técnica é como se o modelo \"nos contasse\" quais são as variáveis mais importantes para ele.\n",
        "\n",
        "---\n",
        "### **6.1.4 Variable Selection with Gini Impurity**  \n",
        "(*Seleção de Variáveis com Impureza de Gini*)\n",
        "\n",
        "O algoritmo `Random Forest` utiliza a impureza de Gini, uma métrica de homogeneidade, para avaliar a importância das variáveis. Variáveis que resultam em subconjuntos homogêneos de dados são consideradas importantes.\n",
        "\n",
        "O `Random Forest` tem uma maneira particular de escolher variáveis, baseada na impureza de Gini. Este critério avalia quão homogêneo é um conjunto de dados quando dividido por uma variável.\n",
        "\n",
        "Vamos a um exemplo: imagine que estamos analisando vendas e dividimos os dados com base no `preço`. Se, após a divisão, os grupos de vendas de preços altos e baixos forem muito similares internamente, o `preço` é uma variável importante. A chave aqui é que o Random Forest busca variáveis que resultem em subconjuntos o mais homogêneo possível.\n",
        "\n",
        "---\n",
        "### **6.1.5 Variable Selection with Lasso Regression**  \n",
        "(*Seleção de Variáveis com Regressão Lasso*)\n",
        "\n",
        "A `Regressão Lasso` penaliza coeficientes do modelo, fazendo com que alguns sejam zero. Isso simplifica o modelo, destacando variáveis com coeficientes significativamente distintos de zero como mais relevantes.\n",
        "\n",
        "A `Regressão` Lasso é como um \"filtro\" para variáveis. Ao criar um modelo, este método aplica uma penalidade aos coeficientes das variáveis. Se a penalidade for forte o suficiente, alguns coeficientes podem se tornar zero, indicando que essas variáveis não são importantes.\n",
        "\n",
        "Na prática, ao aplicar a `regressão Lasso`, acabamos por obter uma lista de variáveis com seus respectivos pesos. As variáveis com pesos mais distantes de zero são as mais relevantes.\n",
        "\n",
        "---\n",
        "### **6.1.6 Subset Selection (Wrapper Method)**  \n",
        "(*Seleção de Variáveis por Subconjunto - Método de Embalagem*)\n",
        "\n",
        "Diferente de métodos que dependem de correlação ou importância atribuída pelo modelo, a **seleção por subconjuntos** avalia combinações de variáveis em relação ao desempenho do modelo. O processo envolve adicionar variáveis, avaliar desempenho e remover as não-informativas, até se obter o subconjunto ideal.\n",
        "\n",
        "Imagine ter que testar todas as combinações possíveis de variáveis para encontrar o melhor conjunto para seu modelo. Isso é o que faz a seleção por subconjuntos. Ela avalia cada combinação, treina o modelo e verifica o desempenho.\n",
        "\n",
        "O diferencial deste método é que ele não se baseia apenas na correlação entre as variáveis ou na importância dada por um modelo. Ele se concentra diretamente no desempenho.\n",
        "\n",
        "---\n",
        "### **6.2 Variable Selection with Boruta Algorithm**  \n",
        "(*Seleção de Variáveis com Algoritmo Boruta*)\n",
        "\n",
        "O `Boruta` destaca-se pelo uso de `variáveis shadow`, cópias de variáveis originais com dados embaralhados. A ideia é comparar a importância das variáveis originais com as shadow, identificando as mais relevantes por meio de análise estatística.\n",
        "\n",
        "O `Boruta` é como um detetive em busca de variáveis importantes. Ele utiliza o Random Forest e cria cópias (ou sombras) das variáveis originais, mas com os dados embaralhados. Em seguida, compara a importância das variáveis originais com essas cópias embaralhadas.\n",
        "\n",
        "Se uma variável original for consistentemente mais importante do que suas cópias embaralhadas, ela é considerada relevante. Assim, o `Boruta` nos fornece uma lista das variáveis mais significativas, baseando-se na comparação com suas sombras.\n",
        "\n",
        "---\n",
        "### **6.2.1 Dividindo o DataFrame em Conjuntos de Treinamento e Teste**\n",
        "\n",
        "Antes de implementar o `Boruta`, é crucial dividir o DataFrame. Algumas variáveis originárias, que geraram novas características, devem ser removidas para evitar redundâncias. Para isso, uma lista, `cols_drop`, é criada, e as variáveis correspondentes são excluídas do DataFrame utilizando o método 'drop' do `pandas`."
      ],
      "metadata": {
        "id": "4yANRh6bfpJF"
      }
    },
    {
      "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": [
        "Ao usar o método `drop` com o argumento `axis=1`, estamos especificando a exclusão de **colunas** inteiras. Isto significa que a coluna completa, com todos os seus registros, será removida.\n",
        "\n",
        "O principal foco na preparação do DataFrame é eliminar **variáveis originais** que geraram novas características. Isso garante a **otimização e integridade** dos dados ao aplicar o algoritmo **Boruta**.\n",
        "\n",
        "### **Divisão do Conjunto de Dados**\n",
        "Esta etapa é fundamental. Aqui, partimos o nosso conjunto de dados em **conjuntos de treinamento e teste**. O propósito? Treinar o modelo com uma porção dos dados e, depois, usar o conjunto de teste para avaliar sua precisão.\n",
        "\n",
        "Por lidarmos com um problema de séries temporais, temos que ter especial atenção à **ordem temporal**. Não é adequado selecionar linhas aleatoriamente para treinamento e teste. Misturar dados do futuro com os do passado pode causar **overfitting** - quando o modelo \"decora\" os dados em vez de efetivamente aprender.\n",
        "\n",
        "Dado nosso contexto de prever seis semanas de vendas diárias por `store`, o ideal é que as **últimas seis semanas** de vendas sejam o conjunto de teste e o restante compreenda o treinamento.\n",
        "\n",
        "Uma prática útil? **Agrupar os dados** por `store` e identificar as datas de vendas mais antigas e mais recentes. Isso clarifica o período de tempo com que estamos trabalhando."
      ],
      "metadata": {
        "id": "iP7RNjgV4fh4"
      }
    },
    {
      "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": [
        "### **Data Splitting Strategy**\n",
        "\n",
        "Para segmentar os dados em **treinamento e teste**, identificamos a **data limite** para o treinamento. Isso é feito subtraindo seis semanas da data máxima de venda com o método `timedelta` da classe `datetime`.\n",
        "\n",
        "Tomando como exemplo a data máxima 31/07/2015: ao retirarmos 42 dias (seis semanas), chegamos à data de 19/06/2015. Assim, os dados desde o início até 18/06/2015 são designados para **treinamento** e, de 19/06/2015 até a data máxima, 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": [
        "### **Data Validation**\n",
        "\n",
        "Após segmentar os dados, é vital **validar** a divisão. Imprimimos as datas mínimas e máximas dos conjuntos `treinamento` e `teste`. A data máxima do `treinamento` deve ser exatamente um dia anterior à data mínima do `teste`. Além disso, a última data de venda corresponde à data máxima do conjunto `teste`. Essas verificações asseguram uma **sequência contínua de datas**, respeitando 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": [
        "---\n",
        "\n",
        "### **6.3 Boruta as a Feature Selector**\n",
        "\n",
        "Após a divisão dos dados para treinamento e teste, o foco agora é otimizar nosso modelo selecionando as características mais pertinentes usando o **Boruta**.\n",
        "\n",
        "A classe `BorutaPy` no Python é projetada para essa função. Aqui estão seus aspectos centrais:\n",
        "\n",
        "1. **Model Choice**: Um de seus argumentos primordiais é o modelo a ser usado. Aqui, optamos pelo `RandomForestRegressor`.\n",
        "   \n",
        "2. **Number of Estimators**: Para obter a melhor performance, permitimos que o Boruta escolha o número ideal de árvores ao definir isso como `'auto'`.\n",
        "\n",
        "3. **Verbosity Log**: Estabelecemos esse log em 2. Isso nos oferece a oportunidade de monitorar o progresso do algoritmo, que pode ser um processo demorado.\n",
        "\n",
        "4. **Random State**: A consistência é crucial. Por isso, configuramos o estado aleatório ('random state') para **42**. Isso assegura que o processo de seleção seja reproduzível em diferentes execuções.\n",
        "\n",
        "Antes de usar o método `'fit'`, é essencial formatar os dados corretamente. O Boruta **não trabalha com dataframes**; ele exige um vetor numérico.\n",
        "\n",
        "Segue uma breve visão do processo:\n",
        "\n",
        "- Começamos com as importações necessárias.\n",
        "- Instanciamos `RandomForestRegressor` e `BorutaPy`.\n",
        "- Preparamos os dados: retirando colunas `'date'` e `'sales'` de `X_train` e transformando o restante em um vetor numérico. O vetor alvo, `y_train`, passa por um processo similar.\n",
        "- Com os dados prontos, prosseguimos com o treinamento do Boruta."
      ],
      "metadata": {
        "id": "Or1QX_J_8l8D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando as bibliotecas necessárias\n",
        "from boruta           import BorutaPy\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "\n",
        "# Inicialização do RandomForestRegressor com paralelização\n",
        "rf = RandomForestRegressor(n_jobs=-1)\n",
        "\n",
        "# Configuração do Boruta com parâmetros essenciais\n",
        "boruta = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=42)\n",
        "\n",
        "# Preparação dos dados para o Boruta, removendo colunas não necessárias\n",
        "X_train_n = X_train.drop(['date', 'sales'], axis=1).values\n",
        "y_train_n = y_train.values.ravel()\n",
        "\n",
        "# Treinamento com Boruta\n",
        "boruta.fit(X_train_n, y_train_n)\n"
      ],
      "metadata": {
        "id": "iZW30SIa99Oq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Understanding Boruta's Results**\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",
        "- `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",
        "# Identifica as colunas aprovadas pelo Boruta\n",
        "cols_selected = boruta.support_.tolist()\n",
        "\n",
        "# Remove as colunas 'date' e 'sales' e armazena em X_train_fs\n",
        "X_train_fs = X_train.drop(['date', 'sales'], axis=1)\n",
        "\n",
        "# Determina o nome das colunas aprovadas pelo Boruta\n",
        "cols_selected_boruta = X_train_fs.columns[cols_selected].to_list()\n",
        "\n",
        "# Identifica as colunas que não foram aprovadas 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": [
        "### **Variable Selection with Boruta** (Seleção de Variáveis com Boruta)\n",
        "\n",
        "O algoritmo Boruta avalia e ordena variáveis com base em sua **relevância**. Utilizamos o atributo `support_` do Boruta para determinar quais variáveis foram consideradas importantes, pois ele retorna um vetor booleano com essa finalidade.\n",
        "\n",
        "Para uma análise mais direta, criamos a lista `cols_selected`. Esta lista armazena os índices das colunas validadas pelo Boruta, e, para uma visualização prática, convertemos tais índices nos respectivos nomes de colunas. Uma observação é que, inicialmente, nosso conjunto de dados contém as colunas `date` e `sales`, que devem ser excluídas. Por isso, geramos um subconjunto nomeado `X_train_fs`, derivado do `X_train` original, porém sem estas duas colunas.\n",
        "\n",
        "Com isso, estabelecemos um novo conjunto denominado `cols_selected_boruta` contendo apenas as variáveis autenticadas pelo Boruta de `X_train_fs`. Paralelamente, é instrutivo identificar as colunas que não obtiveram aprovação do Boruta. Para alcançar esse objetivo, comparamos `X_train_fs` com `cols_selected_boruta` usando a função `np.setdiff1d` do numpy. A diferença entre eles é então alocada na variável `cols_not_selected_boruta`.\n",
        "\n",
        "Em resumo, através do Boruta, determinamos **quais variáveis** são vistas como cruciais pelo algoritmo."
      ],
      "metadata": {
        "id": "GG-C5JTpD0fn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cols_selected_boruta"
      ],
      "metadata": {
        "id": "UomzFTLsAo98"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Columns Discarded by Boruta**  \n",
        "O algoritmo Boruta avalia a relevância de cada variável e pode descartar aquelas que não contribuem significativamente para a modelagem. Neste contexto, **algumas variáveis foram classificadas como irrelevantes** para o modelo e, consequentemente, descartadas. Ao tomar ciência das colunas descartadas, podemos direcionar nossa atenção para as variáveis que de fato possuem maior potencial preditivo."
      ],
      "metadata": {
        "id": "DsRyq_fWHSk9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cols_not_selected_boruta"
      ],
      "metadata": {
        "id": "GSgfX7qlHW2C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Concluding Feature Selection with Boruta**  \n",
        "Após a etapa de seleção de características com o algoritmo Boruta, é essencial refletir sobre os insights obtidos. Neste ponto, é benéfico revisitar nossa **análise exploratória de dados** anterior, onde abordamos várias hipóteses e construímos uma estrutura para diferenciar quais foram validadas, quais foram descartadas e a importância de cada uma no modelo.\n",
        "\n",
        "O objetivo agora é alinhar essas observações com o que Boruta identificou como relevante. Esse alinhamento nos ajuda a consolidar os resultados e a corroborá-los com nossas investigações iniciais.\n",
        "\n",
        "Por exemplo, ao revisar hipóteses de alta relevância, podemos observar que cada uma delas está atrelada a um determinado atributo. A hipótese 9, que sugere que as vendas nas lojas aumentariam ao longo dos anos. Curiosamente, Boruta não viu `Year` como um elemento chave. Este é um momento para ponderar e decidir se deve ou não aceitar a indicação do algoritmo. Uma abordagem comum é, inicialmente, seguir as recomendações de Boruta e, em fases futuras, reintroduzir características que possam otimizar o modelo.\n",
        "\n",
        "Da mesma forma, a hipótese 10 relacionada ao `Month` levanta que as vendas seriam mais expressivas no segundo semestre. Enquanto Boruta avaliou `month_cos` como importante e `month_sin` como secundário, cabe a nós determinar se ambos os atributos devem ser considerados na análise.\n",
        "\n",
        "A hipótese 11, relacionada ao `Day`, sugere vendas mais robustas após o décimo dia de cada mês. Aqui, Boruta validou tanto `day_sin` quanto `day_cos`, reforçando nossa suposição inicial.\n",
        "\n",
        "Finalizando, a integração e a revisão entre as diretrizes de Boruta e as hipóteses da nossa análise exploratória são cruciais para garantir uma modelagem robusta e fundamentada."
      ],
      "metadata": {
        "id": "Dsl-AVVkJFCn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **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 é extenso, e os algoritmos de aprendizado de máquina (ou *Machine Learning*) desempenham um papel crucial. Estes algoritmos permitem que máquinas \"aprendam\" a partir de dados existentes, muito semelhante ao modo como humanos estabelecem associações. Tomemos um exemplo simples: quando reconhecemos um computador, associamos suas características — como a forma, a presença de um teclado e determinadas cores. Da mesma forma, os algoritmos são treinados para reconhecer padrões e usar essas aprendizagens em situações futuras.\n",
        "\n",
        "A complexidade do aprendizado de máquina não invalida métodos simples, como o cálculo da média, que ainda é fundamental em diversos contextos de negócios. A média fornece uma visão geral da distribuição dos dados.\n",
        "\n",
        "Dentro do aprendizado de máquina, temos várias tarefas específicas. A **classificação** é uma das mais comuns. Em termos simples, ela envolve o ensino do algoritmo para identificar, por exemplo, se uma imagem é de um carro, uma van ou um ônibus, baseando-se em características específicas. Para que o algoritmo funcione bem, é crucial fornecer uma ampla variedade de exemplos durante o treinamento.\n",
        "\n",
        "Mas, não nos limitamos apenas à classificação. Há outros problemas como a **regressão**, voltada para previsões numéricas contínuas, e a análise de **séries temporais**, focada em prever comportamentos futuros baseados em dados históricos.\n",
        "\n",
        "Por outro lado, temos o **aprendizado não supervisionado**, onde o algoritmo trabalha sem rótulos pré-definidos nos dados. Usando nosso exemplo das frutas, seria como agrupar as frutas por semelhanças que o próprio algoritmo identifica, sem nos dizer explicitamente quais são essas semelhanças. É um processo de \"descoberta\" de padrões e relações.\n",
        "\n",
        "E, para trazer ainda mais complexidade, existe o **aprendizado semi-supervisionado**, uma combinação dos dois métodos anteriores. Aqui, o modelo não só aprende com os dados rotulados fornecidos mas também melhora e adapta seu aprendizado à medida que novos dados são introduzidos. Um exemplo prático é a seleção de capas na plataforma Netflix: inicialmente, diversas capas são testadas aleatoriamente com os usuários e, a partir do feedback coletado, as mais eficientes são destacadas.\n",
        "\n",
        "Resumindo, o aprendizado de máquina é uma ferramenta poderosa que pode ser adaptada a uma variedade de problemas e contextos. Seja através de métodos supervisionados, não supervisionados ou semi-supervisionados, sua capacidade de aprender e adaptar-se oferece um valor inestimável à ciência de dados."
      ],
      "metadata": {
        "id": "f24zeXE2j06t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "# **7. Machine Learning Algorithms**\n",
        "**Average Model** (`Modelo de Média`): No contexto do aprendizado de máquina, muitas vezes subestimamos a simplicidade, mas ela pode ser extremamente poderosa. Tomemos, por exemplo, o `modelo de média`. Ele prevê, como o nome sugere, a média dos dados de entrada. Imagine que você deseje prever vendas futuras em sua loja. Este modelo projetaria a média das vendas passadas como sua previsão. Pode parecer básico, mas seu verdadeiro valor reside em sua capacidade de atuar como um padrão para outros modelos. Se outro modelo supera o desempenho do modelo de média, indica aprendizado genuíno. Caso contrário, a simples média se mostra eficiente.\n",
        "\n",
        "**Linear Regression and Regularized Linear Regression** (`Regressão Linear e Regressão Linear Regularizada`): Avançando, temos os modelos de `regressão linear` e sua contraparte regularizada. Ambos adotam uma abordagem mais sofisticada do que o modelo de média, tentando traçar uma relação direta entre os dados de entrada e saída. Frequentemente, a versão regularizada apresenta desempenho superior devido à sua capacidade de penalizar recursos menos significativos, promovendo generalização. Opto por esses modelos no início devido ao princípio de **Occam's Razor**, que defende modelos mais simples sempre que são adequados.\n",
        "\n",
        "**Random Forest and Gradient Boosting** (`Random Forest e Gradient Boosting`): Em seguida, temos duas abordagens baseadas em árvores: `Random Forest` e `Gradient Boosting`. Ambos ganharam popularidade devido ao seu robusto desempenho, especialmente em competições como as do Kaggle. Sendo adaptáveis e frequentemente superiores em termos de desempenho, são uma escolha essencial em nossa caixa de ferramentas.\n",
        "\n",
        "Agora, você pode estar curioso sobre abordagens mais modernas, como `redes neurais`, `Deep Learning`, `CNN` e `LSTM`. Embora extremamente poderosos, esses modelos são mais complexos e demorados para implementar. Estamos em um ciclo de desenvolvimento ágil, priorizando resultados rápidos e eficientes. Em um cenário real, já estaríamos várias semanas neste projeto, e a pressão por resultados tangíveis estaria aumentando.\n",
        "\n",
        "Certamente, à medida que o projeto evolui, esses modelos avançados serão considerados e possivelmente incorporados para otimizar ainda mais nossas previsões."
      ],
      "metadata": {
        "id": "lQEu-muHkt_3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "# Selecting Relevant Variables\n",
        "\n",
        "No processo de construção de um modelo de aprendizado de máquina, **selecionar as variáveis corretas** é uma etapa crucial. Usando o **Boruta** como nossa ferramenta de seleção, identificamos um conjunto de variáveis relevantes que têm potencial para melhorar a precisão do nosso modelo.\n",
        "\n",
        "Iniciaremos nossa implementação focando no conjunto de treinamento. Se você se lembra, tínhamos `X_train` e `X_test` já separados. A estratégia agora é extrair as colunas que o Boruta destacou como mais importantes, identificadas como `cols_selected_boruta`. Esta seleção será armazenada em uma variável chamada `x_train`, onde o \"x\" é intencionalmente em minúsculo, diferenciando-a de `X_train`.\n",
        "\n",
        "Da mesma forma, para o conjunto de teste, vamos filtrar `X_test` usando as colunas selecionadas pelo Boruta. O resultado será armazenado em `x_test`.\n",
        "\n",
        "Um ponto a notar: inicialmente, decidimos excluir as colunas \"date\" e \"sales\" no estágio de treinamento. Contudo, há um plano de reintroduzir essas variáveis mais tarde, garantindo uma análise mais ampla e, potencialmente, melhores insights.\n",
        "\n",
        "Nossa base de dados agora é um reflexo da combinação da capacidade de seleção do Boruta com nossa experiência e intuição. Com essa etapa concluída, estamos prontos para prosseguir.\n",
        "\n",
        "Vamos melhorar o código com instruções mais detalhadas:"
      ],
      "metadata": {
        "id": "irTwRtRixtee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Seleciona as colunas identificadas como relevantes pelo Boruta para treinamento\n",
        "x_train = X_train[cols_selected_boruta]\n",
        "x_test = X_test[cols_selected_boruta]\n",
        "\n",
        "# Em um contexto adicional, para fins de validação ou outro treinamento,\n",
        "# pode-se usar uma versão mais completa das colunas selecionadas 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",
        "\n",
        "O **Modelo de Média** é uma técnica fundamental ao tratar de previsões, pois serve como ponto de partida para avaliar o desempenho de modelos mais complexos.\n",
        "\n",
        "Para desenvolver nosso Modelo de Média, nosso foco é prever a média de vendas de diversas lojas. Inicialmente, criamos uma cópia do conjunto de teste `X_test`, armazenando-a em `aux1`. Nesse conjunto, introduzimos uma coluna denominada `sales` que reflete as vendas reais, ou seja, nossa `variável-target`.\n",
        "\n",
        "O passo subsequente consiste em calcular a média de vendas de cada estabelecimento. Para essa tarefa, agrupamos os dados por `store` e aplicamos uma média à coluna `sales`. Tal operação gera um resultado, armazenado em `aux2`.\n",
        "\n",
        "A integração das médias calculadas ao dataset original `aux1` é realizada por meio da função de mesclagem do pandas, utilizando 'store' como a chave primária. Este procedimento é vital, pois permite que comparemos, de forma direta, a média de vendas projetada às vendas reais de cada loja.\n",
        "\n",
        "Com as vendas reais e suas respectivas médias em mãos, estamos aptos a avaliar a performance do modelo. Para isso, empregamos uma função denominada `ml_error`. Essa função, ao receber o nome do modelo, as vendas reais e as previsões (médias de vendas calculadas), fornece três métricas de erro:\n",
        "- **Erro Absoluto Médio (MAE)**: Representa a média das diferenças absolutas entre as projeções e os valores reais.\n",
        "- **Erro Percentual Absoluto Médio (MAPE)**: Traduz a média das diferenças percentuais absolutas entre as previsões e os valores efetivos.\n",
        "- **Raiz do Erro Quadrático Médio (RMSE)**: Corresponde à raiz quadrada da média dos erros ao quadrado.\n",
        "\n",
        "Uma etapa adicional e fundamental é reverter a transformação logarítmica previamente aplicada à variável de resposta. A função exponencial é empregada nesse processo.\n",
        "\n",
        "Ao final, `ml_error` gera um DataFrame do pandas, que consolida o nome do modelo e as métricas de erro obtidas.\n"
      ],
      "metadata": {
        "id": "c0rcgi0syFOX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando as bibliotecas necessárias\n",
        "from sklearn.metrics import mean_absolute_error, mean_squared_error\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# Definindo a função de erro médio absoluto percentual (MAPE)\n",
        "def mean_absolute_percentage_error(y, yhat):\n",
        "    \"\"\"Calcula o erro médio absoluto percentual entre valores reais e preditos.\"\"\"\n",
        "    return np.mean(np.abs((y - yhat) / y))\n",
        "\n",
        "def ml_error(model_name, y, yhat):\n",
        "    \"\"\"Calcula e retorna métricas de erro para avaliação do modelo.\"\"\"\n",
        "    mae = mean_absolute_error(y, yhat)\n",
        "    mape = mean_absolute_percentage_error(y, yhat)\n",
        "    rmse = np.sqrt(mean_squared_error(y, yhat))\n",
        "\n",
        "    return pd.DataFrame({\n",
        "        'Model Name': model_name,\n",
        "        'MAE': mae,\n",
        "        'MAPE': mape,\n",
        "        'RMSE': rmse\n",
        "    }, index=[0])\n",
        "\n",
        "# Preparação dos dados para a avaliação\n",
        "\n",
        "# Criando uma cópia dos dados de teste\n",
        "aux1 = x_test.copy()\n",
        "# Inserindo vendas reais ao conjunto auxiliar\n",
        "aux1['sales'] = y_test.copy()\n",
        "\n",
        "# Calculando a média de vendas por loja e armazenando em aux2\n",
        "aux2 = aux1[['store', 'sales']].groupby('store').mean().reset_index().rename(columns={'sales': 'predictions'})\n",
        "\n",
        "# Integrando as previsões de vendas (médias) ao conjunto auxiliar\n",
        "aux1 = pd.merge(aux1, aux2, how='left', on='store')\n",
        "yhat_baseline = aux1['predictions']\n",
        "\n",
        "# Avaliando a performance do modelo\n",
        "# Revertendo a transformação logarítmica para obter 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": [
        "### **Análise dos Resultados**\n",
        "\n",
        "Após avaliação do modelo, identificamos algumas métricas-chave para sua performance. A métrica `MAE` indicou um erro médio absoluto de **R$ 1.354** em nossas previsões. Adicionalmente, o **Erro Médio Absoluto Percentual `MAPE` foi de **45%**, sugerindo que, em média, as previsões desviam-se em 45% dos valores reais. Por último, o `RMSE`, que nos dá uma noção da magnitude dos erros, ficou em **1.835**. Esta métrica é particularmente útil para entender a dispersão dos erros em nossas previsões."
      ],
      "metadata": {
        "id": "xooXDINa0w79"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### 7.2 Linear Regression Model\n",
        "No escopo de nosso projeto, visamos experimentar variados modelos de aprendizado de máquina para discernir qual melhor se harmoniza com nossa base de dados. Dentre eles, introduzimos o Modelo de Regressão Linear. Este algoritmo, de natureza supervisionada, tem como intuito projetar uma saída com base em variáveis independentes. Ele se destaca em situações que demandam previsões quantitativas, como antecipação de vendas ou estimação de tendências de progresso.\n",
        "\n",
        "A implementação desse modelo se desdobra em três fases críticas:\n",
        "\n",
        "**1. Treinamento**: Aqui, empregamos o método `fit` para instruir o modelo com nossos dados de treinamento (`x_train`, `y_train`). O trecho de código associado a este passo é:"
      ],
      "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 esta etapa, o modelo treinado é armazenado na variável `lr`.\n",
        "\n",
        "**2. Predição**: Com o modelo devidamente treinado, avançamos para as previsões utilizando os dados de teste (`X_test`), através do método predict. As projeções são posteriormente alocadas na variável `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": [
        "**3. Avaliação de Desempenho**: Em seguida, analisamos a eficiência do nosso modelo utilizando a função `ml_error`, a qual contrasta os valores reais `y_test` e as predições `yhat_lr`. Caso os dados tenham sido submetidos a uma transformação, é vital restaurá-los à sua magnitude original, empregando a função np.expml:"
      ],
      "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": [
        "Os resultados apresentados mostraram que a métrica `MAE` foi de 1867, o Erro Médio Absoluto Percentual `MAPE` alcançou 29%, e o `RMSE` se estabeleceu em 2671.\n",
        "\n",
        "### **Comparativo entre Modelos**\n",
        "\n",
        "Quando colocamos lado a lado o `Average Model` e o `Linear Regression Model`, percebemos que o `RMSE` do primeiro foi de 1835, enquanto o segundo obteve `2671`. Esta discrepância revela que o Modelo de Regressão Linear errou mais em suas projeções.\n",
        "\n",
        "**Essas observações levam-nos a duas deduções vitais:**\n",
        "\n",
        "- **1. Eficiência do Modelo de Média**: Seu `RMSE` inferior evidencia uma performance mais acurada na predição dos dados comparativamente ao Modelo de Regressão Linear.\n",
        "- **2. Intrincado Comportamento dos Dados**: O Modelo de Regressão Linear, em sua essência, busca padrões lineares. Se nossos dados exibem um padrão distinto, isso pode justificar a menor precisão deste modelo. Portanto, os dados parecem ser mais multifacetados do que simples relações lineares poderiam captar.\n",
        "\n",
        "Concluindo, é imprescindível que exploremos modelos não lineares em futuras análises, dado que estes podem ser mais aptos a entender e reproduzir a complexidade intrínseca de nossa base de dados."
      ],
      "metadata": {
        "id": "OvYE0JfQ2G0-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **7.3 Linear Regression Regularized Modelo - Lasso**\n",
        "A busca por desempenhos superiores em modelos de regressão frequentemente nos leva a adotar técnicas avançadas, sendo a **regularização** um dos métodos primordiais nesse contexto. Esta técnica visa **prevenir o overfitting**, um fenômeno que ocorre quando o modelo se adapta excessivamente aos dados de treinamento, comprometendo sua capacidade de generalização. Isso é realizado ao limitar os pesos vinculados a cada característica.\n",
        "\n",
        "Dentro da regularização, encontramos o método **Lasso** (Least Absolute Shrinkage and Selection Operator). Este método possui a peculiaridade de não apenas ajustar, mas também zerar certos pesos, atuando de forma seletiva ao excluir algumas características que não são fundamentais para o modelo.\n",
        "\n",
        "Para empregar o Lasso, instanciamos um objeto correspondente e definimos um parâmetro `alpha` de valor 0.01. Esse parâmetro tem relevância destacada, pois estabelece o nível de regularização que desejamos impor ao nosso conjunto de dados."
      ],
      "metadata": {
        "id": "p5fT8wkv26ZN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando classes do módulo 'linear_model' da 'sklearn'\n",
        "from sklearn.linear_model import LinearRegression, Lasso\n",
        "\n",
        "# Inicializando e treinando um modelo Lasso com 'alpha' de 0.01 usando os dados de treino\n",
        "lrr = Lasso(alpha=0.01).fit(x_train, y_train)"
      ],
      "metadata": {
        "id": "4QovfAkT4IFB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Depois de treinado, utilizamos este modelo para realizar previsões no conjunto de testes:"
      ],
      "metadata": {
        "id": "IiwO_Fas4K2o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Realizando previsões com o modelo Lasso treinado usando os dados de teste\n",
        "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": [
        "O próximo passo envolve a avaliação do desempenho deste modelo. Para tal, recorremos à função `ml_error`, uma função personalizada que gera as métricas de erro essenciais para uma análise objetiva do desempenho.\n",
        "\n",
        "O diferencial do Lasso reside em sua capacidade de ajustar a complexidade do modelo através do `alpha`. Um detalhe importante a se observar é que, ao reduzir o valor de `alpha`, o tempo de treinamento pode aumentar, mas em contrapartida, os resultados tendem a ser mais precisos e eficientes."
      ],
      "metadata": {
        "id": "-0z0_zsU4WuI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculando o erro do modelo Lasso usando a função ml_error e revertendo a transformação dos dados\n",
        "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": [
        "### **Avaliação de Desempenho do Modelo**\n",
        "\n",
        "Após a análise, chegamos a determinados indicadores chave que refletem o desempenho do nosso modelo. O **Erro Médio Absoluto (MAE)** apresentou um valor de `1891`. Em termos percentuais, o **Erro Médio Absoluto Percentual (MAPE)** indicou uma discrepância de 29%. Adicionalmente, o modelo exibiu um **Erro Quadrático Médio da Raiz (RMSE)** de `2744`. Estes resultados são cruciais para compreendermos a precisão e a eficácia da nossa modelagem frente aos dados analisados.\n"
      ],
      "metadata": {
        "id": "C27sByWhKUuh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Avaliação dos Modelos Iniciais**\n",
        "\n",
        "Analisamos três modelos neste estudo: o modelo baseado em `média`, `regressão linear` e `regressão linear regularizada (Lasso)`. Ao avaliar os modelos pelo erro quadrático médio (`RMSE`), notamos que o modelo de média, apesar de sua simplicidade, teve o menor `RMSE`, com valor de 1.835. Por sua vez, a regressão linear marcou 2.670, enquanto o Lasso, que atua evitando o sobreajuste por penalizar coeficientes, teve um `RMSE` de 2.744. Apesar do destaque do modelo de média, é inegável a importância de considerarmos modelos não-lineares, dada a complexidade intrínseca dos dados em análise. A conclusão aqui é clara: **abordagens mais simples nem sempre são as mais apropriadas para contextos intrincados**. Portanto, nosso próximo passo será investigar modelos não-lineares.\n",
        "\n",
        "**Exploração de Algoritmos Não-Lineares**\n",
        "\n",
        "Anteriormente, focamos em modelos lineares. Agora, nossa atenção volta-se para modelos não lineares, mais especificamente, o `Random Forest`. A razão para esta escolha reside no fato de que, embora modelos lineares sejam diretos, muitas vezes eles não capturam a totalidade dos padrões nos dados. O `Random Forest`, por ser um modelo mais flexível, é apto a reconhecer e modelar essas nuances. Estamos seguindo a metodologia `CRISP-DM`, começando com modelos mais simples e aumentando a complexidade conforme o projeto avança.\n",
        "\n",
        "---\n",
        "## **7.4 Regressor Random Forest**\n",
        "\n",
        "O algoritmo `Random Forest` opera através de múltiplas árvores de decisão. Durante o treinamento, é formado um \"bosque\" de árvores que operam de forma independente. Quando são feitas previsões, especialmente em contextos de regressão, a saída é determinada pela média das previsões de todas essas árvores. Implementamos o `Random Forest` usando a biblioteca `Scikit-learn`, uma ferramenta robusta em Python para modelagem de dados, e uma instância desse modelo foi estabelecida como `rf`."
      ],
      "metadata": {
        "id": "wZ1YXvmg5OHj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestRegressor\n",
        "\n",
        "# Instanciação e treinamento do modelo Random Forest\n",
        "# `n_estimators` define o número de árvores na floresta.\n",
        "# `n_jobs` determina o número de tarefas paralelas durante o treinamento.\n",
        "# `random_state` garante a reprodutibilidade dos resultados.\n",
        "rf = RandomForestRegressor(n_estimators=100, n_jobs=1, random_state=42).fit(x_train, y_train)"
      ],
      "metadata": {
        "id": "4_3iI9ZPFvuz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Configuração do Modelo Random Forest**\n",
        "\n",
        "Ao instanciar o modelo de Random Forest, definimos parâmetros chave. O `n_estimators=100` determina que serão criadas **100 árvores de decisão** no \"bosque\". Com `n_jobs=-1`, garantimos a utilização de **todos os processadores disponíveis** para otimizar o treinamento. E, para assegurar a **consistência dos resultados**, utilizamos `random_state=42`.\n",
        "\n",
        "Após definir a configuração, treinamos o modelo com os dados `x_train` e `y_train` usando o método `fit`. Quando necessitamos fazer previsões em novos dados, o modelo é aplicado ao conjunto `x_test`, resultando nas estimativas armazenadas em `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": [
        "**Avaliação da Performance do Modelo**\n",
        "\n",
        "Para entender o desempenho do nosso modelo, comparamos as **vendas reais** representadas por `y_test` com as **previsões geradas** pelo modelo, `yhat_rf`. Utilizamos a função `ml_error` para essa avaliação, e os insights obtidos são armazenados 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",
        "**Conclusão da Aplicação do Random Forest Regressor**\n",
        "\n",
        "Finalizamos a etapa de implementação do `Random Forest Regressor`, um marco crucial na nossa jornada de modelagem. Durante essa fase, conduzimos o **treinamento do modelo**, geramos **previsões** e avaliamos meticulosamente **o desempenho** do algoritmo."
      ],
      "metadata": {
        "id": "BmRHEmtoF-Sp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## 7.5 **XGBoost Regressor**\n",
        "\n",
        "Avançamos agora com a implementação do `XGBoost Regressor`, nosso quinto algoritmo de aprendizado de máquina. A escolha pelo **XGBoost** - abreviação para \"Extreme Gradient Boosting\" - é motivada por sua **agilidade e eficiência**, qualidades que o consagram no universo da Ciência de Dados.\n"
      ],
      "metadata": {
        "id": "JMZLEEX4GH8G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importa a biblioteca xgboost\n",
        "import xgboost as xgb\n",
        "\n",
        "# Cria e treina um modelo XGBRegressor\n",
        "model_xgb = xgb.XGBRegressor(\n",
        "    objective='reg:squarederror',  # Objetivo de otimização: erro quadrático\n",
        "    n_estimators=100,              # Número de etapas de boosting\n",
        "    eta=0.001,                     # Taxa de aprendizado\n",
        "    max_depth=10,                  # Profundidade máxima de uma árvore\n",
        "    subsample=0.7,                 # Fração de amostras para treinar cada árvore\n",
        "    colsample_bytree=0.9           # Fração de colunas selecionadas para cada árvore\n",
        ").fit(x_train, y_train)            # Treina o modelo usando os dados x_train e y_train\n"
      ],
      "metadata": {
        "id": "DlXT4fesIuDw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Configuração do Modelo XGBoost**\n",
        "\n",
        "Ao criar o modelo XGBoost, definimos vários parâmetros que orientam o seu comportamento:\n",
        "- `objective='reg:squarederror'`: Define a métrica de erro a ser minimizada, no caso o erro quadrático, que é comum em tarefas de regressão.\n",
        "- `n_estimators=100`: Especifica que 100 árvores de decisão serão criadas no processo de boosting.\n",
        "- `eta=0.001`: Estabelece uma taxa de aprendizado, controlando a contribuição de cada árvore.\n",
        "- `max_depth=10`: Limita a profundidade de cada árvore, evitando overfitting.\n",
        "- `subsample=0.7`: Usa 70% dos dados para treinar cada árvore, uma forma de randomização para aprimorar o modelo.\n",
        "- `colsample_bytree=0.9`: Garante que 90% das características sejam consideradas ao dividir os nós de uma árvore.\n",
        "\n",
        "Com o modelo definido, procedemos ao treinamento usando `x_train` e `y_train`. Para previsões futuras, este modelo será aplicado aos dados de teste `x_test`, e os resultados armazenados 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": [
        "**Avaliação do Modelo XGBoost**\n",
        "\n",
        "Para entender a eficácia do nosso modelo XGBoost, é crucial medir a discrepância entre o esperado e o previsto. Assim, comparamos as **vendas reais** representadas por `y_test` com as **previsões** geradas pelo modelo, `yhat_xgb`. Utilizamos a função `ml_error` para realizar essa comparação e os insights obtidos 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": [
        "**Implementação do XGBoost Regressor**\n",
        "\n",
        "Nesta fase, abordamos o **XGBoost Regressor**, um modelo renomado em aprendizado de máquina. Realizamos três etapas cruciais: a **criação** do modelo, a geração de **previsões** e, por fim, a **avaliação** de seu desempenho. Cada passo é vital para assegurar a eficiência e a precisão do modelo em tarefas preditivas."
      ],
      "metadata": {
        "id": "Fd8_HRFCJHmL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **7.6 Model Performance Comparison**\n",
        "\n",
        "Nossa principal intenção nesta seção é analisar e contrastar os desempenhos dos diferentes modelos de aprendizado de máquina que implementamos. O objetivo final é **identificar o modelo que apresenta o menor erro de previsão**.\n",
        "\n",
        "Para consolidar e comparar esses resultados, utilizamos a função `concat` do Pandas, que agrega múltiplos DataFrames em um único, facilitando a nossa análise comparativa."
      ],
      "metadata": {
        "id": "iRKdfAv5JW2-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Utilizando a função 'concat' do Pandas para agrupar os resultados dos diferentes modelos\n",
        "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": [
        "**Comparação de Desempenho dos Modelos**\n",
        "\n",
        "Na linha de código em questão, integramos os desempenhos de diversos algoritmos de aprendizado de máquina. Estes incluem o **modelo baseline**, a **regressão linear**, a **regressão com regularização Lasso**, o **Random Forest** e o **XGBoost**. Este agrupamento de resultados é armazenado na variável `modelling_result`.\n",
        "\n",
        "Posteriormente, nosso objetivo é ranquear os modelos com base em sua precisão. Utilizamos o **Erro Quadrático Médio (RMSE)** como indicador. Um RMSE mais baixo indica um modelo mais acurado, já que as previsões são mais próximas dos valores reais. Para organizar os modelos pelo RMSE, empregamos a função `sort_values`."
      ],
      "metadata": {
        "id": "Gj6NxC5nsWLN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ordena os resultados dos modelos com base no Erro Quadrático Médio (RMSE).\n",
        "# Um valor mais baixo de RMSE indica um melhor desempenho do modelo.\n",
        "modelling_result.sort_values('RMSE')"
      ],
      "metadata": {
        "id": "Zv2eK4WKsZwu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Avaliação do Desempenho dos Modelos**\n",
        "\n",
        "Em nossa análise, categorizamos os modelos com base no **Erro Quadrático Médio (RMSE)**. O RMSE, sendo uma métrica de erro, sinaliza que valores menores indicam **melhor desempenho**. Em meio aos modelos testados - que abrangem tanto abordagens lineares quanto não-lineares - o `Random Forest` se sobressaiu com um `RMSE` de `1011`. Em sequência, temos o **XGBoost Regressor** com `1250` e o modelo de médias com `1835`. A análise revela que os modelos lineares, com RMSEs de `2600` e `2744`, talvez não sejam as melhores opções para tarefas complexas como previsão de vendas.\n",
        "\n",
        "Isso nos sugere que a natureza do fenômeno em estudo - previsão de vendas - é intrinsecamente complexa e não-linear. Portanto, modelos como `Random Forest` e `XGBoost` podem ser mais adequados. No entanto, é importante ter em mente que a eficiência desses modelos pode vir ao custo de tempo de execução. Por exemplo, ampliando o número de árvores para `2500` ou `3000`, poderíamos enfrentar desafios temporais consideráveis em um ambiente de produção.\n",
        "\n",
        "Por fim, um ponto essencial é que o `RMSE` obtido pode não ser a representação absoluta do desempenho real de um modelo. Devido à divisão dos dados e à volatilidade inerente às vendas, há uma possibilidade de o `RMSE` oferecer uma visão otimista ou pessimista da eficácia do modelo."
      ],
      "metadata": {
        "id": "d6xa54Uwsdn2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **7.7 Cross-Validation Method (measuring actual model performance)**\n",
        "\n",
        "Na fase anterior, **avaliamos cinco modelos** usando dados referentes às últimas seis semanas. Contudo, o desempenho observado nessa avaliação pode não refletir a capacidade real dos modelos. Isso ocorre porque a performance pode variar conforme o período de tempo selecionado para teste.\n",
        "\n",
        "Para uma avaliação mais robusta, aplicamos o método de **validação cruzada**. Este procedimento divide o conjunto de dados em subconjuntos e avalia a performance do modelo repetidamente, usando diferentes combinações desses subconjuntos para treinamento e validação. Pode-se visualizar esse processo como se tivéssemos um baralho de 100 cartas, representando o conjunto de dados. Em cada etapa, usamos 90 cartas para treino e 10 para validação, assegurando que todas as cartas sejam usadas em ambos os contextos. Ao fim, a média dos resultados determina a performance geral do modelo. É crucial entender que, na validação cruzada, nos referimos aos dados de teste como \"dados de validação\".\n",
        "\n",
        "---\n",
        "### **7.7.1 Validação Cruzada para Séries Temporais**\n",
        "\n",
        "Quando lidamos com **séries temporais**, a validação cruzada exige uma abordagem ligeiramente diferente. A sequência temporal dos dados não deve ser ignorada. Assim, em vez de selecionar aleatoriamente os dados para treino e validação, mantemos sua ordem cronológica. Em cada iteração, expandimos o conjunto de treinamento para incorporar os dados da etapa anterior e selecionamos um novo período para validação.\n",
        "\n",
        "Por exemplificar, ao prever vendas semanais em um período de 6 semanas, a abordagem seria:\n",
        "\n",
        "1. Treine com dados da 1ª semana e valide com a 2ª.\n",
        "2. Treine com dados das 1ª e 2ª semanas e valide com a 3ª.\n",
        "\n",
        "E assim por diante, sempre mantendo a sequência temporal e expandindo o conjunto de treinamento. Dessa forma, o modelo é continuamente treinado com mais informações e avaliado em condições próximas às reais.\n"
      ],
      "metadata": {
        "id": "KnFuGfUwulVU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Preparação de Dados para Análise Temporal**\n",
        "\n",
        "Quando lidamos com análises temporais, a estruturação adequada dos dados é um ponto-chave. Suponha que temos um conjunto de dados, denominado `X_train`, que contém todas as variáveis relevantes, mas está desprovido das colunas `date` e `sales`, essenciais para nossa análise.\n",
        "\n",
        "Neste contexto, a primeira etapa é expandir `X_train`, criando uma coluna denominada `full` que englobará todas as informações. Em seguida, integramos às colunas `date` e `sales`, garantindo que a estrutura do conjunto de dados esteja completa e pronta para as análises que se seguirão."
      ],
      "metadata": {
        "id": "F-JH_zP560uT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definindo as colunas que serão adicionadas\n",
        "feat_to_add = ['date', 'sales']\n",
        "\n",
        "# Copiando a lista de colunas selecionadas pelo Boruta\n",
        "cols_selected_boruta_full = cols_selected_boruta.copy()\n",
        "\n",
        "# Estendendo a lista com as colunas 'date' e 'sales'\n",
        "cols_selected_boruta_full.extend(feat_to_add)\n",
        "\n",
        "# Filtrando o conjunto de treinamento com as colunas selecionadas\n",
        "x_training = X_train[cols_selected_boruta_full]\n",
        "\n",
        "# Mostrando as primeiras linhas do conjunto de treinamento atualizado\n",
        "x_training.head()"
      ],
      "metadata": {
        "id": "ZjZaRrB066H9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **K-Fold Cross Validation (Validação Cruzada K-Fold)**\n",
        "\n",
        "Desenvolvemos uma função chamada `cross_validation` para realizar a validação cruzada. Esta função recebe três argumentos: os dados de treino, a quantidade de divisões (representado pelo parâmetro `kfold`) e o nome do modelo.\n",
        "\n",
        "Dentro desta função, inicializamos listas para armazenar os valores de `MAE`, `MAPE` e `RMSE`. A escolha por essas métricas é motivada pela necessidade de avaliar de maneira robusta o desempenho do nosso modelo.\n",
        "\n",
        "O mecanismo de funcionamento é simples: percorremos em uma iteração reversa de 1 até `kfold + 1`. Para cada iteração, os conjuntos de treino e validação são segmentados com base nas datas, permitindo que o modelo aprenda a partir de diferentes amostras do dataset. Após treinar o modelo com os dados de treino de cada divisão, fazemos previsões usando os dados de validação.\n",
        "\n",
        "Estes resultados, ou seja, os desempenhos em cada ciclo, são armazenados nas respectivas listas de `MAE`, `MAPE`e `RMSE`. No término da função, consolidamos esses resultados e retornamos um DataFrame que apresenta o nome do modelo junto às médias e desvios padrão das métricas mencionadas.\n",
        "\n",
        "Essa abordagem nos oferece uma visão mais ampla do desempenho do modelo, ao invés de confiarmos em uma única divisão de treino e teste, garantindo uma avaliação mais confiável."
      ],
      "metadata": {
        "id": "3YKiCn9oBopO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definindo a função de validação cruzada\n",
        "def cross_validation(x_training, kfold, model_name, model, verbose=False):\n",
        "    # Listas para armazenar os erros de cada ciclo K-Fold\n",
        "    mae_list  = []\n",
        "    mape_list = []\n",
        "    rmse_list = []\n",
        "\n",
        "    # Iniciando o loop em ordem reversa do valor de kfold até 1\n",
        "    for k in reversed(range(1, kfold+1)):\n",
        "        # Determinando o intervalo de datas para validação\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",
        "        # Segmentando os dados em conjuntos de treino e validação com base nas datas\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",
        "        # Definindo os conjuntos de treino e validação para as features e os targets\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",
        "        # Treinando o modelo com os dados de treino\n",
        "        m = model().fit(xtraining, ytraining)\n",
        "\n",
        "        # Fazendo previsões com os dados de validação\n",
        "        yhat = m.predict(xvalidation)\n",
        "\n",
        "        # Calculando o erro entre previsões e valores reais\n",
        "        m_result = ml_error(model_name, np.expm1(yvalidation), np.expm1(yhat))\n",
        "\n",
        "        # Armazenando o erro de cada métrica para essa 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",
        "    # Calculando e retornando as médias e desvios padrão das métricas de erro após todos os ciclos K-Fold\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",
        "### **Detailing the Cross Validation Function**\n",
        "\n",
        "Ao trabalhar com modelos preditivos, é crucial segmentar nossos dados de maneira eficaz. O processo de validação cruzada auxilia nessa segmentação, garantindo uma avaliação precisa do desempenho do modelo.\n",
        "\n",
        "Nesta função, adotamos a estratégia de **validação temporal**, onde definimos duas datas essenciais: `validation_start_date` e `validation_end_date`. Estas determinam o intervalo de tempo que será usado para testar o modelo. A escolha dessas datas é influenciada pelo período mais recente do conjunto de dados. Se, por exemplo, o nosso conjunto de dados termina na data 'D' e decidimos utilizar as últimas 6 semanas como teste, a `validation_end_date` seria 'D', enquanto a `validation_start_date` seria 'D' menos essas 6 semanas.\n",
        "\n",
        "Através desta abordagem, simulamos um cenário onde o modelo é treinado com dados históricos e é avaliado em sua capacidade de prever eventos em um futuro próximo. Isso garante que avaliemos a real capacidade preditiva do modelo, preparando-o para situações reais de aplicaçã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": [
        "### **Data Segmentation into Training and Validation**\n",
        "\n",
        "Após estabelecer as datas essenciais, `validation_start_date` e `validation_end_date`, procedemos à divisão de nosso conjunto de dados. O conjunto de treinamento englobará todas as entradas anteriores à `validation_start_date`. Já o conjunto de validação incorporará as informações no intervalo entre `validation_start_date` e `validation_end_date`.\n",
        "\n",
        "Esta organização é fundamental para treinar nosso modelo com uma base sólida de dados passados e, posteriormente, avaliar sua capacidade preditiva em um período específico e mais recente."
      ],
      "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": [
        "### **Confirming Data Segregation by Date Ranges**\n",
        "\n",
        "Após a subdivisão dos nossos dados em conjuntos de treinamento e validação, é fundamental assegurar que essa segmentação foi feita corretamente. Para isso, uma prática recomendada é avaliar as datas extremas - mínima e máxima - presentes em cada subconjunto. Isso nos permite confirmar se os intervalos de `validation_start_date` e `validation_end_date` foram respeitados e se os dados estão estruturados conforme esperado.\n",
        "\n"
      ],
      "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": [
        "### **Flexibility in Temporal Analysis**\n",
        "\n",
        "Ao determinarmos as datas de início e término para a validação, utilizamos um valor específico, representado pela variável `k`, que define o número de semanas incluídas na validação. Essa escolha permite não apenas assegurar que os subconjuntos estejam corretamente segmentados, mas também oferece flexibilidade. Alterando o valor de `k`, podemos ajustar o período de tempo considerado na validação, garantindo uma análise temporal robusta e adaptável às nossas necessidades específicas."
      ],
      "metadata": {
        "id": "s2TwThDe7jLM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Cross-Validation Details**\n",
        "\n",
        "Ao nos prepararmos para a validação cruzada, o **manuseio adequado dos dados** é fundamental. Em nosso conjunto de dados, as colunas `data` e `vendas` são essenciais para a análise, mas não devem influenciar diretamente o treinamento do modelo. Por isso, antes de iniciar o processo de treinamento, removemos ambas as colunas dos conjuntos de treinamento e validação. Essa ação garante que o modelo se concentre apenas nas características mais relevantes para a previsã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": [
        "### **Model Creation and Training**\n",
        "\n",
        "Após a meticulosa preparação dos dados, avançamos para a etapa crucial: a **construção e o treinamento** do nosso modelo. Optamos pelo modelo de `Regressão Linear`, devido à sua eficácia e simplicidade em situações de relação linear entre variáveis. Utilizando o conjunto de treinamento, ensinamos esse modelo a reconhecer padrões e a estabelecer uma relação entre as características e a variável alvo. Esta fase é fundamental, pois a qualidade do treinamento determinará o desempenho do modelo em previsões futuras."
      ],
      "metadata": {
        "id": "4oC2ucz8BezB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "lr = LinearRegression().fit(xtraining, ytraining)"
      ],
      "metadata": {
        "id": "o4ricSZZBgK_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Prediction and Assessment**\n",
        "\n",
        "Uma vez que nosso modelo está treinado, entramos em uma etapa essencial: **a predição**. Utilizando o conjunto de validação, o modelo aplica o conhecimento adquirido para realizar previsões sobre dados que nunca viu antes. Mas, como sabemos se as previsões são precisas? Aqui entra a importância da **avaliação**. Medimos a eficácia do modelo utilizando a função `ml_error`, uma métrica personalizada que quantifica a diferença entre as previsões e os valores reais. Esta avaliação nos oferece um panorama claro sobre a capacidade do modelo em generalizar seu aprendizado para novos dados."
      ],
      "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": [
        "**Invocation and Finalization **\n",
        "\n",
        "Ao aproximar-se do término, nos deparamos com a invocação da função `cross_validation`. Nesta etapa, fornecemos à função três informações cruciais: os **dados de treinamento**, o **número de dobras (k-folds)** e, claro, o **modelo** escolhido - neste caso, a `Regressão Linear`. Adicionalmente, há um toque de personalização no processo: o parâmetro `verbose`. Esta opção determina se queremos, ou não, visualizar detalhes de cada iteração realizada. Se estivermos interessados em um acompanhamento mais detalhado, ativamos este parâmetro; caso contrário, o processo ocorre de forma mais discreta."
      ],
      "metadata": {
        "id": "hNQrg0rzM1m6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **7.2.1 Linear Regression Model with Cross Validation**\n",
        "\n",
        "O **Modelo de Regressão Linear** é uma das ferramentas fundamentais na caixa de ferramentas de um cientista de dados. Em nosso contexto, a validação cruzada, frequentemente referida como **Validação Cruzada**, amplifica a robustez deste modelo. Ao invocar este método, nos asseguramos que o modelo seja treinado e testado em diferentes subconjuntos do conjunto de dados, maximizando assim sua capacidade de generalização. Dessa maneira, evitamos que o modelo se ajuste excessivamente a uma única porção dos dados (`overfitting`) e asseguramos uma avaliação mais abrangente de seu desempenho. 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": [
        "A função `cross_validation` desempenha um papel essencial ao avaliar a performance de um modelo de Regressão Linear. No exemplo apresentado, essa função é invocada com cinco parâmetros distintos:\n",
        "\n",
        "1. `x_training` que representa o conjunto de dados destinado ao treinamento.\n",
        "2. O valor `5`, indicando o número de divisões ou \"dobras\" a serem usadas na validação cruzada.\n",
        "3. A string `'Linear Regression'` que designa o nome do modelo em questão.\n",
        "4. `model`, que é a instância do modelo treinado.\n",
        "5. Por último, temos o nível de detalhamento das informações exibidas, que foi definido como \"falso\" neste contexto.\n",
        "\n",
        "**Entendendo o Processo:** A validação cruzada divide o conjunto de dados em um número especificado de partes (neste caso, cinco). O modelo é treinado em quatro dessas partes e testado na quinta. Este processo é repetido cinco vezes, garantindo que cada segmento seja usado como teste uma vez.\n",
        "\n",
        "Após as iterações, temos cinco métricas de desempenho. Estas são essenciais para calcular a média e o desvio padrão, fornecendo uma visão abrangente do desempenho do modelo. Em uma das iterações, o valor do **Root Mean Square (RMS)** foi de `2.671`. Contudo, o RMS médio calculado foi de `2.900`, o que sugere variações no desempenho durante as diferentes iterações.\n",
        "\n",
        "Para uma avaliação robusta, considera-se a média ± o desvio padrão. Neste exemplo, a performance real do modelo varia entre `2.400` e `3.400`. Esta abordagem nos oferece uma visão holística do desempenho, sendo mais informativa do que uma avaliação isolada."
      ],
      "metadata": {
        "id": "evigTe-0BrkN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **7.3.1 Lasso - Cross Validation**\n",
        "A validação cruzada é uma técnica vital na avaliação da eficácia de modelos de regressão. No contexto do nosso projeto de previsão de vendas, voltamos nossa atenção para o modelo **Lasso**, uma modalidade da regressão linear que incorpora regularização.\n",
        "\n",
        "A invocação da função `cross_validation` para o modelo Lasso é similar àquela usada em modelos de regressão linear simples. Ela é chamada com cinco parâmetros específicos:\n",
        "\n",
        "- O conjunto de dados `x_training` designado para treinamento.\n",
        "- O número `5`, que define o total de divisões ou \"dobras\" na validação cruzada.\n",
        "- A denominação `'Lasso'` que especifica o tipo de modelo.\n",
        "- `LRR`, que é a instância do modelo Lasso após ser treinado.\n",
        "- E um marcador de controle de exibição de detalhes, aqui definido como \"falso\".\n",
        "\n",
        "Este processo fornece insights sobre a performance do modelo Lasso, permitindo avaliar sua precisão e confiabilidade nas previsões de vendas."
      ],
      "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": [
        "\n",
        "Ao abordar o modelo **Lasso**, recorremos à validação cruzada para avaliar seu desempenho. Esta técnica se destaca por dividir o conjunto de dados `x_training` em cinco segmentos, treinando o modelo em quatro destes e testando-o no restante. Essa estratégia repetitiva nos fornece diversas métricas de performance.\n",
        "\n",
        "Os resultados obtidos são esclarecedores. Enquanto o `RMSE` da última semana foi registrado em `2.952`, a média dos RMSEs obtidos através da validação cruzada foi de `3.057`. Este valor, associado ao desvio padrão de `504`, revela que o desempenho do modelo flutua em uma faixa entre `2.500` a `3.500`.\n",
        "\n",
        "Importante ressaltar que a métrica mais fidedigna para avaliar o desempenho do modelo Lasso é `3.057 ± 504`. Esta análise ampliada, proporcionada pela validação cruzada, permite identificar períodos atípicos, como uma semana de alto desempenho, e oferece uma visão mais ampla do comportamento do modelo em diferentes cenários. Tal abordagem assegura que nossas previsões não sejam baseadas em outliers ou semanas não representativas."
      ],
      "metadata": {
        "id": "5lqV2HOQQ_xO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **7.4.1 Random Forest Regressor - Cross Validation**\n",
        "Prosseguindo com nossa investigação sobre modelos preditivos, voltamos nossa atenção para a **Regressão de Floresta Aleatória** (Random Forest Regressor). Este método se destaca por agregar o poder de diversas árvores de decisão. Em vez de se apoiar em uma única árvore, ele treina múltiplas e, posteriormente, integra suas previsões. Esse processo de integração visa aprimorar a precisão e robustez da previsão.\n",
        "\n",
        "Assim como nos modelos anteriores, a estratégia de validação cruzada é empregada para avaliar a eficácia do Random Forest Regressor. A função `cross_validation` é novamente convocada, porém, agora, a variável que designa o modelo treinado é `rf`. Adicionalmente, optamos por ativar o parâmetro `verbose`, proporcionando um monitoramento detalhado do andamento das operações."
      ],
      "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": [
        "Ao prosseguir na nossa análise de modelos preditivos, exploramos agora o **Random Forest Regressor**. Este modelo, ao utilizar diversas árvores de decisão, potencializa a precisão das previsões.\n",
        "\n",
        "Executando o comando `rf_result_cv = cross_validation(x_training, 5, 'Random Forest Regressor', rf, verbose=True)`, iniciamos o processo de validação cruzada para o Random Forest Regressor. Os resultados obtidos, consistentes com as avaliações anteriores, nos oferecem insights valiosos sobre o desempenho e a acurácia deste modelo em prever vendas."
      ],
      "metadata": {
        "id": "43wrOn6q397A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **7.5.1 XGBoost Regressor - Cross Validation**\n",
        "Em nossa contínua exploração de modelos preditivos, chegamos ao **XGBoost Regressor**. Este algoritmo avançado utiliza a técnica de boosting, uma estratégia onde modelos subsequentes são treinados com base nos erros do modelo anterior. O resultado é uma série de previsões progressivamente mais refinadas.\n",
        "\n",
        "O que distingue o XGBoost é sua notável eficiência. Ele tem uma reputação consolidada em competições de aprendizado de máquina, sendo frequentemente reconhecido por sua precisão inigualável.\n",
        "\n",
        "Para avaliar a performance do XGBoost, aplicaremos a validação cruzada, assim como fizemos com os modelos anteriores. Utilizando a função `cross_validation`, fornecemos os parâmetros essenciais: o conjunto de treinamento, o número de divisões, o nome do modelo e o modelo treinado, neste caso, `model_xgb`. Definimos `verbose` como `True`, garantindo assim a visualização do progresso do processo em tempo real."
      ],
      "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": [
        "Obtemos as métricas de desempenho específicas para este modelo. Com esses dados em mãos, somos capazes de comparar a eficácia do XGBoost Regressor em relação aos modelos que já examinamos anteriormente. A meta, naturalmente, é identificar qual algoritmo nos oferece a mais acurada previsão de vendas. Esse processo é fundamental para uma tomada de decisão informada sobre qual estratégia adotar em nossas previsões."
      ],
      "metadata": {
        "id": "HiMz8khc41Xn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Sales Forecasting Algorithm: Comparative Analysis**\n",
        "\n",
        "Concluímos nossa jornada exploratória com a aplicação de algoritmos de previsão de vendas, onde exploramos modelos como **Regressão Linear**, **Lasso Regressor**, **Random Forest Regressor** e **XGBoost Regressor**. O próximo passo crucial é analisar e contrastar o desempenho de cada modelo, visando identificar o mais preciso entre eles.\n",
        "\n",
        "Para uma análise clara e direta, estabelecemos duas categorias de avaliação:\n",
        "\n",
        "- A primeira, apresentada na subseção **7.6.1 - Single Performance**, consolida o desempenho de cada modelo com base em um único fold.\n",
        "  \n",
        "- Já a segunda, detalhada na subseção **7.6.2 - Real Performance - Cross Validation**, nos oferece uma visão mais aprofundada, revelando o desempenho dos modelos quando submetidos ao processo de validação cruzada.\n",
        "\n",
        "### **7.6.1 - Single Performance**\n",
        "\n",
        "Nesta fase, nosso objetivo é unificar os resultados de todos os modelos em um único `DataFrame`, nomeado `modeling_result`. Essa consolidação permitirá a comparação direta de desempenho com base no valor do **Erro Quadrático Médio** (RMSE - Root Mean Squared Error). O código para essa operação é:\n",
        "\n",
        "(Note: The following line of code was not provided, but this is where it would be inserted if given.)\n",
        "\n",
        "Através desta estrutura organizada, estamos preparados para discernir qual modelo melhor atende às nossas necessidades de previsão."
      ],
      "metadata": {
        "id": "wibyULZN6Y18"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importa a função 'concat' da biblioteca Pandas\n",
        "import pandas as pd\n",
        "\n",
        "# Concatenando os resultados dos diferentes modelos em um único DataFrame\n",
        "modeling_result = pd.concat(['baseline_result', 'lr_result', 'lrr_result', 'rf_result', 'xgb_result'])\n",
        "\n",
        "# Ordenando o DataFrame resultante com base no valor do RMSE (Erro Quadrático Médio Raiz)\n",
        "# Um RMSE menor indica um modelo com melhor desempenho\n",
        "modeling_result.sort_values('RMSE')\n"
      ],
      "metadata": {
        "id": "ViDqOeqv5vg0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **7.6.2. Real Performance - Cross Validation**\n",
        "Dentro da subseção 7.6.2, voltamos nossa atenção ao desempenho dos modelos sob o prisma da **validação cruzada**. Este método é fundamental, pois nos oferece uma visão mais realista do desempenho de um modelo, ao avaliá-lo em diferentes subconjuntos do conjunto de dados.\n",
        "\n",
        "Para tal, executaremos um código específico que irá sintetizar os resultados desta validação. Esse processo nos permite obter uma avaliação consolidada e comparativa dos modelos, ajudando na escolha do mais adequado para nossas previsões.\n",
        "\n",
        "Lembrando que a validação cruzada é um método de avaliação que divide o conjunto de dados em partes, treina o modelo em algumas dessas partes e o testa nas restantes. Isso é repetido várias vezes, rotacionando os dados de treino e teste, para garantir que o modelo seja avaliado de maneira abrangente e não tendenciosa.\n"
      ],
      "metadata": {
        "id": "WjMOQBvh5V9b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Concatenando os resultados da validação cruzada dos diferentes modelos em um único DataFrame\n",
        "modeling_result_cv = pd.concat(['lr_result_cv', 'lrr_result_cv', 'rf_result_cv', 'xgb_result_cv'])\n",
        "\n",
        "# Ordenando o DataFrame resultante com base no valor do RMSE (Erro Quadrático Médio Raiz)\n",
        "# Novamente, um RMSE menor indica um modelo com melhor desempenho\n",
        "modeling_result_cv.sort_values('RMSE')"
      ],
      "metadata": {
        "id": "hW31Z0gN5R5G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Performance Analysis of the Models**\n",
        "\n",
        "Ao executar o código proposto, obteremos duas tabelas essenciais para nossa análise. A primeira evidencia o **desempenho** de cada modelo com base em uma única divisão dos dados, enquanto a segunda destaca a performance efetiva dos modelos, considerando a abrangente **validação cruzada**.\n",
        "\n",
        "Estas tabelas são cruciais, pois não apenas ilustram a capacidade individual de cada modelo, mas também nos permitem uma comparação objetiva entre eles. Com base nessa análise comparativa, poderemos identificar e selecionar o modelo que mais eficientemente prevê as vendas em nosso contexto específico."
      ],
      "metadata": {
        "id": "omEp_H536sN-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### ** Conclusion on Forecasting Models*\n",
        "Finalizamos a etapa de treinamento e avaliação dos modelos de previsão. Durante esse processo, analisamos quatro modelos: `Linear Regression`, `Lasso Regression`, `Random Forest` e `XGBoost`. O **Random Forest** destacou-se, apresentando um `RMSE` médio de 1256, valor que se mostrou superior ao dos outros modelos, evidenciando sua eficiência tanto em classificação quanto em regressão.\n",
        "\n",
        "Entretanto, decidimos avançar com o **XGBoost**. Tal escolha é fundamentada em duas razões principais: sua crescente popularidade em cenários variados e nossa experiência anterior onde, apesar da eficácia do Random Forest, seu tamanho e consequente custo de manutenção em produção eram elevados. Contudo, é vital entender que a seleção do modelo se adapta ao contexto e metas específicas de cada projeto. Os procedimentos aqui discutidos podem ser adaptados a qualquer modelo de Machine Learning.\n",
        "\n",
        "O próximo passo é aprimorar os hiperparâmetros do `XGBoost`, processo crucial para refinar o desempenho do algoritmo, focando na otimização dos parâmetros que norteiam o aprendizado do modelo.\n",
        "\n",
        "---\n",
        "\n",
        "### **Project Update: Rossmann Sales Forecast**\n",
        "\n",
        "Neste ponto, proporcionamos um panorama do atual estágio de nosso projeto de previsão de vendas para a Rossmann, elucidando cada fase para todos os envolvidos.\n",
        "\n",
        "Baseamos nosso projeto em um ciclo de 10 etapas, inspirado no CRISP-DM, renomada metodologia em ciência de dados. Iniciamos definindo a necessidade da Rossmann: prever vendas para estabelecer orçamentos de reforma. Em seguida, aprofundamos na compreensão dessa demanda, dialogando com stakeholders e definindo que prever vendas para as seis semanas subsequentes seria o ideal.\n",
        "\n",
        "Na fase de coleta, embora em contextos distintos os métodos possam variar, obtivemos dados da plataforma Kaggle. Depois, os dados foram tratados, considerando descrição, engenharia de características e filtros conforme necessidades empresariais. Posteriormente, mergulhamos na análise exploratória, validando hipóteses e realizando testes.\n",
        "\n",
        "Após a preparação dos dados, selecionamos as variáveis mais impactantes com o algoritmo Boruta. Na modelagem, cinco algoritmos de aprendizado de máquina foram implementados.\n",
        "\n",
        "No momento, focamos no ajuste do `XGBoost`, mesmo este apresentando desempenho ligeiramente abaixo do Random Forest. As etapas vindouras abordarão a avaliação dessemodelo e a decisão de sua aplicação em produção, culminando na primeira solução para a demanda de previsão de vendas da Rossmann."
      ],
      "metadata": {
        "id": "5uVIXPSOC5Gm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "# **8.0 Fine Tuning**\n",
        "No projeto de previsão de vendas, o **ajuste de hiperparâmetros** é crucial para otimizar a performance de nossos modelos de Machine Learning. Estes hiperparâmetros são configurações modificáveis que determinam como os modelos aprendem com os dados. Para exemplificar, são comparáveis aos botões de um rádio, ajustados para a melhor sintonia.\n",
        "\n",
        "Os hiperparâmetros variam conforme o modelo. Em redes neurais, englobam o número de neurônios, camadas ocultas e função de ativação. Em modelos de \"Random Forest\", abrangem o número de estimadores e a profundidade das árvores. Selecionar seus valores corretamente é vital, pois se bem ajustados, elevam a precisão das previsões e reduzem o overfitting. Para isso, adotamos técnicas avançadas, ao invés de simples seleção aleatória, a fim de otimizar o desempenho do modelo.\n",
        "\n",
        "Três abordagens principais para ajuste são: `Random Search`, `Grid Search` e `Bayesian Optimization`.\n",
        "\n",
        "### **Random Search**\n",
        "\n",
        "A estratégia `Random Search` escolhe valores de hiperparâmetros de maneira aleatória dentro de um conjunto predefinido. Por exemplo, em um modelo XGBoost, consideramos hiperparâmetros como número de estimadores, subamostra, profundidade máxima, taxa de aprendizado e peso mínimo da criança. Em cada iteração, valores são selecionados aleatoriamente, o modelo é treinado/testado e o desempenho registrado. Ao final, opta-se pelo conjunto de hiperparâmetros de melhor performance. Seu trunfo está na velocidade de implementação. No entanto, devido à sua abordagem aleatória, pode não encontrar o conjunto ideal.\n",
        "\n",
        "###**Grid Search**\n",
        "\n",
        "A técnica `Grid Search` examina todas as combinações possíveis de hiperparâmetros. O modelo é treinado/testado para cada combinação, usando validação cruzada, e a performance é registrada. A combinação de melhor desempenho é selecionada. Entretanto, seu ponto fraco é o tempo consumido, podendo ser inviável em certos cenários. Embora o ajuste de hiperparâmetros seja crucial, outros fatores, como qualidade dos dados e escolha do algoritmo, também influenciam o desempenho.\n",
        "\n",
        "### **Bayesian Search**\n",
        "\n",
        "Diferentemente das técnicas anteriores, a `Bayesian Search` fundamenta-se na teoria bayesiana para escolher os valores dos hiperparâmetros. Seu foco é calcular a probabilidade dos hiperparâmetros com base no erro observado, tornando a busca mais direcionada e eficiente. Supera o Grid Search em velocidade e o Random Search em precisão, mas pode ser mais complexo. No nosso projeto, a preferência é pelo Random Search pela relação custo-benefício e facilidade de aplicação. Contudo, é essencial conhecer todas as estratégias para enriquecer a expertise em Machine Learning."
      ],
      "metadata": {
        "id": "3Ucboai5B6s_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **8.1 Hyperparameter Tuning with Random Search**\n",
        "Ao desenvolver nosso projeto de previsão de vendas, optamos pelo algoritmo `XGBoost` para estruturar nosso modelo preditivo. Uma etapa crucial na modelagem de aprendizado de máquina é o ajuste de hiperparâmetros. Os hiperparâmetros são configurações específicas que orientam o processo de treinamento. No contexto do `XGBoost`, alguns dos hiperparâmetros centrais são:\n",
        "\n",
        "- **`n_estimators`**: Refere-se ao número de árvores que o modelo irá construir.\n",
        "- **`eta`**: É a taxa de aprendizado, que determina o passo de cada iteração.\n",
        "- **`max_depth`**: Indica a profundidade máxima que cada árvore pode alcançar.\n",
        "- **`subsample`**: Define a fração de amostras utilizadas para ajustar cada árvore individual.\n",
        "- **`colsample_bytree`**: Estipula a fração de colunas consideradas na construção de cada árvore.\n",
        "- **`min_child_weight`**: Representa o peso mínimo exigido em um nó folha.\n",
        "\n",
        "Para otimizar a performance do modelo, precisamos escolher valores apropriados para esses hiperparâmetros. A estratégia de **Random Search** é uma técnica que seleciona aleatoriamente combinações desses valores e testa o desempenho do modelo. Dessa forma, conseguimos identificar a combinação que oferece os melhores resultados para o nosso conjunto de dados específico."
      ],
      "metadata": {
        "id": "v-AR6Raqc-ex"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando o módulo necessário\n",
        "import warnings\n",
        "\n",
        "# Desativando avisos para deixar a saída do código mais limpa\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Definindo os hiperparâmetros para o Random Search\n",
        "param = {\n",
        "    # O número de árvores de decisão na floresta\n",
        "    'n_estimators': [15, 17, 25, 30, 35],\n",
        "\n",
        "    # A taxa de aprendizado\n",
        "    'eta': [0.01, 0.03],\n",
        "\n",
        "    # A profundidade máxima das árvores\n",
        "    'max_depth': [3, 5, 9],\n",
        "\n",
        "    # Fração dos exemplos de treinamento a serem usados em cada árvore\n",
        "    'subsample': [0.1, 0.5, 0.7],\n",
        "\n",
        "    # Fração de colunas a serem usadas em cada árvore\n",
        "    'colsample_bytree': [0.3, 0.7, 0.9],\n",
        "\n",
        "    # 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": [
        "**Busca Aleatória**: Uma Técnica de Otimização de Hiperparâmetros\n",
        "\n",
        "A **busca aleatória** é uma técnica robusta para otimizar os hiperparâmetros de um modelo de aprendizado de máquina. Ao invés de testar todas as combinações possíveis, essa técnica seleciona, de forma aleatória, conjuntos de hiperparâmetros para um número pré-definido de iterações. Esta quantidade é determinada pela variável `MAX_EVAL`. Durante cada iteração, um conjunto específico de hiperparâmetros é empregado para treinar o modelo, neste caso, um modelo **XGBoost**. Posteriormente, avalia-se o desempenho desse modelo por meio da **validação cruzada**.\n",
        "\n",
        "A estruturação do código que executa a busca aleatória segue a lógica acima mencionada."
      ],
      "metadata": {
        "id": "XRjIQi92k9Uz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import xgboost as xgb\n",
        "\n",
        "# Número máximo de avaliações\n",
        "MAX_EVAL = 2\n",
        "\n",
        "# Dataframe para armazenar os resultados de todas as iterações\n",
        "final_results = pd.DataFrame()\n",
        "\n",
        "for _ in range(MAX_EVAL):\n",
        "    # Seleção aleatória de hiperparâmetros\n",
        "    hp = {k: random.choice(v) for k, v in param.items()}\n",
        "    print(f\"Hiperparâmetros selecionados: {hp}\")\n",
        "\n",
        "    # Inicialização do modelo XGBoost com os hiperparâmetros selecionados\n",
        "    model_xgb = xgb.XGBRegressor(\n",
        "        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",
        "    )\n",
        "\n",
        "    # Avaliação da performance do modelo utilizando validação cruzada\n",
        "    result = cross_validation(x_training, 2, 'XGBoost Regressor', model_xgb, verbose=False)\n",
        "    final_results = pd.concat([final_results, result])\n",
        "\n",
        "# Exibe os resultados finais\n",
        "final_results"
      ],
      "metadata": {
        "id": "W2RmLnS_E0zI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Hyperparameter Optimization Analysis**\n",
        "Após completar as iterações de otimização, torna-se imperativo avaliar cuidadosamente os resultados para determinar a combinação ótima de hiperparâmetros. Cada iteração reflete uma combinação distinta, selecionada aleatoriamente, levando a performances variadas.\n",
        "\n",
        "No nosso estudo, observamos diferentes combinações a cada iteração. A performance do modelo, medida pela métrica `Root Mean Square Error (RMSE)`, serve como um indicador da qualidade da predição. Este valor quantifica o erro do modelo, isto é, a discrepância entre as predições e os dados reais.\n",
        "\n",
        "No contexto avaliado, a segunda iteração registrou um valor de `RMSE` inferior à primeira, sinalizando que os hiperparâmetros da segunda foram mais eficazes. Assim, um cientista de dados prático se concentraria nos valores dessa segunda iteração, visto que otimizaram a performance conforme a métrica RMSE.\n",
        "\n",
        "Este procedimento é vital em projetos de previsão, pois direciona para hiperparâmetros que aprimoram a acurácia do modelo, elevando a confiabilidade das projeções de vendas.\n",
        "\n"
      ],
      "metadata": {
        "id": "-nQO94EqZugM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **8.2. Final Model**\n",
        "Ao concluir a otimização dos hiperparâmetros para nosso modelo de previsão de vendas, determinamos que o **conjunto de parâmetros da segunda iteração** proporcionou a melhor performance, com base na métrica `RMSE``.\n",
        "\n",
        "Assim, para a construção do modelo final, utilizamos os valores otimizados desses hiperparâmetros. Estes valores servirão como referência ao implementar o modelo em situações práticas, garantindo uma previsão mais precisa e confiável."
      ],
      "metadata": {
        "id": "t2cI0fp4ofei"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definindo um dicionário para armazenar os hiperparâmetros otimizados do modelo.\n",
        "param_tuned = {\n",
        "    'n_estimators'    : 30,        # Número de árvores a serem usadas no boosting\n",
        "    'eta'             : 0.03,      # Taxa de aprendizado\n",
        "    'max_depth'       : 9,         # Profundidade máxima de cada árvore\n",
        "    'subsample'       : 0.1,       # Proporção de amostras usadas para treinar cada árvore\n",
        "    'colsample_bytree': 0.7,       # Proporção de colunas usadas por cada árvore\n",
        "    'min_child_weight': 15.        # Soma mínima dos pesos das instâncias h necessária em um filho\n",
        "}"
      ],
      "metadata": {
        "id": "8UQeD62yokPv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "### **Optimized Model Training**\n",
        "Posteriormente, o **modelo XGBoost** foi ajustado utilizando os `hiperparâmetros otimizados` e os dados designados para treinamento. Utilizando este modelo ajustado, previsões foram realizadas com base no `conjunto de dados de teste`.\n",
        "\n"
      ],
      "metadata": {
        "id": "G_CfiJA8qru1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Inicialização e treinamento do modelo XGBoost com hiperparâmetros otimizados\n",
        "model_xgb_tuned = xgb.XGBRegressor(\n",
        "    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']\n",
        ").fit(x_train, y_train)\n",
        "\n",
        "# Realização da predição com o modelo ajustado\n",
        "yhat_xgb_tuned = model_xgb_tuned.predict(x_test)"
      ],
      "metadata": {
        "id": "ksNRaY72pC6h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "\n",
        "### **Model Performance Evaluation**\n",
        "\n",
        "Ao concluir o treinamento do modelo otimizado, sua eficácia foi meticulosamente avaliada usando o método `ml_error`. Essencialmente, este método mensura a diferença entre os valores reais das vendas, representados por `y_test`, e as estimativas geradas pelo modelo, denotadas como `yhat_xgb_tuned`. É vital observar que foi empregada uma **função exponencial** nesses conjuntos, com o intuito de desfazer a transformação logarítmica feita anteriormente no decorrer do projeto.\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "vhpb8FN2oil4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Avaliação da Performance do Modelo Otimizado\n",
        "xgb_result_tuned = ml_error('XGBoost Regressor', np.exp(y_test), np.exp(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",
        "---\n",
        "\n",
        "**Atualização do Projeto Rossmann**\n",
        "\n",
        "Estamos agora na etapa 9 de nosso projeto de previsão de vendas. Neste momento crucial, focamos na **interpretação e contextualização do erro** do nosso modelo. Isso significa que buscaremos entender o que a performance do nosso modelo representa em resultados tangíveis para o negócio: qual o valor financeiro que nosso modelo pode trazer, o que uma acurácia de 70% representa em lucros e o possível aumento de clientes.\n",
        "\n",
        "Antes de prosseguirmos, é importante relembrar nosso progresso:\n",
        "\n",
        "Iniciamos definindo e entendendo a problemática empresarial em questão. A partir daí, coletamos dados de forma criteriosa, com o auxílio de SQL. Posteriormente, priorizamos a integridade dos dados, limpando-os e tratando-os, para garantir sua qualidade. Com os dados limpos, partimos para uma análise exploratória profunda para realmente compreender a situação atual do negócio.\n",
        "\n",
        "Preparamos os dados para a modelagem, realizando as transformações necessárias, visto que modelos de machine learning possuem particularidades em relação ao formato dos dados. Seguimos treinando diversos modelos, variando entre lineares e não lineares, e avaliando-os em relação a um modelo de referência (baseline).\n",
        "\n",
        "Nossa missão, ao longo deste projeto, foi resolver uma problemática empresarial real. Embora a ciência de dados e o machine learning sejam essenciais, o foco sempre foi aplicá-los de maneira que potencialize os resultados da empresa. Então, seguimos para avaliar a eficácia de nosso modelo e o impacto gerado.\n",
        "\n",
        "---\n",
        "\n",
        "## **9.0 Error Translation and Interpretation**\n",
        "\n",
        "No projeto de previsão de vendas, é imperativo avaliar e interpretar o erro de maneira apropriada, bem como ajustar a escala dos dados. Nesta seção, faremos ambas as atividades de forma transparente e didática.\n",
        "\n",
        "Para avaliar o erro, começamos selecionando as colunas relevantes de `X_test`, identificadas durante a etapa de seleção de características, usando a técnica **Boruta**. Estas são mantidas na variável `cols_selected_boruta_full`. Ainda, colunas como `date` e `sales` são essenciais, visto seu papel fundamental na validação cruzada.\n"
      ],
      "metadata": {
        "id": "8WYAMykAX100"
      }
    },
    {
      "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": [
        "# Revertendo a transformação logarítmica dos dados usando a função expm1 do NumPy\n",
        "df9[['sales', 'predictions']] = np.expm1(df9[['sales', 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": [
        "---\n",
        "## **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": [
        "# Agrupando os dados por loja e somando as previsões de vendas para cada uma, depois redefinindo o índice.\n",
        "df91 = df9.groupby('store')['predictions'].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": [
        "def calculate_errors(x):\n",
        "    mae = mean_absolute_error(x['sales'], x['predictions'])\n",
        "    mape = mean_absolute_percentage_error(x['sales'], x['predictions'])\n",
        "    return pd.Series((mae, mape), index=['MAE', 'MAPE'])\n",
        "\n",
        "df9_aux = df9[['store', 'sales', 'predictions']].groupby('store').apply(calculate_errors).reset_index()"
      ],
      "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": [
        "# Realiza uma junção dos DataFrames df9_aux1 e df9_aux2.\n",
        "# Esta junção é feita com base na coluna 'store', e utiliza o método 'inner',\n",
        "# o que significa que somente as lojas que existem em ambos os DataFrames serão mantidas.\n",
        "df9_aux3 = pd.merge(df9_aux1, df9_aux2, how='inner', on='store')\n",
        "\n",
        "# Agora, realiza uma nova junção, desta vez entre o DataFrame df91 e df9_aux3.\n",
        "# Novamente, a junção é feita com base na coluna 'store' usando o método 'inner'.\n",
        "# O resultado, df92, contém as informações combinadas dos três DataFrames originais.\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": [
        "# Calcula o cenário mais pessimista (worst_scenario) para cada loja, subtraindo o MAE (Erro Médio Absoluto) da previsão.\n",
        "# Isso nos dá uma estimativa inferior das vendas previstas, considerando o erro possível do modelo.\n",
        "df92['worst_scenario'] = df92['predictions'] - df92['MAE']\n",
        "\n",
        "# Calcula o cenário mais otimista (best_scenario) para cada loja, adicionando o MAE à previsão.\n",
        "# Isso nos dá uma estimativa superior das vendas previstas, considerando o erro possível do modelo.\n",
        "df92['best_scenario'] = df92['predictions'] + df92['MAE']\n",
        "\n",
        "# Reorganiza as colunas do DataFrame para uma melhor visualização e compreensão dos dados.\n",
        "# Aqui, as colunas estão ordenadas por relevância e contexto, começando com a loja, a previsão e os cenários derivados.\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": [
        "# Ordena o DataFrame df92 com base no Erro Percentual Absoluto Médio (MAPE) em ordem decrescente.\n",
        "top_mape_stores = 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": [
        "# Importando bibliotecas necessárias\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "class StoreAnalysis:\n",
        "\n",
        "    def __init__(self, data):\n",
        "        self.data = data\n",
        "\n",
        "    def plot_mape_distribution(self):\n",
        "        \"\"\" Visualiza a distribuição do Erro Percentual Absoluto Médio (MAPE) por loja. \"\"\"\n",
        "        plt.figure(figsize=(12, 6))\n",
        "        sns.scatterplot(x='store', y='MAPE', data=self.data)\n",
        "        plt.title('Distribuição de MAPE por Loja')\n",
        "        plt.xlabel('ID da Loja')\n",
        "        plt.ylabel('MAPE (%)')\n",
        "        plt.grid(True, which='both', linestyle='--', linewidth=0.5)\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "# Instanciando a classe e plotando o gráfico\n",
        "analysis = StoreAnalysis(df92)\n",
        "analysis.plot_mape_distribution()"
      ],
      "metadata": {
        "id": "k4Opn0VofCHr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Visualization of Store Performance**\n",
        "\n",
        "Ao analisar o gráfico, observamos que a maior parte das lojas apresenta um `MAPE` próximo de 10%. No entanto, lojas específicas, como as identificadas pelos números `292` e `900`, destacam-se com um `MAPE` ultrapassando 50%.\n",
        "\n",
        "Há também estabelecimentos com `MAPE` aproximado de 30%. Este gráfico nos sinaliza quais lojas necessitam de intervenções mais focadas para otimizar nossas previsões de vendas."
      ],
      "metadata": {
        "id": "DcPjcwXRY8Or"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **9.2 Total Forecast Performance**\n",
        "Para oferecer uma perspectiva abrangente das **previsões de vendas**, é essencial destacar os cenários mais e menos otimistas para todas as lojas. Tal resumo é valioso, particularmente para apresentar um panorama ágil aos interessados no projeto.\n",
        "\n",
        "Iniciamos a análise extraindo três colunas essenciais do `df92`: `predictions`, `worst_scenario` e `best_scenario`. Estas representam, respectivamente, as nossas previsões e as estimativas de cenários mais e menos favoráveis de vendas.\n",
        "\n",
        "A etapa subsequente envolve a utilização da função `apply` em conjunto com uma função `lambda`, objetivando somar todos os valores presentes em cada uma destas colunas. Essencialmente, essa operação itera e totaliza os valores ao longo do eixo vertical (agregando, assim, os valores de cada linha para cada respectiva coluna).\n",
        "\n",
        "O produto dessa operação é o `df93`, onde cada linha ilustra um cenário específico e a acumulação de valores associados a ele. Para otimizar a clareza dos dados, ajustamos o índice do `df93` e renomeamos as colunas para 'Scenario' e 'Values'. Adicionalmente, formatamos a coluna 'Values' para refletir os montantes no formato da moeda Real (R$), assegurando assim uma apresentação mais intuitiva e compreensível das projeções financeiras."
      ],
      "metadata": {
        "id": "q6JCdg-lSEq3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculando a soma das colunas 'predictions', 'worst_scenario' e 'best_scenario' e reformatando o dataframe resultante\n",
        "df93 = df92[['predictions', 'worst_scenario', 'best_scenario']].sum().reset_index()\n",
        "df93.columns = ['Scenario', 'Values']\n",
        "\n",
        "# Convertendo os valores da coluna 'Values' para o formato (R$)\n",
        "df93['Values'] = df93['Values'].apply(lambda x: f'R${x:,.2f}')\n",
        "\n",
        "# Exibindo o dataframe df93\n",
        "df93"
      ],
      "metadata": {
        "id": "8BCHKnhyYT4R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Forecasting Sales Overview**\n",
        "\n",
        "A análise do nosso `df93` agora proporciona um panorama das **previsões de vendas** para as próximas seis semanas em todas as lojas. Baseando-nos nos dados, antecipamos vendas totais de R$285 milhões. Em um cenário mais conservador, as vendas podem alcançar 285 milhões e 115 mil. Em contraste, em um cenário otimista, esperamos que as vendas cheguem a 286 milhões e 605 mil.\n",
        "\n",
        "É crucial compreender que, embora possa parecer intuitivo subtrair um cenário do outro para avaliar a precisão, esse método não é adequado aqui. O termo \"acurácia\" é mais alinhado a problemas de `classificação`, e não de `regressão`.\n",
        "\n",
        "Concluídas estas análises, a **visualização gráfica** se torna o próximo passo crucial. Em projetos de ciência de dados, gráficos desempenham um papel fundamental não apenas para interpretar as informações, mas também para transmiti-las de maneira clara, sobretudo para indivíduos sem familiaridade técnica na área."
      ],
      "metadata": {
        "id": "3m9Vwzy_TyS2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **9.3 Machine Learning Performance**\n",
        "Durante esta fase, priorizamos a claridade na apresentação dos resultados, introduzindo duas colunas cruciais: `error` e `error_rate`. Estas são meticulosamente calculadas para proporcionar uma base sólida para a construção de gráficos analíticos. Estes, por sua vez, oferecem insights significativos sobre o desempenho do algoritmo adotado."
      ],
      "metadata": {
        "id": "Pg29BOI4iUwF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculando a diferença entre as vendas reais e as previsões para determinar o erro\n",
        "df9['error'] = df9['sales'] - df9['predictions']\n",
        "\n",
        "# Calculando a taxa de erro como a razão entre as previsões e as vendas reais\n",
        "df9['error_rate'] = df9['predictions'] / df9['sales']"
      ],
      "metadata": {
        "id": "vamvIkpxSDUO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### **Error Analysis in Sales Predictions**\n",
        "\n",
        "Na avaliação da precisão das previsões, dois parâmetros cruciais são **'error'** e **'error_rate'**. O primeiro, **'error'**, mensura a discrepância entre as vendas reais e as estimadas. Já o **'error_rate'** representa a proporção dessas previsões em relação aos valores verdadeiros, oferecendo uma perspectiva percentual da acurácia.\n",
        "\n",
        "Para uma interpretação visual e abrangente desses dados, implementamos quatro gráficos. O trecho de código subsequente detalha a metodologia de criação destas visualizações."
      ],
      "metadata": {
        "id": "FbHEr73YiiqL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Preparando uma matriz de subplots 2x2 para mostrar 4 gráficos\n",
        "fig, axs = plt.subplots(2, 2, figsize=(14,10))\n",
        "\n",
        "# Primeiro gráfico: Comparação entre vendas reais e previsões ao longo do tempo\n",
        "axs[0,0].set_title(\"Comparação entre Vendas e Previsões\")\n",
        "sns.lineplot(x = 'date', y = 'sales', data = df9, label = 'SALES', ax=axs[0,0])\n",
        "sns.lineplot(x = 'date', y = 'predictions', data = df9, label = 'PREDICTIONS', ax=axs[0,0])\n",
        "\n",
        "# Segundo gráfico: Visualização da taxa de erro ao longo do tempo\n",
        "axs[0,1].set_title(\"Taxa de Erro ao Longo do Tempo\")\n",
        "sns.lineplot(x = 'date', y = 'error_rate', data = df9, ax=axs[0,1])\n",
        "\n",
        "# Terceiro gráfico: Distribuição dos erros\n",
        "axs[1,0].set_title(\"Distribuição do Erro\")\n",
        "sns.distplot(df9['error'], ax=axs[1,0])\n",
        "\n",
        "# Quarto gráfico: Dispersão entre as previsões e os erros\n",
        "axs[1,1].set_title(\"Relação entre Previsões e Erro\")\n",
        "sns.scatterplot(x = df9['predictions'], y = df9['error'], ax=axs[1,1])\n",
        "\n",
        "plt.tight_layout()  # Melhora o espaçamento entre os gráficos\n",
        "plt.show()  # Mostra os gráficos"
      ],
      "metadata": {
        "id": "opi4ppxgSGNV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Analysis of Sales Predictions**\n",
        "\n",
        "No primeiro gráfico, ilustramos a relação entre **vendas reais e previsões** através de linhas ao longo do tempo. A convergência notável entre ambas, durante um período de seis semanas, indica a precisão das previsões em relação às vendas concretizadas.\n",
        "\n",
        "No gráfico subsequente, o foco está no `error_rate` representado ao longo do tempo. A visualização serve para avaliar a eficiência do modelo: um `error_rate` de um denota precisão impecável. Valores superiores a um indicam superestimação das vendas, enquanto valores inferiores sinalizam subestimação.\n",
        "\n",
        "O terceiro gráfico, denominado `distplot`, detalha a **distribuição do erro**. Quando esta distribuição assemelha-se à normal, sugere-se que os erros são bem distribuídos, um indicativo promissor sobre a confiabilidade do modelo.\n",
        "\n",
        "Por fim, o quarto gráfico, um `scatterplot`, contrapõe **previsões e erros**. Tal visualização é vital para a análise de resíduos, uma técnica que destaca áreas onde o modelo pode ser suscetível a falhas, fornecendo insights para melhorias contínuas.\n",
        "\n",
        "Essas representações visuais e métricas não só traduzem o desempenho técnico do modelo, mas também facilitam sua interpretação em termos de impacto nos negócios, tornando os resultados mais acessíveis aos profissionais da área."
      ],
      "metadata": {
        "id": "WoxRudZSinTn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Rossmann Project Status**\n",
        "O projeto Rossmann, centrado na previsão de vendas, adotou dez etapas essenciais inspiradas na metodologia CRISP-DM. Essas etapas desenham uma trajetória coesa, começando com a compreensão profunda do negócio até culminar na implantação do modelo em questão. Vamos delinear brevemente cada uma:\n",
        "\n",
        "**Definição da questão de negócio**: Central para o projeto foi identificar a necessidade dos gerentes das lojas em prever vendas para as próximas seis semanas, visando planejar reformas. Este alinhamento inicial com a estratégia de negócio é crucial.\n",
        "\n",
        "**Entendimento do negócio**: Antes de qualquer abordagem técnica, era imprescindível entender o cerne do desafio. Isto implicou diálogos com os stakeholders para capturar a real magnitude do problema.\n",
        "\n",
        "**Coleta de dados**: Utilizamos um conjunto de dados da plataforma Kaggle. Em contextos variados, a origem dos dados pode ser múltipla, mas aqui, optou-se por um conjunto que reflete um ambiente profissional autêntico.\n",
        "\n",
        "**Limpeza dos dados**: Após uma análise descritiva inicial, engajamo-nos em 'feature engineering', criando variáveis mais informativas a partir das originais e filtrando o conjunto de dados para manter apenas o essencial.\n",
        "\n",
        "**Exploração de dados**: Esta etapa focou na análise exploratória, para entender os dados à luz do negócio e identificar variáveis com potencial de impacto no modelo final.\n",
        "\n",
        "**Preparação dos dados**: Posterior à exploração, os dados foram moldados para a modelagem, incluindo a codificação de variáveis categóricas e a seleção de variáveis usando o algoritmo `Boruta`.\n",
        "\n",
        "**Modelagem**: Implementamos cinco algoritmos de aprendizado de máquina, avaliando a eficácia de cada um.\n",
        "\n",
        "**Avaliação do modelo**: Utilizamos validação cruzada para uma avaliação robusta dos modelos desenvolvidos.\n",
        "\n",
        "**Interpretação dos resultados**: Além de avaliar a eficácia técnica, buscamos entender o valor real que o modelo poderia trazer ao negócio, seja financeiramente, na aquisição de clientes ou em economia.\n",
        "\n",
        "**Implantação (deploy)**: O modelo final foi hospedado em um ambiente de produção na nuvem, disponibilizando-o para os usuários finais.\n",
        "\n",
        "Vale destacar que a meta no primeiro ciclo do CRISP-DM é entregar rapidamente uma versão piloto da solução. Este lançamento inicial permite que os stakeholders percebam o real valor do Machine Learning, e o feedback coletado orienta melhorias em iterações subsequentes."
      ],
      "metadata": {
        "id": "6ti9Ksm116Eg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **10.0 Model Deployment in Production**\n",
        "No âmbito de projetos de previsão de vendas, é imperativo o **deployment** do modelo em ambiente de produção, permitindo que suas predições sejam acessadas por diversos consumidores, seja via aplicativo móvel, website ou outros softwares online.\n",
        "\n",
        "`API` (Interface de Programação de Aplicativos) pode ser entendida como um contrato que define como diferentes softwares se comunicam e interagem. Em suma, a API estabelece quais funções e métodos estão disponíveis para que uma aplicação converse com outra.\n",
        "\n",
        "Quando falamos em `Request`, nos referimos a um pedido feito à API. Esse é o modo como uma aplicação \"chama\" a outra para interagir. O `EndPoint` é, em sua essência, o endereço para onde essa requisição é direcionada, geralmente um URL. O termo `Deploy` alude ao processo de migrar um software do ambiente de desenvolvimento para o ambiente de produção, normalmente na nuvem, tornando-o acessível a dispositivos conectados à internet.\n",
        "\n",
        "Quanto ao **Ciclo de Desenvolvimento**:\n",
        "- `Ambiente Local`: Representa o local inicial de desenvolvimento, geralmente o dispositivo do programador.\n",
        "- `Ambiente de Produção`: Compreende servidores, muitas vezes baseados na nuvem, que ofertam serviços ou informações aos usuários finais.\n",
        "- `Ambiente de Desenvolvimento`: Funciona como uma réplica do ambiente de produção, porém com mais controles e sem acesso ao público. Aqui, os desenvolvedores testam mudanças antes de migrá-las para produção.\n",
        "\n",
        "Analisando a **Arquitetura de Produção** para nosso modelo:\n",
        "1. `Handler`: Atua como intermediário, recebendo requisições dos usuários e encaminhando-as ao modelo.\n",
        "2. `Preparação de Dados`: Prepara os dados para serem processados pelo modelo, realizando todas as etapas de limpeza, transformação e criação de variáveis. Essa etapa é crucial para alinhar os dados recebidos ao formato usado durante o treinamento do modelo.\n",
        "3. `Modelo Treinado`: Representa o núcleo de todo o sistema. Uma vez que os dados estão preparados, o modelo realiza as previsões e as envia de volta ao Handler, que, por sua vez, repassa ao usuário requisitante.\n",
        "\n",
        "O desenvolvimento deste projeto segue um fluxo definido: inicia-se no ambiente local, passa por testes no ambiente de desenvolvimento e, por fim, é implantado no ambiente de produção para acesso dos usuários.\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "HdwpQNKU2Cck"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **10.1 Rossmann Class Overview**\n",
        "Central ao nosso projeto está a **classe Rossmann**, um componente-chave que engloba todas as operações de limpeza, transformações e codificações realizadas durante o treinamento do modelo. Esta classe é vital para assegurar **consistência** e precisão ao aplicar o modelo a conjuntos de dados inéditos.\n",
        "\n",
        "Ao concluir o treinamento, a próxima etapa crítica é a preservação desse modelo. Utilizamos a biblioteca `pickle` do Python para essa finalidade. Através dela, o modelo é serializado em um único arquivo, que pode ser armazenado e posteriormente deserializado quando for necessário colocá-lo em operação."
      ],
      "metadata": {
        "id": "6YUkG-TWqQNH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pickle\n",
        "from google.colab import files\n",
        "\n",
        "# Salvar o modelo treinado em um arquivo .pkl\n",
        "filename = 'model_rossmann.pkl'\n",
        "with open(filename, 'wb') as file:\n",
        "    pickle.dump(model_xgb_tuned, file)\n",
        "\n",
        "# Fazer download do modelo diretamente para a máquina local\n",
        "files.download(filename)"
      ],
      "metadata": {
        "id": "DHC5VnRfqoyn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Saving Transformation Parameters**\n",
        "\n",
        "Além de salvaguardar o modelo em si, é essencial garantir a persistência dos **parâmetros de transformação** aplicados aos dados durante o treinamento. Essa etapa garante que, ao recebermos novos dados, possamos aplicar exatamente as mesmas transformações, mantendo a **consistência** e assegurando a integridade do processo de predição.\n",
        "\n",
        "---\n",
        "## **5.1 Normalization Techniques (Return)**\n",
        "\n",
        "A **normalização** é um passo crucial na preparação dos dados para garantir que todos os atributos estejam em uma escala comum, otimizando o desempenho dos modelos de aprendizado de máquina. Em nossa implementação, particularmente na classe `Rossmann`, utilizamos duas abordagens notáveis: o `RobustScaler` e o `MinMaxScaler`.\n",
        "\n",
        "A escolha pelo **RobustScaler** para a variável `competition_distance` é estratégica, pois essa técnica é robusta a outliers. Após aplicar essa transformação, salvamos os resultados com o auxílio do `pickle`, garantindo assim uma reutilização eficiente no futuro."
      ],
      "metadata": {
        "id": "F0j_3LkqraVk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import RobustScaler, MinMaxScaler\n",
        "from google.colab import files\n",
        "import pickle\n",
        "\n",
        "# Inicializando as instâncias de redimensionamento\n",
        "rs = RobustScaler()\n",
        "mms = MinMaxScaler()  # Este scaler não foi usado no snippet fornecido, certifique-se de que ele seja necessário.\n",
        "\n",
        "# Redimensionando a coluna 'competition_distance' utilizando o RobustScaler\n",
        "df5['competition_distance'] = rs.fit_transform(df5[['competition_distance']].values)\n",
        "\n",
        "# Salvando o scaler treinado em um arquivo usando pickle\n",
        "filename = 'encoding_competition_distance.pkl'\n",
        "with open(filename, 'wb') as file:\n",
        "    pickle.dump(rs, file)\n",
        "\n",
        "# Fazer download do scaler diretamente para a máquina local a partir do Google Colab\n",
        "files.download(filename)"
      ],
      "metadata": {
        "id": "BVRVCthHrgjy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Variable Transformation: Competition and Promotion Times (Return)**\n",
        "\n",
        "Ao tratar das variáveis `competition_time_month` e `promo_time_week`, empregamos a **transformação RobustScaler**. Esse método é especialmente valioso quando os dados contêm muitos outliers, pois ele dimensiona os dados considerando a mediana e os quartis, reduzindo a influência desses valores extremos. Após a transformação, garantimos a persistência desses dados transformados utilizando o `pickle`, permitindo um fácil carregamento e reutilização futura."
      ],
      "metadata": {
        "id": "fD628BLKrmBV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "\n",
        "# Redimensionando a coluna 'competition_time_month' utilizando o RobustScaler\n",
        "df5['competition_time_month'] = rs.fit_transform(df5[['competition_time_month']].values)\n",
        "\n",
        "# Salvando o scaler treinado da coluna 'competition_time_month' em um arquivo usando pickle\n",
        "filename_competition = 'encoding_competition_time_month.pkl'\n",
        "with open(filename_competition, 'wb') as file:\n",
        "    pickle.dump(rs, file)\n",
        "\n",
        "# Fazer download do scaler de 'competition_time_month' diretamente para a máquina local a partir do Google Colab\n",
        "files.download(filename_competition)\n",
        "\n",
        "# Redimensionando a coluna 'promo_time_week' utilizando o RobustScaler\n",
        "df5['promo_time_week'] = rs.fit_transform(df5[['promo_time_week']].values)\n",
        "\n",
        "# Salvando o scaler treinado da coluna 'promo_time_week' em um arquivo usando pickle\n",
        "filename_promo = 'encoding_promo_time_week.pkl'\n",
        "with open(filename_promo, 'wb') as file:\n",
        "    pickle.dump(rs, file)\n",
        "\n",
        "# Fazer download do scaler de 'promo_time_week' diretamente para a máquina local a partir do Google Colab\n",
        "files.download(filename_promo)"
      ],
      "metadata": {
        "id": "xbY7-DvkrnUI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Variable Transformation: Year (Return)**\n",
        "\n",
        "Ao lidar com a variável `year`, utilizamos a **transformação MinMaxScaler**. Este método é fundamental para normalizar e redimensionar os valores da variável, garantindo que todos os dados estejam na mesma escala e, assim, otimizando o desempenho dos algoritmos de aprendizado de máquina."
      ],
      "metadata": {
        "id": "r1yx-FzzrpUz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Redimensionando a coluna 'year' utilizando o MinMaxScaler\n",
        "df5['year'] = mms.fit_transform(df5[['year']].values)\n",
        "\n",
        "# Salvando o scaler treinado da coluna 'year' em um arquivo usando pickle\n",
        "filename_year = 'encoding_year.pkl'\n",
        "with open(filename_year, 'wb') as file:\n",
        "    pickle.dump(mms, file)\n",
        "\n",
        "# Fazer download do scaler de 'year' diretamente para a máquina local a partir do Google Colab\n",
        "from google.colab import files\n",
        "files.download(filename_year)"
      ],
      "metadata": {
        "id": "2lxgrn_osPFm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **5.3 Categorical Data Encoding (Return)**\n",
        "\n",
        "A etapa de **codificação** desempenha um papel fundamental na transformação de dados categóricos para um formato adequado à interpretação dos modelos de aprendizado de máquina. A natureza da variável categórica determina a técnica de codificação mais adequada. Neste projeto, adotamos três abordagens principais: `one-hot encoding`, `label encoding` e `ordinal encoding`.\n",
        "\n",
        "Em particular, para a variável `state_holiday`, empregamos o método **one-hot encoding**. Esta técnica gera colunas adicionais para cada categoria distinta da variável em análise. Os valores dessas novas colunas são binários (0 ou 1), representando se a entrada original contém ou não a respectiva categoria. Segue o trecho de código referente a este processo:"
      ],
      "metadata": {
        "id": "Wb2YeaeCsQoZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Aplicando One Hot Encoding na coluna 'state_holiday' para transformar categorias em colunas binárias\n",
        "df5 = pd.get_dummies(df5, prefix=['state_holiday'], columns=['state_holiday'])"
      ],
      "metadata": {
        "id": "xuFZr7EwtonE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Label Encoding for the 'Store Type' Variable**\n",
        "Para a variável `store_type`, empregamos a técnica de **label encoding**. Esta técnica atribui a cada categoria distinta um valor inteiro único, sendo especialmente útil quando as categorias não apresentam uma ordem definida. Para concretizar este processo, utilizamos a classe `LabelEncoder` do pacote `sklearn.preprocessing` e armazenamos o codificador para aplicações subsequentes."
      ],
      "metadata": {
        "id": "aLQ_qDxNtrLP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "import pickle\n",
        "\n",
        "# Aplicando Label Encoding na coluna 'store_type' para converter categorias em números\n",
        "le = LabelEncoder()\n",
        "df5['store_type'] = le.fit_transform(df5['store_type'])\n",
        "\n",
        "# Salvando o encoder utilizado para futuras transformações no Google Colab\n",
        "with open('/content/parameter/store_type_scaler.pkl', 'wb') as file:\n",
        "    pickle.dump(le, file)"
      ],
      "metadata": {
        "id": "1Ysyc8bGtsf0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### **Ordinal Encoding of the 'Assortment' Variable**\n",
        "\n",
        "Para a variável `assortment`, adotamos a técnica de **ordinal encoding**. Esta abordagem é particularmente relevante quando as categorias possuem uma sequência definida. Assim, cada categoria é associada a um valor inteiro específico, respeitando a ordem estabelecida."
      ],
      "metadata": {
        "id": "BmjVHsrZtv8l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Criando um dicionário para mapear os valores da coluna 'assortment' em números ordinais\n",
        "assortment_dict = {'basic':1, 'extra':2, 'extended':3}\n",
        "\n",
        "# Aplicando o mapeamento na coluna 'assortment' usando o dicionário criado\n",
        "df5['assortment'] = df5['assortment'].map(assortment_dict)"
      ],
      "metadata": {
        "id": "2CVMzCUptxd0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Com isso, finalizamos a etapa de codificação das variáveis categóricas do nosso conjunto de dados. É essencial enfatizar a **importância deste processo** para a eficácia do nosso modelo de previsão de vendas. A codificação correta permite que o modelo interprete e utilize essas variáveis de maneira otimizada."
      ],
      "metadata": {
        "id": "gqiMZUHPt0EK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **10.1 Rossmann Class**\n",
        "A **classe Rossmann** é projetada especificamente para automatizar e estruturar o processo de previsão de vendas da rede de lojas Rossmann. Esta classe centraliza as funções e métodos necessários para esse fim. Como parte de sua inicialização e operação, várias bibliotecas são importadas, garantindo que todas as ferramentas necessárias estejam disponíveis para seu funcionamento correto."
      ],
      "metadata": {
        "id": "dPw1lT2guvoy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importando as bibliotecas necessárias para o projeto\n",
        "\n",
        "# A biblioteca pickle é usada para serializar (ou seja, salvar em disco) e desserializar (ou seja, carregar do disco) objetos em Python.\n",
        "import pickle\n",
        "\n",
        "# A biblioteca inflection é usada para converter palavras do singular para o plural e vice-versa.\n",
        "import inflection\n",
        "\n",
        "# Pandas é uma biblioteca de manipulação e análise de dados.\n",
        "import pandas as pd\n",
        "\n",
        "# Numpy é uma biblioteca para operações matemáticas em arrays e matrizes multidimensionais.\n",
        "import numpy as np\n",
        "\n",
        "# Math fornece funções matemáticas definidas pelo padrão C.\n",
        "import math\n",
        "\n",
        "# Datetime é usado para manipular datas e horas.\n",
        "import datetime"
      ],
      "metadata": {
        "id": "Pdha_snzDju6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Creating the Rossmann Class:**"
      ],
      "metadata": {
        "id": "mG6sOYxdDkFq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definindo a classe Rossmann\n",
        "# Esta classe servirá como base para todas as funções e métodos relacionados ao projeto Rossmann.\n",
        "\n",
        "class Rossmann(object):\n",
        "    pass"
      ],
      "metadata": {
        "id": "5oKMSKzDDnuV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Class Inicialization Method**\n",
        "O processo de inicialização da classe é essencial para garantir a funcionalidade adequada dos modelos subsequentes. Durante esse método, diversos **modelos previamente treinados** são recuperados do disco. Estes modelos, específicos para atributos como `competition_distance`, `competition_time_month`, `promo_time_week`, `year` e `store_type`, desempenham um papel crucial para assegurar que os dados em análise sejam processados da mesma maneira que os dados utilizados durante o treinamento original."
      ],
      "metadata": {
        "id": "YZuaif7KDuXP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def __init__( self ):\n",
        "    # Definindo o caminho base para os arquivos necessários\n",
        "    self.home_path = 'repos/DataScience_Em_Producao/'\n",
        "\n",
        "    # Função auxiliar para carregar os scalers\n",
        "    def load_scaler( path ):\n",
        "        return pickle.load( open( path, 'rb' ) )\n",
        "\n",
        "    # Carregando os scalers a partir dos arquivos .pkl\n",
        "    self.competition_distance_scaler = load_scaler( self.home_path + 'parameter/competition_distance_scaler.pkl' )\n",
        "    self.competition_time_month_scaler = load_scaler( self.home_path + 'parameter/competition_time_month_scaler.pkl' )\n",
        "    self.promo_time_week_scaler = load_scaler( self.home_path + 'parameter/promo_time_week_scaler.pkl' )\n",
        "    self.year_scaler = load_scaler( self.home_path + 'parameter/year_scaler.pkl' )\n",
        "    self.store_type_scaler = load_scaler( self.home_path + 'parameter/store_type_scaler.pkl' )"
      ],
      "metadata": {
        "id": "yMso8MtCDv-2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O método em destaque serve como **inicializador** da respectiva classe. Sua principal responsabilidade é garantir que a classe esteja pronta para operar de maneira eficiente. Para isso, ele carrega todas as `ferramentas de ajuste` previamente armazenadas em arquivos. Esta etapa é crucial, ao processar novos dados, é imprescindível que eles estejam alinhados ao formato dos dados originais para treinamento do modelo."
      ],
      "metadata": {
        "id": "URitxz23Hwi_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### Data Cleaning\n",
        "O código designado como `data_cleaning` tem a missão essencial de **higienizar os dados**. Nele, as colunas são renomeadas seguindo o padrão `snakecase`, proporcionando uma padronização mais acessível e consistente. Valores ausentes não são negligenciados; ao contrário, são tratados e preenchidos de maneira adequada. Adicionalmente, verifica-se a natureza de cada dado, fazendo as devidas correções de tipo quando necessário, garantindo assim a integridade e precisão das informações."
      ],
      "metadata": {
        "id": "3uN6XR10Dx8L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def data_cleaning( self, df1 ):\n",
        "    # Renomeando colunas utilizando a convenção 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",
        "    # Conversão da coluna 'date' para o tipo de data\n",
        "    df1['date'] = pd.to_datetime( df1['date'] )\n",
        "\n",
        "    # Tratamento de valores ausentes\n",
        "    default_distance = 200000.0\n",
        "    df1['competition_distance'].fillna(default_distance, inplace=True)\n",
        "\n",
        "    # Se os valores de mês e ano de competição estiverem ausentes, preencha-os com mês e ano da data da venda\n",
        "    df1['competition_open_since_month'].fillna(df1['date'].dt.month, inplace=True)\n",
        "    df1['competition_open_since_year'].fillna(df1['date'].dt.year, inplace=True)\n",
        "\n",
        "    # Se os valores de semana e ano de promoção estiverem ausentes, preencha-os com a semana e o ano da data da venda\n",
        "    df1['promo2_since_week'].fillna(df1['date'].dt.week, inplace=True)\n",
        "    df1['promo2_since_year'].fillna(df1['date'].dt.year, inplace=True)\n",
        "\n",
        "    # Manipulação da coluna 'promo_interval'\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.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",
        "    # Conversão para int (número inteiro) em colunas específicas\n",
        "    to_int_cols = ['competition_open_since_month', 'competition_open_since_year', 'promo2_since_week', 'promo2_since_year']\n",
        "    for col in to_int_cols:\n",
        "        df1[col] = df1[col].astype(int)\n",
        "\n",
        "    return df1"
      ],
      "metadata": {
        "id": "b25X11aODzI8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O código em questão foca no aprimoramento e **limpeza do conjunto de dados**. Primeiramente, realiza a renomeação das colunas para garantir consistência e clareza. Em casos de valores ausentes, estes são substituídos por informações pertinentes, otimizando a integridade do dataset. Além disso, ocorre uma conversão para assegurar que cada dado esteja em seu tipo correto. Adicionalmente, para aprimorar a análise, são criadas novas colunas a partir das já existentes, oferecendo novas perspectivas sobre a informação."
      ],
      "metadata": {
        "id": "XKPRoRraIeKV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Feature Engineering**\n",
        "\n",
        "O método `feature_engineering` é dedicado ao aprimoramento do conjunto de dados através da **engenharia de atributos**. Ele não apenas cria, mas também modifica variáveis para maximizar seu potencial informativo. Entre os atributos gerados, temos: `year`, `month`, `day` e `week_of_year`. Adicionalmente, calcula-se o tempo decorrido desde o início de eventos significativos, como competições e promoções, com o objetivo de enriquecer o modelo para uma previsão de vendas mais precisa."
      ],
      "metadata": {
        "id": "IVxX8HOcD077"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def feature_engineering( self, df2 ):\n",
        "    # Engenharia de atributos relacionados à coluna 'date'\n",
        "    df2['year'] = df2['date'].dt.year  # Extrai o ano da coluna 'date'\n",
        "    df2['month'] = df2['date'].dt.month  # Extrai o mês da coluna 'date'\n",
        "    df2['day'] = df2['date'].dt.day  # Extrai o dia da coluna 'date'\n",
        "    df2['week_of_year'] = df2['date'].dt.isocalendar().week  # Extrai a semana do ano da coluna 'date'\n",
        "    df2['year_week'] = df2['date'].dt.strftime( '%Y-%W' )  # Formata a coluna 'date' para mostrar ano e semana\n",
        "\n",
        "    # Cálculo do tempo desde 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'])/np.timedelta64(1, 'M')).astype(int)\n",
        "\n",
        "    # Cálculo do tempo desde 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'])/np.timedelta64(1, 'W')).astype(int)\n",
        "\n",
        "    # Mapeamento dos valores da coluna 'assortment'\n",
        "    assortment_map = {'a': 'basic', 'b': 'extra', 'c': 'extended'}\n",
        "    df2['assortment'] = df2['assortment'].map(assortment_map)\n",
        "\n",
        "    # Mapeamento dos valores da coluna 'state_holiday'\n",
        "    state_holiday_map = {'a': 'public_holiday', 'b': 'easter_holiday', 'c': 'christmas', '0': 'regular_day'}\n",
        "    df2['state_holiday'] = df2['state_holiday'].map(state_holiday_map)\n",
        "\n",
        "    # Removendo os registros onde a loja estava fechada\n",
        "    df2 = df2[df2['open'] != 0]\n",
        "\n",
        "    # Eliminando colunas que não serão mais necessárias\n",
        "    df2.drop(['open', 'promo_interval', 'month_map'], axis=1, inplace=True)\n",
        "\n",
        "    return df2"
      ],
      "metadata": {
        "id": "zprINPXWD4TG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O código em questão é focado na **engenharia de recursos** do conjunto de dados. Ele não apenas gera **novas colunas** para enriquecer a análise, mas também converte valores codificados em representações mais claras e descritivas. Além disso, faz a limpeza do dataset, eliminando linhas e colunas que não contribuem significativamente para análises futuras."
      ],
      "metadata": {
        "id": "rpmxWRWSI64A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **Data Preparation**\n",
        "O método `data_preparation` é encarregado de aprimorar os dados para a etapa subsequente de previsão. Dentro de suas responsabilidades, ele **ajusta a escala de determinados dados para harmonizá-los**. Além disso, efetua a codificação de variáveis categóricas, garantindo que sejam interpretadas corretamente pelos modelos."
      ],
      "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",
        "    # Reescalando os valores\n",
        "    columns_to_scale = ['competition_distance', 'competition_time_month', 'promo_time_week', 'year']\n",
        "    scalers = [self.competition_distance_scaler, self.competition_time_month_scaler, self.promo_time_week_scaler, self.year_scaler]\n",
        "\n",
        "    for column, scaler in zip(columns_to_scale, scalers):\n",
        "        df5[column] = scaler.fit_transform(df5[[column]].values)\n",
        "\n",
        "    # Codificação das variáveis categóricas\n",
        "\n",
        "    # One Hot Encoding para 'state_holiday'\n",
        "    df5 = pd.get_dummies(df5, prefix=['state_holiday'], columns=['state_holiday'])\n",
        "\n",
        "    # Label Encoding para 'store_type'\n",
        "    df5['store_type'] = self.store_type_scaler.fit_transform(df5['store_type'])\n",
        "\n",
        "    # Ordinal Encoding para 'assortment'\n",
        "    assortment_dict = {'basic': 1, 'extra': 2, 'extended': 3}\n",
        "    df5['assortment'] = df5['assortment'].map(assortment_dict)\n",
        "\n",
        "    # Transformações cíclicas\n",
        "\n",
        "    # Função para criar características cíclicas\n",
        "    def cyclic_encode(df, col, max_val):\n",
        "        df[col + '_sin'] = np.sin(2 * np.pi * df[col]/max_val)\n",
        "        df[col + '_cos'] = np.cos(2 * np.pi * df[col]/max_val)\n",
        "        return df\n",
        "\n",
        "    # Aplicando a transformação cíclica para as colunas\n",
        "    df5 = cyclic_encode(df5, 'day_of_week', 7)\n",
        "    df5 = cyclic_encode(df5, 'month', 12)\n",
        "    df5 = cyclic_encode(df5, 'day', 30)\n",
        "    df5 = cyclic_encode(df5, 'week_of_year', 52)\n",
        "\n",
        "    # Selecionando colunas 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": [
        "---\n",
        "### **Data Preparation for Modeling**\n",
        "A função em destaque executa operações meticulosas para otimizar os dados para modelagem. **Inicialmente**, ajusta a escala de variáveis numéricas, visando uma distribuição mais homogênea. Esta etapa é vital pois uma distribuição equilibrada facilita o processamento por modelos de aprendizado de máquina.\n",
        "\n",
        "A seguir, ocorre a codificação de variáveis categóricas. Duas abordagens são adotadas: o `one-hot encoding`, que converte categorias em colunas binárias, e o `label encoding`, onde números únicos são atribuídos a cada categoria. Ambas as técnicas garantem que o modelo interprete e use corretamente estas variáveis.\n",
        "\n",
        "Ademais, a função identifica variáveis com comportamento cíclico, como dia da semana e mês. É essencial reconhecer a natureza repetitiva dessas variáveis; por exemplo, após o domingo, a semana recomeça na segunda-feira. Para preservar esta característica cíclica, são realizadas transformações adequadas, permitindo que o modelo compreenda e incorpore esse padrão.\n",
        "\n",
        "Finalmente, a função delimita as colunas que serão efetivamente incorporadas ao modelo, consolidando a preparação dos dados."
      ],
      "metadata": {
        "id": "E9djFGULJzQE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "###  **Prediction Functionality**\n",
        "O método `get_prediction` é crucial, pois emprega o modelo já treinado para gerar previsões de vendas. Estas são subsequentemente anexadas ao conjunto de dados originais, assegurando uma visualização integrada entre dados históricos e projeções."
      ],
      "metadata": {
        "id": "n8lGng4kJ03B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_prediction(self, model, original_data, test_data):\n",
        "    '''\n",
        "    Esta função realiza a previsão usando um modelo fornecido e, em seguida,\n",
        "    adiciona essas previsões aos dados originais.\n",
        "    '''\n",
        "\n",
        "    # Realiza a previsão\n",
        "    pred = model.predict(test_data)\n",
        "\n",
        "    # Junta a previsão aos dados originais\n",
        "    original_data['prediction'] = np.expm1(pred)\n",
        "\n",
        "    # Retorna os dados originais com previsões no formato JSON\n",
        "    return original_data.to_json(orient='records', date_format='iso')"
      ],
      "metadata": {
        "id": "ok9duXBLD_Z8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A função **`get_prediction`** é essencial ao projeto, pois efetua previsões com base em um modelo de aprendizado de máquina já estabelecido. O processo inicia-se com a execução dessas previsões em um conjunto de dados de teste, consolidando o resultado na variável `pred`. Após essa etapa, as previsões passam por um ajuste para se alinharem à escala original e são integradas ao conjunto de dados iniciais sob o rótulo `prediction`. Como etapa conclusiva, o DataFrame - enriquecido com os valores originais e as novas previsões - é transposto para o formato `JSON`. Esse formato, amplamente reconhecido por sua eficácia na transferência de dados, é organizado de forma que cada entrada do `JSON` representa uma linha dos dados iniciais, complementada pela respectiva previsão gerada pelo modelo."
      ],
      "metadata": {
        "id": "YsBC4jdAEBJs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **10.2 API Handler**\n",
        "No segmento da previsão de vendas, focamos na implementação de uma API para tornar nosso modelo de aprendizado de máquina pronto para uso em produção. Utilizamos `Flask`, uma biblioteca vital para desenvolver e gerenciar aplicações web. Juntamente com o `Flask`, empregamos `pickle` para acessar nosso modelo pré-treinado e `pandas` para manipular dados.\n",
        "\n",
        "A criação da nossa aplicação no Flask é realizada com `app = Flask(__name__)`. Procedemos com a definição de um endpoint, especificamente `/rossmann/predict`, que adota o método `POST`. Este endpoint é crucial para aceitar os dados e retornar as previsões do nosso modelo.\n",
        "\n",
        "Dentro da função `rossmann_predict()`, capturamos os dados na forma de JSON da solicitação. Baseado neste JSON, determinamos se contém um único exemplo ou vários, estruturando um DataFrame pandas conforme necessário. A jornada de previsão começa com a limpeza dos dados pelo método `data_cleaning()` da nossa classe Rossmann. Em seguida, recorremos à `feature_engineering()` para aprimorar as características e `data_preparation()` para organizar os dados. O desfecho é a previsão feita por `get_prediction()`, que consequentemente retorna o resultado.\n",
        "\n",
        "Se a solicitação JSON for vazia, entregamos uma resposta com status 200 e corpo desprovido, sinalizando que, apesar do sucesso na recepção, a ausência de dados impediu qualquer ação subsequente.\n",
        "\n",
        "Ao executar o script independentemente, ele ativa a aplicação Flask para monitorar solicitações na porta padrão. Em síntese, esta descrição sublinha a infraestrutura da API, otimizada para colocar nosso modelo de previsão de vendas em produção, recebendo e processando dados para retornar previsões acuradas."
      ],
      "metadata": {
        "id": "GDrJr-2zqZ9w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importação das bibliotecas\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_path = '/repos/DataScience_Em_Producao/model/model_rossmann.pkl'\n",
        "model = pickle.load(open(model_path, 'rb'))\n",
        "\n",
        "# Inicialização da aplicação Flask\n",
        "app = Flask(__name__)\n",
        "\n",
        "@app.route('/rossmann/predict', methods=['POST'])\n",
        "def rossmann_predict():\n",
        "    '''\n",
        "    Endpoint para previsão do modelo Rossmann.\n",
        "    Espera-se receber um JSON com os dados de teste.\n",
        "    Retorna as previsões no formato JSON.\n",
        "    '''\n",
        "\n",
        "    # Coleta os dados da requisição\n",
        "    test_json = request.get_json()\n",
        "\n",
        "    # Verifica se foram fornecidos dados para a previsão\n",
        "    if not test_json:\n",
        "        return Response('{}', status=200, mimetype='application/json')\n",
        "\n",
        "    # Converte o JSON para DataFrame\n",
        "    if isinstance(test_json, dict):\n",
        "        test_raw = pd.DataFrame(test_json, index=[0])\n",
        "    else:\n",
        "        test_raw = pd.DataFrame(test_json, columns=test_json[0].keys())\n",
        "\n",
        "    # Preparação e previsão usando o pipeline\n",
        "    pipeline = Rossmann()\n",
        "    df1 = pipeline.data_cleaning(test_raw)\n",
        "    df2 = pipeline.feature_engineering(df1)\n",
        "    df3 = pipeline.data_preparation(df2)\n",
        "    df_response = pipeline.get_prediction(model, test_raw, df3)\n",
        "\n",
        "    return df_response\n",
        "\n",
        "# Ponto de entrada da aplicação\n",
        "if __name__ == '__main__':\n",
        "    app.run(host='0.0.0.0')"
      ],
      "metadata": {
        "id": "i0wqciaYhalo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### **10.3 API Tester**\n",
        "Para disponibilizar nosso modelo, desenvolvemos uma `API` usando o `Flask`, uma renomada biblioteca `Python` voltada para aplicações web. Esta API não só recebe entradas de dados, mas também processa-os pelo modelo e, consequentemente, retorna as previsões.\n",
        "\n",
        "Para validar a eficácia da nossa API, empregamos um conjunto de dados que o modelo nunca analisou. Esse conjunto simula informações novas, replicando cenários reais que o modelo enfrentará. Para gerar uma previsão corretamente, é essencial estruturar um dataframe com as mesmas colunas utilizadas durante o treinamento do modelo."
      ],
      "metadata": {
        "id": "ojg-3rayqf_7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importação das bibliotecas necessárias\n",
        "import pandas as pd\n",
        "import json\n",
        "import requests\n",
        "from google.colab import files\n",
        "\n",
        "# Carregar o conjunto de dados de teste e o conjunto de dados da loja diretamente do Google Colab\n",
        "uploaded = files.upload()\n",
        "df10 = pd.read_csv('test.csv')\n",
        "df_store_raw = pd.read_csv('store.csv')\n",
        "\n",
        "# Realizar a combinação (merge) dos conjuntos de dados\n",
        "df_test = pd.merge(df10, df_store_raw, how='left', on='Store')\n",
        "\n",
        "# Selecione uma loja específica para previsão\n",
        "df_test = df_test[df_test['Store'] == 22]\n",
        "\n",
        "# Remova os registros onde a loja estava fechada\n",
        "df_test = df_test[df_test['Open'] != 0]\n",
        "df_test = df_test.dropna(subset=['Open'])\n",
        "df_test = df_test.drop('Id', axis=1)\n",
        "\n",
        "# Converta o dataframe para o formato json\n",
        "data = json.dumps(df_test.to_dict(orient='records'))\n",
        "\n",
        "# Faça uma requisição para a API\n",
        "url = 'http://0.0.0.0:5000/rossmann/predict'\n",
        "headers = {'Content-type': 'application/json'}\n",
        "response = requests.post(url, data=data, headers=headers)\n",
        "\n",
        "# Exiba as previsões\n",
        "results = pd.DataFrame(response.json(), columns=response.json()[0].keys())\n",
        "aggregated_results = results[['store', 'prediction']].groupby('store').sum().reset_index()\n",
        "for idx, row in aggregated_results.iterrows():\n",
        "    print(f\"A loja número {row['store']} venderá R${row['prediction']:,.2f} nas próximas 6 semanas.\")"
      ],
      "metadata": {
        "id": "KasZZ0ua27Hw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **API Testing for Sales Forecasting**\n",
        "\n",
        "To ensure effective use of the API in our sales forecasting project, we start by loading the test data and the specific store information. Combining these datasets provides a consolidated dataframe. For efficiency, predictions are made specifically for **one store** and days when the store was closed are excluded. This dataframe is then converted into a `JSON` format, making it suitable for transmission via the API. A call is made to the API using the `POST` method, embedding the data within the request body. Subsequently, the API provides the predictions which are promptly displayed.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "R6O8NLRImiis"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Implementing a Sales Forecast Model on Heroku**\n",
        "A implementação de um modelo de previsão de vendas no Heroku exige passos específicos e detalhados:\n",
        "\n",
        "1. **Preparação do Ambiente**: Após se registrar no Heroku, é crucial instalar o `cliente Heroku`. Este cliente viabiliza a comunicação com a plataforma via terminal. O comando de instalação varia conforme o sistema operacional. Após concluída a instalação, autentique-se no Heroku usando `heroku login`.\n",
        "\n",
        "2. **Configuração para Deploy**: Três arquivos são fundamentais para a publicação do modelo:\n",
        "  - `Procfile`: Define o comando que o Heroku invoca para iniciar a API.\n",
        "  - `requirements.txt`: Enumera as bibliotecas empregadas no projeto. Pode ser gerado com `pip freeze > requirements.txt`.\n",
        "  - O diretório do projeto deve ser inicializado como um repositório Git, utilizando `git init`.\n",
        "\n",
        "3. **Publicação do Modelo**: A sequência de comandos Git prepara e envia seu modelo para o Heroku:\n",
        "  - Verifique os arquivos com `git status`.\n",
        "  - Adicione os arquivos via `git add .`.\n",
        "  - Efetue o registro das alterações com `git commit -m \"primeiro commit\"`.\n",
        "  - Finalmente, utilize `git push heroku master` para enviar o modelo ao Heroku.\n",
        "\n",
        "4. **Criação da Aplicação no Heroku**: Antes do envio, crie a aplicação no Heroku usando `heroku apps:create nome_da_aplicacao`, onde 'nome_da_aplicacao' é substituído pelo nome que desejar.\n",
        "\n",
        "5. **Verificação da Aplicação**: Uma vez criada, a aplicação estará acessível em sua conta Heroku. Os registros podem ser acessados selecionando 'more', seguido por 'view logs'.\n",
        "\n",
        "6. **Envio dos Arquivos ao Heroku**: Com a aplicação já estabelecida, use `git push heroku master`. O Heroku processará os arquivos, instalará as dependências do `requirements.txt` e acionará o comando do `Procfile`.\n",
        "\n",
        "7. **Teste da Aplicação**: Com a aplicação pronta, substitua a URL local pela URL do Heroku em seu arquivo Jupyter para testá-la.\n",
        "\n",
        "8. **Realização de Requisições**: Uma vez hospedada, sua aplicação pode atender requisições de diversos lugares, seja via notebook ou ferramentas como Postman ou Telegram.\n",
        "\n",
        "9. **Monitoramento de Recursos**: Na versão gratuita do Heroku, há um teto de 500MB. Monitorar o consumo é vital para evitar exceder este limite.\n",
        "\n",
        "Com a finalização destes passos, sua aplicação estará plenamente operante no Heroku, permitindo previsões de vendas de qualquer lugar com conectividade à web. Note que essas diretrizes são genéricas e ajustes podem ser necessários conforme o projeto em questão."
      ],
      "metadata": {
        "id": "U4IQwzr5mofx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **12. Sales Forecasting with Telegram Bot**\n",
        "Este projeto visou a criação de um modelo de previsão de vendas, tornando-o acessível através de um bot no Telegram. **O modelo, hospedado na plataforma Heroku**, serve como um meio eficaz para gerentes de lojas acessarem projeções de vendas para planejamentos futuros.\n",
        "\n",
        "A construção técnica de um modelo é apenas uma etapa de um projeto de ciência de dados. A verdadeira relevância surge ao disponibilizar seus resultados de maneira intuitiva para os usuários. O bot do Telegram cumpre esse propósito, proporcionando **acesso instantâneo às previsões** em qualquer dispositivo.\n",
        "\n",
        "O desenvolvimento deste projeto seguiu um fluxo lógico e estruturado:\n",
        "\n",
        "- **Identificação da questão de negócio**: Os gerentes necessitavam de previsões claras para as próximas seis semanas.\n",
        "- **Entendimento do negócio**: A ausência de uma visão clara sobre as receitas futuras comprometia decisões estratégicas, como planejamentos de reformas.\n",
        "- **Coleta e preparação de dados**: Obtidos em formato CSV, os dados passaram por limpeza e tratamento, garantindo sua qualidade para análise.\n",
        "- **Análise exploratória (EDA)**: Uma inspeção minuciosa permitiu a compreensão das variáveis e a validação de hipóteses.\n",
        "- **Modelagem e avaliação**: Diversos algoritmos foram testados, culminando em um modelo com desempenho satisfatório.\n",
        "\n",
        "Após essas etapas, o modelo foi implantado no **Heroku**, e o bot do Telegram foi desenvolvido para interface com os usuários. Este bot, ao receber a solicitação, consulta o modelo hospedado e retorna a previsão desejada.\n",
        "\n",
        "Atualmente, focamos em refinar a interação com o bot, permitindo que os usuários solicitem previsões para lojas específicas. Com essa evolução, a previsão de vendas se tornará acessível a partir de qualquer dispositivo.\n",
        "\n",
        "Em síntese, este projeto reforça como a ciência de dados, quando aplicada corretamente, pode gerar valor tangível ao negócio, indo além de meras teorias.\n",
        "\n",
        "### **Creating the Rossmann API**\n",
        "\n",
        "O processo se inicia com a configuração do ambiente de desenvolvimento. Após definir o diretório do projeto e ativar o ambiente virtual, um arquivo chamado `rossmann-bot.py` é criado para codificação.\n",
        "\n",
        "A sequência de código prioriza a **carga e processamento dos dados de teste**. Utilizando `Pandas` e `JSON`, os conjuntos de dados são carregados, mesclados e filtrados, garantindo que apenas lojas abertas e informações relevantes sejam consideradas. Estes dados, então, são convertidos para o formato JSON, preparando-os para uma chamada de API.\n",
        "\n",
        "A resposta da API é processada e as previsões são consolidadas, proporcionando uma visão clara das vendas futuras por loja. A modularidade do código e encapsulamento em funções assegura facilidade de manutenção e extensão.\n",
        "\n",
        "É fundamental notar que o modelo, acessível via API no **Heroku**, pode ocasionalmente entrar em modo de espera, mas se reativa prontamente ao receber uma nova solicitação.\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "Y9Xb76Kfw36C"
      }
    }
  ]
}