Forecast_12_Taxa_de_Indimplencia.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "     \n",
    "     O código é um exemplo de como implementar um modelo de previsão de séries temporais utilizando redes neurais recorrentes LSTM. A ideia do modelo é utilizarmos os dados históricos da taxa de inadimplência para prever a taxa de inadimplência dos próximos 12 meses. Para isso, realizamos diversas etapas de pré-processamento, tais como normalização dos valores, divisão dos dados em treino e teste, criação de conjuntos de dados para treinamento e teste, e remodelagem dos dados em três tipos de modelos diferentes um LSTM, um de Alisamento Exponencial e um Ensemble - que calcula a média de resultado dos dois anteriores.\n",
    "\n",
    "     Após a construção do modelo, as previsões são feitas e, em seguida, calculamos o erro médio quadrático (MSE) e o erro médio absoluto (MAE) para avaliar o desempenho do modelos. Quando essas métricas são baixas, significa que o modelo está produzindo previsões precisas e próximas dos valores reais. Isso indica que o modelo está aprendendo padrões importantes na série temporal e é capaz de generalizar bem para novos dados. Portanto, um MSE e MAE baixos são indícios de que um modelo de previsão de séries temporais é robusto e confiável. **Os resultados dos modelos sugerem que a melhor opção de forecast final é o modelo LSTM** capaz de capturar os padrões da série temporal e, portanto, é um modelo adequado para o forecast da taxa de inadimplência. \n",
    "     \n",
    "     Quanto aos principais drivers desses valores, pode-se considerar fatores macroeconômicos, tais como a taxa de juros, a inflação e o desemprego, bem como fatores específicos do setor, como a concessão de crédito, a situação financeira das empresas e o perfil dos consumidores."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Importar Libs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importar Libs\n",
    "\n",
    "import requests\n",
    "import json\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from statsmodels.tsa.holtwinters import ExponentialSmoothing\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, LSTM"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Carregar dados\n",
    "url = \"https://api.bcb.gov.br/dados/serie/bcdata.sgs.21082/dados?formato=json\"\n",
    "response = requests.get(url)\n",
    "data = json.loads(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Preparar dados\n",
    "df = pd.DataFrame(data)\n",
    "df['data'] = pd.to_datetime(df['data'], dayfirst=True)\n",
    "df['valor'] = df['valor'].astype(float)\n",
    "df.set_index('data', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalizar dados\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "scaled_data = scaler.fit_transform(df.values)\n",
    "\n",
    "# Dividir dados em treino e teste\n",
    "train_size = int(len(scaled_data) * 0.9)\n",
    "train, test = scaled_data[:train_size], scaled_data[train_size:]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Split Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função para criar conjuntos de dados para treinamento e teste\n",
    "def create_dataset(dataset, look_back=1):\n",
    "    X, Y = [], []\n",
    "    for i in range(len(dataset) - look_back):\n",
    "        X.append(dataset[i:i + look_back, 0])\n",
    "        Y.append(dataset[i + look_back, 0])\n",
    "    return np.array(X), np.array(Y)\n",
    "\n",
    "# Criar conjuntos de dados para treinamento e teste\n",
    "look_back = 1\n",
    "X_train, Y_train = create_dataset(train, look_back)\n",
    "X_test, Y_test = create_dataset(test, look_back)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remodelar a entrada para ser [amostras, etapas de tempo, características]\n",
    "X_train = np.reshape(X_train, (X_train.shape[0], 1, X_train.shape[1]))\n",
    "X_test = np.reshape(X_test, (X_test.shape[0], 1, X_test.shape[1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Train Model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Neural LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "128/128 - 4s - loss: 0.1813 - 4s/epoch - 30ms/step\n",
      "Epoch 2/100\n",
      "128/128 - 0s - loss: 0.0475 - 282ms/epoch - 2ms/step\n",
      "Epoch 3/100\n",
      "128/128 - 0s - loss: 0.0228 - 275ms/epoch - 2ms/step\n",
      "Epoch 4/100\n",
      "128/128 - 0s - loss: 0.0191 - 328ms/epoch - 3ms/step\n",
      "Epoch 5/100\n",
      "128/128 - 0s - loss: 0.0165 - 466ms/epoch - 4ms/step\n",
      "Epoch 6/100\n",
      "128/128 - 0s - loss: 0.0139 - 367ms/epoch - 3ms/step\n",
      "Epoch 7/100\n",
      "128/128 - 0s - loss: 0.0115 - 342ms/epoch - 3ms/step\n",
      "Epoch 8/100\n",
      "128/128 - 0s - loss: 0.0095 - 475ms/epoch - 4ms/step\n",
      "Epoch 9/100\n",
      "128/128 - 0s - loss: 0.0076 - 318ms/epoch - 2ms/step\n",
      "Epoch 10/100\n",
      "128/128 - 0s - loss: 0.0063 - 264ms/epoch - 2ms/step\n",
      "Epoch 11/100\n",
      "128/128 - 0s - loss: 0.0052 - 326ms/epoch - 3ms/step\n",
      "Epoch 12/100\n",
      "128/128 - 0s - loss: 0.0043 - 382ms/epoch - 3ms/step\n",
      "Epoch 13/100\n",
      "128/128 - 0s - loss: 0.0037 - 329ms/epoch - 3ms/step\n",
      "Epoch 14/100\n",
      "128/128 - 0s - loss: 0.0033 - 334ms/epoch - 3ms/step\n",
      "Epoch 15/100\n",
      "128/128 - 0s - loss: 0.0031 - 384ms/epoch - 3ms/step\n",
      "Epoch 16/100\n",
      "128/128 - 0s - loss: 0.0029 - 255ms/epoch - 2ms/step\n",
      "Epoch 17/100\n",
      "128/128 - 0s - loss: 0.0029 - 277ms/epoch - 2ms/step\n",
      "Epoch 18/100\n",
      "128/128 - 0s - loss: 0.0028 - 256ms/epoch - 2ms/step\n",
      "Epoch 19/100\n",
      "128/128 - 0s - loss: 0.0028 - 343ms/epoch - 3ms/step\n",
      "Epoch 20/100\n",
      "128/128 - 0s - loss: 0.0028 - 247ms/epoch - 2ms/step\n",
      "Epoch 21/100\n",
      "128/128 - 0s - loss: 0.0028 - 278ms/epoch - 2ms/step\n",
      "Epoch 22/100\n",
      "128/128 - 0s - loss: 0.0028 - 343ms/epoch - 3ms/step\n",
      "Epoch 23/100\n",
      "128/128 - 0s - loss: 0.0028 - 294ms/epoch - 2ms/step\n",
      "Epoch 24/100\n",
      "128/128 - 0s - loss: 0.0028 - 328ms/epoch - 3ms/step\n",
      "Epoch 25/100\n",
      "128/128 - 0s - loss: 0.0027 - 309ms/epoch - 2ms/step\n",
      "Epoch 26/100\n",
      "128/128 - 0s - loss: 0.0028 - 373ms/epoch - 3ms/step\n",
      "Epoch 27/100\n",
      "128/128 - 0s - loss: 0.0027 - 316ms/epoch - 2ms/step\n",
      "Epoch 28/100\n",
      "128/128 - 0s - loss: 0.0027 - 391ms/epoch - 3ms/step\n",
      "Epoch 29/100\n",
      "128/128 - 0s - loss: 0.0030 - 366ms/epoch - 3ms/step\n",
      "Epoch 30/100\n",
      "128/128 - 0s - loss: 0.0029 - 352ms/epoch - 3ms/step\n",
      "Epoch 31/100\n",
      "128/128 - 0s - loss: 0.0027 - 316ms/epoch - 2ms/step\n",
      "Epoch 32/100\n",
      "128/128 - 0s - loss: 0.0028 - 313ms/epoch - 2ms/step\n",
      "Epoch 33/100\n",
      "128/128 - 0s - loss: 0.0028 - 456ms/epoch - 4ms/step\n",
      "Epoch 34/100\n",
      "128/128 - 0s - loss: 0.0027 - 339ms/epoch - 3ms/step\n",
      "Epoch 35/100\n",
      "128/128 - 0s - loss: 0.0027 - 452ms/epoch - 4ms/step\n",
      "Epoch 36/100\n",
      "128/128 - 0s - loss: 0.0028 - 479ms/epoch - 4ms/step\n",
      "Epoch 37/100\n",
      "128/128 - 0s - loss: 0.0027 - 334ms/epoch - 3ms/step\n",
      "Epoch 38/100\n",
      "128/128 - 0s - loss: 0.0028 - 414ms/epoch - 3ms/step\n",
      "Epoch 39/100\n",
      "128/128 - 0s - loss: 0.0027 - 362ms/epoch - 3ms/step\n",
      "Epoch 40/100\n",
      "128/128 - 0s - loss: 0.0027 - 378ms/epoch - 3ms/step\n",
      "Epoch 41/100\n",
      "128/128 - 1s - loss: 0.0027 - 515ms/epoch - 4ms/step\n",
      "Epoch 42/100\n",
      "128/128 - 0s - loss: 0.0029 - 421ms/epoch - 3ms/step\n",
      "Epoch 43/100\n",
      "128/128 - 0s - loss: 0.0027 - 406ms/epoch - 3ms/step\n",
      "Epoch 44/100\n",
      "128/128 - 0s - loss: 0.0027 - 299ms/epoch - 2ms/step\n",
      "Epoch 45/100\n",
      "128/128 - 0s - loss: 0.0028 - 365ms/epoch - 3ms/step\n",
      "Epoch 46/100\n",
      "128/128 - 0s - loss: 0.0029 - 415ms/epoch - 3ms/step\n",
      "Epoch 47/100\n",
      "128/128 - 0s - loss: 0.0024 - 367ms/epoch - 3ms/step\n",
      "Epoch 48/100\n",
      "128/128 - 0s - loss: 0.0028 - 308ms/epoch - 2ms/step\n",
      "Epoch 49/100\n",
      "128/128 - 0s - loss: 0.0027 - 333ms/epoch - 3ms/step\n",
      "Epoch 50/100\n",
      "128/128 - 0s - loss: 0.0027 - 374ms/epoch - 3ms/step\n",
      "Epoch 51/100\n",
      "128/128 - 0s - loss: 0.0027 - 334ms/epoch - 3ms/step\n",
      "Epoch 52/100\n",
      "128/128 - 0s - loss: 0.0027 - 236ms/epoch - 2ms/step\n",
      "Epoch 53/100\n",
      "128/128 - 0s - loss: 0.0028 - 353ms/epoch - 3ms/step\n",
      "Epoch 54/100\n",
      "128/128 - 0s - loss: 0.0027 - 265ms/epoch - 2ms/step\n",
      "Epoch 55/100\n",
      "128/128 - 0s - loss: 0.0027 - 336ms/epoch - 3ms/step\n",
      "Epoch 56/100\n",
      "128/128 - 0s - loss: 0.0027 - 300ms/epoch - 2ms/step\n",
      "Epoch 57/100\n",
      "128/128 - 0s - loss: 0.0028 - 357ms/epoch - 3ms/step\n",
      "Epoch 58/100\n",
      "128/128 - 0s - loss: 0.0027 - 293ms/epoch - 2ms/step\n",
      "Epoch 59/100\n",
      "128/128 - 0s - loss: 0.0027 - 329ms/epoch - 3ms/step\n",
      "Epoch 60/100\n",
      "128/128 - 0s - loss: 0.0027 - 385ms/epoch - 3ms/step\n",
      "Epoch 61/100\n",
      "128/128 - 0s - loss: 0.0027 - 290ms/epoch - 2ms/step\n",
      "Epoch 62/100\n",
      "128/128 - 0s - loss: 0.0027 - 289ms/epoch - 2ms/step\n",
      "Epoch 63/100\n",
      "128/128 - 0s - loss: 0.0028 - 284ms/epoch - 2ms/step\n",
      "Epoch 64/100\n",
      "128/128 - 0s - loss: 0.0028 - 379ms/epoch - 3ms/step\n",
      "Epoch 65/100\n",
      "128/128 - 0s - loss: 0.0026 - 272ms/epoch - 2ms/step\n",
      "Epoch 66/100\n",
      "128/128 - 0s - loss: 0.0027 - 387ms/epoch - 3ms/step\n",
      "Epoch 67/100\n",
      "128/128 - 1s - loss: 0.0027 - 540ms/epoch - 4ms/step\n",
      "Epoch 68/100\n",
      "128/128 - 0s - loss: 0.0027 - 370ms/epoch - 3ms/step\n",
      "Epoch 69/100\n",
      "128/128 - 0s - loss: 0.0026 - 343ms/epoch - 3ms/step\n",
      "Epoch 70/100\n",
      "128/128 - 1s - loss: 0.0026 - 506ms/epoch - 4ms/step\n",
      "Epoch 71/100\n",
      "128/128 - 0s - loss: 0.0029 - 326ms/epoch - 3ms/step\n",
      "Epoch 72/100\n",
      "128/128 - 0s - loss: 0.0028 - 288ms/epoch - 2ms/step\n",
      "Epoch 73/100\n",
      "128/128 - 0s - loss: 0.0027 - 301ms/epoch - 2ms/step\n",
      "Epoch 74/100\n",
      "128/128 - 0s - loss: 0.0027 - 415ms/epoch - 3ms/step\n",
      "Epoch 75/100\n",
      "128/128 - 0s - loss: 0.0028 - 302ms/epoch - 2ms/step\n",
      "Epoch 76/100\n",
      "128/128 - 0s - loss: 0.0027 - 351ms/epoch - 3ms/step\n",
      "Epoch 77/100\n",
      "128/128 - 0s - loss: 0.0028 - 324ms/epoch - 3ms/step\n",
      "Epoch 78/100\n",
      "128/128 - 0s - loss: 0.0027 - 312ms/epoch - 2ms/step\n",
      "Epoch 79/100\n",
      "128/128 - 0s - loss: 0.0026 - 248ms/epoch - 2ms/step\n",
      "Epoch 80/100\n",
      "128/128 - 0s - loss: 0.0027 - 332ms/epoch - 3ms/step\n",
      "Epoch 81/100\n",
      "128/128 - 0s - loss: 0.0027 - 366ms/epoch - 3ms/step\n",
      "Epoch 82/100\n",
      "128/128 - 0s - loss: 0.0028 - 272ms/epoch - 2ms/step\n",
      "Epoch 83/100\n",
      "128/128 - 0s - loss: 0.0027 - 272ms/epoch - 2ms/step\n",
      "Epoch 84/100\n",
      "128/128 - 0s - loss: 0.0027 - 291ms/epoch - 2ms/step\n",
      "Epoch 85/100\n",
      "128/128 - 0s - loss: 0.0027 - 411ms/epoch - 3ms/step\n",
      "Epoch 86/100\n",
      "128/128 - 0s - loss: 0.0027 - 277ms/epoch - 2ms/step\n",
      "Epoch 87/100\n",
      "128/128 - 0s - loss: 0.0026 - 314ms/epoch - 2ms/step\n",
      "Epoch 88/100\n",
      "128/128 - 0s - loss: 0.0027 - 374ms/epoch - 3ms/step\n",
      "Epoch 89/100\n",
      "128/128 - 0s - loss: 0.0027 - 293ms/epoch - 2ms/step\n",
      "Epoch 90/100\n",
      "128/128 - 0s - loss: 0.0027 - 263ms/epoch - 2ms/step\n",
      "Epoch 91/100\n",
      "128/128 - 0s - loss: 0.0027 - 266ms/epoch - 2ms/step\n",
      "Epoch 92/100\n",
      "128/128 - 0s - loss: 0.0027 - 346ms/epoch - 3ms/step\n",
      "Epoch 93/100\n",
      "128/128 - 0s - loss: 0.0027 - 266ms/epoch - 2ms/step\n",
      "Epoch 94/100\n",
      "128/128 - 0s - loss: 0.0027 - 275ms/epoch - 2ms/step\n",
      "Epoch 95/100\n",
      "128/128 - 0s - loss: 0.0027 - 288ms/epoch - 2ms/step\n",
      "Epoch 96/100\n",
      "128/128 - 0s - loss: 0.0026 - 442ms/epoch - 3ms/step\n",
      "Epoch 97/100\n",
      "128/128 - 0s - loss: 0.0028 - 291ms/epoch - 2ms/step\n",
      "Epoch 98/100\n",
      "128/128 - 0s - loss: 0.0027 - 277ms/epoch - 2ms/step\n",
      "Epoch 99/100\n",
      "128/128 - 0s - loss: 0.0028 - 346ms/epoch - 3ms/step\n",
      "Epoch 100/100\n",
      "128/128 - 0s - loss: 0.0027 - 344ms/epoch - 3ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x24f1b3e4a60>"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Criar e treinar a rede LSTM\n",
    "model = Sequential()\n",
    "model.add(LSTM(4, input_shape=(1, look_back)))\n",
    "model.add(Dense(1))\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "model.fit(X_train, Y_train, epochs=100, batch_size=1, verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4/4 [==============================] - 1s 3ms/step\n",
      "1/1 [==============================] - 1s 655ms/step\n"
     ]
    }
   ],
   "source": [
    "# Fazer previsões\n",
    "train_predict = model.predict(X_train)\n",
    "test_predict = model.predict(X_test)\n",
    "\n",
    "# Inverter previsões\n",
    "train_predict = scaler.inverse_transform(train_predict)\n",
    "Y_train = scaler.inverse_transform([Y_train])\n",
    "test_predict = scaler.inverse_transform(test_predict)\n",
    "Y_test = scaler.inverse_transform([Y_test])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Previsões para os próximos 12 meses (LSTM):\n",
      "Mês 1: 2.29\n",
      "Mês 2: 2.44\n",
      "Mês 3: 2.49\n",
      "Mês 4: 2.58\n",
      "Mês 5: 2.64\n",
      "Mês 6: 2.71\n",
      "Mês 7: 2.64\n",
      "Mês 8: 2.76\n",
      "Mês 9: 2.81\n",
      "Mês 10: 2.83\n",
      "Mês 11: 2.96\n",
      "Mês 12: 3.00\n"
     ]
    }
   ],
   "source": [
    "# Exibir previsões para os próximos 12 meses (LSTM)\n",
    "print(\"Previsões para os próximos 12 meses (LSTM):\")\n",
    "for i, prediction in enumerate(test_predict[:12, 0]):\n",
    "    print(f\"Mês {i + 1}: {prediction:.2f}\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Alisamento Exponencial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\MateusDeNadaiLofrano\\anaconda3\\lib\\site-packages\\statsmodels\\tsa\\base\\tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency MS will be used.\n",
      "  self._init_dates(dates, freq)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 31ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 29ms/step\n",
      "1/1 [==============================] - 0s 33ms/step\n",
      "1/1 [==============================] - 0s 38ms/step\n",
      "1/1 [==============================] - 0s 46ms/step\n",
      "1/1 [==============================] - 0s 41ms/step\n",
      "1/1 [==============================] - 0s 88ms/step\n",
      "1/1 [==============================] - 0s 47ms/step\n",
      "1/1 [==============================] - 0s 40ms/step\n",
      "1/1 [==============================] - 0s 42ms/step\n",
      "1/1 [==============================] - 0s 54ms/step\n"
     ]
    }
   ],
   "source": [
    "# Alisamento Exponencial\n",
    "hw_model = ExponentialSmoothing(df.iloc[:train_size, 0], seasonal_periods=12, trend='add', seasonal='multiplicative').fit()\n",
    "hw_pred = hw_model.forecast(12)\n",
    "\n",
    "# Prever os próximos 12 meses usando LSTM e Alisamento Exponencial\n",
    "future_steps = 12\n",
    "last_train_value = train[-1]\n",
    "predictions = []\n",
    "\n",
    "for i in range(future_steps):\n",
    "    x_input = np.array([last_train_value]).reshape((1, 1, 1))\n",
    "    lstm_pred = model.predict(x_input)\n",
    "    last_train_value = lstm_pred\n",
    "    lstm_pred = scaler.inverse_transform(lstm_pred)\n",
    "    hw_pred_i = hw_pred[i] if i < len(hw_pred) else hw_pred[-1]\n",
    "    ensemble_pred = (lstm_pred[0][0] + hw_pred_i) / 2\n",
    "    predictions.append(ensemble_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Previsões para os próximos 12 meses (Alisamento Exponencial):\n",
      "Mês 1: 2.25\n",
      "Mês 2: 2.31\n",
      "Mês 3: 2.35\n",
      "Mês 4: 2.37\n",
      "Mês 5: 2.44\n",
      "Mês 6: 2.49\n",
      "Mês 7: 2.38\n",
      "Mês 8: 2.41\n",
      "Mês 9: 2.43\n",
      "Mês 10: 2.43\n",
      "Mês 11: 2.47\n",
      "Mês 12: 2.45\n"
     ]
    }
   ],
   "source": [
    "# Exibir previsões para os próximos 12 meses (Alisamento Exponencial)\n",
    "print(\"Previsões para os próximos 12 meses (Alisamento Exponencial):\")\n",
    "for i, prediction in enumerate(hw_pred):\n",
    "    print(f\"Mês {i + 1}: {prediction:.2f}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Previsões para os próximos 12 meses (LSTM + Alisamento Exponencial):\n",
      "Mes 1: 2.28\n",
      "Mes 2: 2.30\n",
      "Mes 3: 2.32\n",
      "Mes 4: 2.32\n",
      "Mes 5: 2.36\n",
      "Mes 6: 2.38\n",
      "Mes 7: 2.32\n",
      "Mes 8: 2.33\n",
      "Mes 9: 2.34\n",
      "Mes 10: 2.34\n",
      "Mes 11: 2.36\n",
      "Mes 12: 2.35\n"
     ]
    }
   ],
   "source": [
    "# Exibir previsões para os próximos 12 meses\n",
    "print(\"Previsões para os próximos 12 meses (LSTM + Alisamento Exponencial):\")\n",
    "for i, prediction in enumerate(predictions):\n",
    "    print(f\"Mes {i + 1}: {prediction:.2f}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Avaliação do Forecast"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\t Abaixo calculamos as métricas de erro dos modelos. No caso de séries temporais utilizamos o cálculo do MSE, ou erro médio quadrático, e MAE, ou erro médio absoluto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import mean_squared_error, mean_absolute_error\n",
    "\n",
    "# Calcular o erro para o modelo LSTM\n",
    "mse_lstm = mean_squared_error(Y_test[0], test_predict[:,0])\n",
    "mae_lstm = mean_absolute_error(Y_test[0], test_predict[:,0])\n",
    "\n",
    "# Calcular o erro para o modelo de Alisamento Exponencial\n",
    "mse_hw = mean_squared_error(df.iloc[train_size:train_size + 12, 0], hw_pred)\n",
    "mae_hw = mean_absolute_error(df.iloc[train_size:train_size + 12, 0], hw_pred)\n",
    "\n",
    "# Calcular o erro para o ensemble (LSTM + Alisamento Exponencial)\n",
    "ensemble_pred = np.array([(test_predict[i, 0] + hw_pred[i]) / 2 for i in range(len(hw_pred))])\n",
    "mse_ensemble = mean_squared_error(df.iloc[train_size:train_size + 12, 0], ensemble_pred)\n",
    "mae_ensemble = mean_absolute_error(df.iloc[train_size:train_size + 12, 0], ensemble_pred)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE - LSTM: 0.0112, Alisamento Exponencial: 0.1102, Ensemble (LSTM + Alisamento Exponencial): 0.0300\n",
      "MAE - LSTM: 0.0942, Alisamento Exponencial: 0.2980, Ensemble (LSTM + Alisamento Exponencial): 0.1568\n"
     ]
    }
   ],
   "source": [
    "# Imprimir os erros para os três modelos\n",
    "print(f\"MSE - LSTM: {mse_lstm:.4f}, Alisamento Exponencial: {mse_hw:.4f}, Ensemble (LSTM + Alisamento Exponencial): {mse_ensemble:.4f}\")\n",
    "print(f\"MAE - LSTM: {mae_lstm:.4f}, Alisamento Exponencial: {mae_hw:.4f}, Ensemble (LSTM + Alisamento Exponencial): {mae_ensemble:.4f}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "     Um MSE menor indica um melhor ajuste do modelo. Neste caso, no modelo que obteve o menor resultado foi o LSTM . Da mesma maneira, um MAE menor também indica uma boa aderência do modelo, ou seja que em média nossas previsões estão desviando o valor de *MAE - LSTM* em relação aos valores reais. Realizado o cálculo das métricas pode-se considerar que o modelo com melhor resultado foi o de LSTM, sendo assim considerado nosso forecast final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Preparar os dados para o gráfico\n",
    "lstm_predictions = test_predict[:12, 0]\n",
    "\n",
    "# Criar o gráfico\n",
    "x_labels = np.arange(1, 13, 1)\n",
    "\n",
    "real_data = df.iloc[train_size:train_size + 12, 0]\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(x_labels, real_data, label=\"Dados Reais\", marker='o')\n",
    "plt.plot(x_labels, lstm_predictions, label=\"Previsões LSTM\", marker='x')\n",
    "plt.xlabel(\"Meses\")\n",
    "plt.ylabel(\"Taxa de Inadimplência\")\n",
    "plt.title(\"Taxa de Inadimplência - Dados Reais vs Previsões LSTM\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}