previsao_indicadores_ver1.1_normalizacao_por_partes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\python\\tf_test\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as sp\n",
    "from sklearn.preprocessing  import MinMaxScaler,StandardScaler\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error\n",
    "import keras.backend as K\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.optimizers import Adam\n",
    "from keras.callbacks import EarlyStopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def configuraConjuntoInicial(caminhoArquivo=None,colunas=None):\n",
    "    if caminhoArquivo is None:\n",
    "        caminhoArquivo = 'DECFEC_light_2000_2017.csv'\n",
    "    dataSet = pd.read_csv(caminhoArquivo)\n",
    "    # mes_normalizado = np.array([float(i.split(\"-\")[1])/12 for i in dataSet.index])\n",
    "    # dataSet['Data'] = pd.to_datetime(dataSet[\"Data\"])\n",
    "    dataSet = dataSet.set_index([\"Data\"])\n",
    "    if colunas is not None:\n",
    "        dataSet = dataSet[colunas]\n",
    "    return dataSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def separaConjuntosDeTreinoETeste(conjunto, dataReferencia=None):\n",
    "    \n",
    "    if dataReferencia is None:\n",
    "        dataReferencia = '2016-01-01'\n",
    "    conjuntoTreino = conjunto[:dataReferencia]\n",
    "    conjuntoTreino = conjuntoTreino[:-1]\n",
    "    conjuntoTeste = conjunto[dataReferencia:]\n",
    "    return conjuntoTreino,conjuntoTeste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalizaConjunto(conjunto):\n",
    "    \n",
    "    scaler = MinMaxScaler()\n",
    "    colunasConjunto = [i for i in conjunto]\n",
    "    conjuntoNormalizado = scaler.fit_transform(pd.DataFrame(conjunto))\n",
    "    conjuntoNormalizado  = pd.DataFrame(conjuntoNormalizado, index=conjunto.index,columns=colunasConjunto)\n",
    "    return conjuntoNormalizado,scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def separaPorIntervalosDeProbabilidade(serie,intervalos):\n",
    "    valores = serie.values.flatten().tolist()\n",
    "    prob_acumulada=[]\n",
    "    conjuntoNormalizado=[]\n",
    "    for i in range(len(intervalos)):\n",
    "        ocorrencias = (len([x for x in valores if (x <= intervalos[i])])/len(valores))\n",
    "        intervalos[i] = round(intervalos[i],2)\n",
    "        ocorrencias = round(ocorrencias, 5)\n",
    "        prob_acumulada.append(ocorrencias)\n",
    "    \n",
    "    plt.hist(valores,cumulative=True,density = True)\n",
    "    plt.show()\n",
    "    print('Intervalos:')\n",
    "    print(intervalos)\n",
    "    print('Probabilidades acumuladas:')\n",
    "    print(prob_acumulada)\n",
    "    return prob_acumulada, intervalos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalizaNumero(numero,probMin,probMax,valorMin,valorMax):\n",
    "    \n",
    "    return (probMin + (numero-valorMin)*(probMax - probMin)/(valorMax - valorMin))\n",
    "\n",
    "def inverteNormalizacaoNumero(numero,probMin,probMax,valorMin,valorMax):\n",
    "    return (valorMin + (numero-probMin)*(valorMax - valorMin)/(probMax - probMin))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalizaSeriePorTrechos(serie,trechos,probabilidades,showPlot=False):\n",
    "    \n",
    "    serie_normalizada = []\n",
    "    for i in range(serie.size):\n",
    "        valor = serie.iloc[i].values[0]\n",
    "        indice_maior = np.where(np.array(trechos)  > valor)[0][0]\n",
    "        serie_normalizada.append(normalizaNumero(numero=valor,probMin=probabilidades[indice_maior-1],probMax=probabilidades[indice_maior],valorMin=trechos[indice_maior-1],valorMax=trechos[indice_maior]))\n",
    "    serie_normalizada = np.array(serie_normalizada)\n",
    "    \n",
    "    if(showPlot):\n",
    "        dataSetparaPlot = pd.DataFrame(serie_normalizada,columns=['Série Normalizada'],index= pd.to_datetime(serie.index)) \n",
    "        ax = dataSetparaPlot.plot(figsize=(12,7),grid=True)\n",
    "        plt.show()\n",
    "    \n",
    "    dataSetNormalizado = pd.DataFrame(serie_normalizada,columns=['Série Normalizada'],index=serie.index)\n",
    "    \n",
    "    return dataSetNormalizado\n",
    "\n",
    "def inverteNormalizacaoPorTrechos(serie,trechos,probabilidades,showPlot=False):\n",
    "    serie_invertida = []\n",
    "    for i in range(serie.size):\n",
    "        valor = serie.iloc[i].values[0]\n",
    "        indice_maior = np.where(np.array(probabilidades)  > valor)[0][0]\n",
    "        serie_invertida.append(inverteNormalizacaoNumero(numero=valor,probMin=probabilidades[indice_maior-1],probMax=probabilidades[indice_maior],valorMin=trechos[indice_maior-1],valorMax=trechos[indice_maior]))\n",
    "    serie_invertida = np.array(serie_invertida)\n",
    "    \n",
    "    if(showPlot):\n",
    "        dataSetparaPlot = pd.DataFrame(serie_invertida,index=pd.to_datetime(serie.index))\n",
    "        dataSetparaPlot.plot(figsize=(12,7),grid=True)\n",
    "        plt.show()\n",
    "    \n",
    "    dataSetInvertido = pd.DataFrame(serie_invertida,columns=['Série Normalizada'],index=serie.index) \n",
    "    \n",
    "    return dataSetInvertido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intervalos:\n",
      "[0, 1, 2, 6]\n",
      "Probabilidades acumuladas:\n",
      "[0.0, 0.69907, 0.94444, 1.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intervalos:\n",
      "[0, 0.6, 2]\n",
      "Probabilidades acumuladas:\n",
      "[0.0, 0.68056, 1.0]\n"
     ]
    }
   ],
   "source": [
    "dec = configuraConjuntoInicial(colunas=['DEC'])\n",
    "probAcumuladaDEC,intervalosDEC = separaPorIntervalosDeProbabilidade(dec,intervalos=[0,1,2,6])\n",
    "\n",
    "decNormalizado = normalizaSeriePorTrechos(serie=dec,trechos=intervalosDEC,probabilidades=probAcumuladaDEC)\n",
    "# decReconstruido = inverteNormalizacaoPorTrechos(serie=decNormalizado,trechos=intervalosDEC,probabilidades=probAcumuladaDEC)\n",
    "\n",
    "fec = configuraConjuntoInicial(colunas=['FEC'])\n",
    "probAcumuladaFEC,intervalosFEC = separaPorIntervalosDeProbabilidade(fec,intervalos=[0,0.6, 2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def codificaMesesDoConjunto(conjunto):\n",
    "    mesCodificado = np.array([float(i.split(\"-\")[1])/12 for i in conjunto.index])\n",
    "    return mesCodificado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def configuraConjuntosDeEntradaEDeReferencia(conjuntoDeDados, janelasDeObservacao=None,atraso=1, colunaAdicional=None,labelColunaAdicional=None):\n",
    "    \n",
    "    if janelasDeObservacao is None:\n",
    "        janelasDeObservacao = 12\n",
    "    dataSetDeEntrada = []\n",
    "    dataSetDeReferencia = []\n",
    "    \n",
    "    for ii in range(len(conjuntoDeDados) - janelasDeObservacao):\n",
    "        janelaDeDados = conjuntoDeDados[ii:ii+ janelasDeObservacao]\n",
    "        valorDeReferencia = conjuntoDeDados[ii+janelasDeObservacao]\n",
    "        dataSetDeEntrada.append(janelaDeDados)\n",
    "        dataSetDeReferencia.append(valorDeReferencia)\n",
    "    \n",
    "    dataSetDeEntrada = np.array(dataSetDeEntrada)\n",
    "    dataSetDeReferencia = np.array(dataSetDeReferencia)\n",
    "    conjuntoDeEntrada = pd.DataFrame(dataSetDeEntrada)\n",
    "    conjuntoDeReferencia = pd.DataFrame(dataSetDeReferencia)\n",
    "    \n",
    "    if colunaAdicional is not None and labelColunaAdicional is not None:\n",
    "        conjuntoDeEntrada[labelColunaAdicional] = colunaAdicional[janelasDeObservacao:]\n",
    "    return conjuntoDeEntrada, conjuntoDeReferencia\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def configuraRedeMLP(conjuntoEntrada,conjuntoSaida,neuronios_1=None,neuronios_2=None,showPlot=False):\n",
    "    \n",
    "    dimEntrada = len([i for i in conjuntoEntrada])\n",
    "    conjuntoEntrada = conjuntoEntrada.values\n",
    "    conjuntoSaida = conjuntoSaida.values\n",
    "    \n",
    "    earlyStopping = EarlyStopping(monitor = 'val_loss', patience = 100, verbose = 1)\n",
    "    K.clear_session()\n",
    "    model = Sequential()\n",
    "    if neuronios_1 is None:\n",
    "        neuronios_1 = 12\n",
    "    model.add(Dense(neuronios_1,  input_shape=(dimEntrada,),activation='relu',kernel_initializer ='random_normal'))\n",
    "    \n",
    "    if neuronios_2 is not None:\n",
    "        model.add(Dense(neuronios_2, input_shape=(neuronios_1,), activation='relu'))\n",
    "    \n",
    "    # model.add(Dense(3, input_shape=(6,), activation='tanh'))\n",
    "    model.add(Dense(1))\n",
    "    model.compile(optimizer=Adam(lr=0.0001), loss='mean_squared_error',metrics=['mae'])\n",
    "    historico = model.fit(conjuntoEntrada , conjuntoSaida,\n",
    "                validation_split=0.20, epochs=1000,\n",
    "                callbacks=[earlyStopping], verbose=0)\n",
    "    if(showPlot):\n",
    "        model.summary()\n",
    "        plt.plot(historico.history['mean_absolute_error'])\n",
    "        plt.plot(historico.history['val_loss'])\n",
    "        plt.legend(['mean_absolute_error','val_loss'])\n",
    "        plt.grid(True)\n",
    "        plt.show()\n",
    "    return model,historico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def executaPrevisaoDoModelo(modelo,conjuntoEntrada,conjuntoSaida=None,scalerSaida=None,showPlot=False):\n",
    "    \n",
    "    previsaoDeDados = modelo.predict(conjuntoEntrada)\n",
    "    if(showPlot and scalerSaida is not None and conjuntoSaida is not None):\n",
    "        dadosReais = scalerSaida.inverse_transform(conjuntoSaida)\n",
    "        previsaoDeDados = scalerSaida.inverse_transform(previsaoDeDados)\n",
    "        plt.figure(figsize=(12,7))\n",
    "        plt.plot(dadosReais)\n",
    "        plt.plot(previsaoDeDados)\n",
    "        plt.legend(['Real','Previsão'])\n",
    "        plt.grid(True)\n",
    "        plt.show()\n",
    "        return previsaoDeDados,dadosReais\n",
    "    return previsaoDeDados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculaErros(previsao,verdadeiro):\n",
    "    rmse = (mean_squared_error(verdadeiro, previsao))**0.5\n",
    "    mape = np.mean(np.abs((verdadeiro - previsao) / verdadeiro)) * 100\n",
    "    print('Root Mean Squared Error: %f'%rmse)\n",
    "    print('Mean Absolute Percentage Error: %f'%mape)\n",
    "    return rmse,mape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def executaPrevisaoEmMultiEstagios(modelo:Sequential,conjuntoEntradaInicial,numeroEstagios,conjuntoSaida=None,inverterNormalizacaoSaida=False,probabilidades=None,trechos=None,showPlot=False):\n",
    "    \n",
    "    dadosDeEntrada = conjuntoEntradaInicial.iloc[0:1]\n",
    "    labels = [i for i in conjuntoEntradaInicial]\n",
    "    previsaoFinal = []\n",
    "    \n",
    "    if numeroEstagios > 12:\n",
    "        horizonteMaximo = range(12)\n",
    "        iteracoesAdicionais = range(numeroEstagios - 12)\n",
    "    else:\n",
    "        horizonteMaximo = range(numeroEstagios)\n",
    "        iteracoesAdicionais = range(0)\n",
    "    \n",
    "    for i in horizonteMaximo:\n",
    "        previsao = executaPrevisaoDoModelo(modelo=modelo,conjuntoEntrada=dadosDeEntrada)\n",
    "        previsao = previsao.flatten().tolist()[0]\n",
    "        previsaoFinal.append(previsao)\n",
    "        if i == (len(horizonteMaximo) - 1):\n",
    "            if  len(iteracoesAdicionais) > 0:\n",
    "                dadosDeEntrada = conjuntoEntradaInicial.iloc[i:i+1]\n",
    "                for j in iteracoesAdicionais:\n",
    "                            previsao = executaPrevisaoDoModelo(modelo=modelo,conjuntoEntrada=dadosDeEntrada)\n",
    "                            previsao = previsao.flatten().tolist()[0]\n",
    "                            previsaoFinal.append(previsao)\n",
    "                            \n",
    "                            if j == (numeroEstagios - 1):\n",
    "                                break\n",
    "                            proximaEntrada = dadosDeEntrada.drop(columns='mes_codificado').values.flatten().tolist()\n",
    "                            proximaEntrada.append(previsao)\n",
    "                            proximaEntrada.append(conjuntoEntradaInicial['mes_codificado'].iloc[i+j+1])\n",
    "                            proximaEntrada.pop(0)\n",
    "                            dataFrameDeEntrada = []\n",
    "                            dataFrameDeEntrada.append(proximaEntrada)\n",
    "                            dadosDeEntrada = pd.DataFrame(dataFrameDeEntrada,columns=labels)\n",
    "            break\n",
    "        proximaEntrada = dadosDeEntrada.drop(columns='mes_codificado').values.flatten().tolist()\n",
    "        proximaEntrada.append(previsao)\n",
    "        proximaEntrada.append(conjuntoEntradaInicial['mes_codificado'].iloc[i+1])\n",
    "        proximaEntrada.pop(0)\n",
    "        dataFrameDeEntrada = []\n",
    "        dataFrameDeEntrada.append(proximaEntrada)\n",
    "        dadosDeEntrada = pd.DataFrame(dataFrameDeEntrada,columns=labels)\n",
    "        \n",
    "    \n",
    "    previsaoFinal = pd.DataFrame(np.array(previsaoFinal))\n",
    "    \n",
    "    if(showPlot and inverterNormalizacaoSaida and conjuntoSaida is not None):\n",
    "        \n",
    "        dadosReais = inverteNormalizacaoPorTrechos(serie=conjuntoSaida,trechos=trechos,probabilidades=probabilidades)\n",
    "        previsaoDeDados = inverteNormalizacaoPorTrechos(serie=previsaoFinal,trechos=trechos,probabilidades=probabilidades)\n",
    "\n",
    "        plt.figure(figsize=(12,7))\n",
    "        plt.plot(dadosReais)\n",
    "        plt.plot(previsaoDeDados)\n",
    "        plt.legend(['Real','Previsão'])\n",
    "        plt.grid(True)\n",
    "        plt.show()\n",
    "        return previsaoDeDados,dadosReais\n",
    "    return previsaoFinal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def converteDataStringParaDateTime(conjunto):\n",
    "    \n",
    "    return conjunto.set_index(pd.to_datetime(conjunto.index),drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intervalos:\n",
      "[0, 1, 2, 6]\n",
      "Probabilidades acumuladas:\n",
      "[0.0, 0.76282, 0.95513, 1.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intervalos:\n",
      "[0, 1.2, 3]\n",
      "Probabilidades acumuladas:\n",
      "[0.0, 0.75, 1.0]\n"
     ]
    }
   ],
   "source": [
    "indicador = 'DEC'\n",
    "conjunto = configuraConjuntoInicial(colunas=[indicador])\n",
    "treino,teste = separaConjuntosDeTreinoETeste(conjunto=conjunto,dataReferencia='2013-01-01')\n",
    "\n",
    "\n",
    "# treinoNormalizado,scalerTreino = normalizaConjunto(conjunto=treino)\n",
    "probAcumuladaTreino,intervalosTreino = separaPorIntervalosDeProbabilidade(treino,intervalos=[0,1,2,6])\n",
    "treinoNormalizado = normalizaSeriePorTrechos(serie=treino,trechos=intervalosTreino,probabilidades=probAcumuladaTreino)\n",
    "\n",
    "# testeNormalizado,scalerTeste = normalizaConjunto(conjunto=teste)\n",
    "probAcumuladaTeste,intervalosTeste = separaPorIntervalosDeProbabilidade(teste,intervalos=[0,1.2,3])\n",
    "testeNormalizado = normalizaSeriePorTrechos(serie=teste,trechos=intervalosTeste,probabilidades=probAcumuladaTeste)\n",
    "\n",
    "\n",
    "mesCodificadoTreino = codificaMesesDoConjunto(treinoNormalizado)\n",
    "mesCodificadoTeste = codificaMesesDoConjunto(testeNormalizado)\n",
    "treinoInput,treinoOutput = configuraConjuntosDeEntradaEDeReferencia(conjuntoDeDados=np.ndarray.flatten(treinoNormalizado.values),janelasDeObservacao=13,atraso=1,colunaAdicional=mesCodificadoTreino, labelColunaAdicional='mes_codificado')\n",
    "testeInput,testeOutput = configuraConjuntosDeEntradaEDeReferencia(conjuntoDeDados=np.ndarray.flatten(testeNormalizado.values),janelasDeObservacao=13,atraso=1,colunaAdicional=mesCodificadoTeste, labelColunaAdicional='mes_codificado')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 13)                195       \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 14        \n",
      "=================================================================\n",
      "Total params: 209\n",
      "Trainable params: 209\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Root Mean Squared Error: 0.346676\n",
      "Mean Absolute Percentage Error: 35.830925\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.34667577284310086, Série Normalizada    35.830925\n",
       " dtype: float64)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modelo = Sequential()\n",
    "modelo,historico = configuraRedeMLP(conjuntoEntrada=treinoInput,conjuntoSaida=treinoOutput,neuronios_1=13,neuronios_2=None,showPlot=True)\n",
    "prev_teste = []\n",
    "prev_teste,real_teste = executaPrevisaoEmMultiEstagios(modelo=modelo,conjuntoEntradaInicial=testeInput,numeroEstagios=testeOutput.size,conjuntoSaida=testeOutput,inverterNormalizacaoSaida=True,probabilidades=probAcumuladaTeste,trechos=intervalosTeste,showPlot=True)\n",
    "calculaErros(previsao=prev_teste,verdadeiro=real_teste)\n",
    "# print(real_teste)\n",
    "\n",
    "## Previsão dos dados de treino (um mes a frente):\n",
    "# previsaoTreino = []\n",
    "# previsaoTreino, dadosReaisTreino = executaPrevisaoDoModelo(modelo=modelo,conjuntoEntrada=treinoInput,conjuntoSaida=treinoOutput,scalerSaida=scalerTreino,showPlot=True)\n",
    "# calculaErros(previsao=previsaoTreino,verdadeiro=dadosReaisTreino)\n",
    "\n",
    "## Previsão dos dados de teste (um mês a frente): \n",
    "# previsaoTeste =[]\n",
    "# previsaoTeste, dadosReaisTeste = executaPrevisaoDoModelo(modelo=modelo,conjuntoEntrada=testeInput,conjuntoSaida=testeOutput,scalerSaida=scalerTeste,showPlot=True)\n",
    "# calculaErros(previsao=previsaoTeste,verdadeiro=dadosReaisTeste)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 746,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Previsão do DEC\n",
      "Data                       \n",
      "2014-09-01         0.802986\n",
      "2014-10-01         0.853061\n",
      "2014-11-01         0.875046\n",
      "2014-12-01         0.890264\n",
      "2015-01-01         0.756547\n",
      "2015-02-01         0.751251\n",
      "2015-03-01         0.718098\n",
      "2015-04-01         0.714589\n",
      "2015-05-01         0.722954\n",
      "2015-06-01         0.738724\n",
      "2015-07-01         0.752722\n",
      "2015-08-01         0.778961\n",
      "2015-09-01         0.720856\n",
      "2015-10-01         0.756881\n",
      "2015-11-01         0.800823\n",
      "2015-12-01         0.829631\n",
      "2016-01-01         0.869102\n",
      "2016-02-01         0.744251\n",
      "2016-03-01         0.733218\n",
      "2016-04-01         0.716206\n",
      "2016-05-01         0.709029\n",
      "2016-06-01         0.719775\n",
      "2016-07-01         0.737740\n",
      "2016-08-01         0.751645\n",
      "2016-09-01         0.777884\n",
      "2016-10-01         0.801200\n",
      "2016-11-01         0.826611\n",
      "2016-12-01         0.853539\n",
      "2017-01-01         0.880462\n",
      "2017-02-01         0.753780\n",
      "2017-03-01         0.738191\n",
      "2017-04-01         0.719734\n",
      "2017-05-01         0.710932\n",
      "2017-06-01         0.721349\n",
      "2017-07-01         0.738354\n",
      "2017-08-01         0.752270\n",
      "2017-09-01         0.778151\n",
      "2017-10-01         0.801410\n",
      "2017-11-01         0.826721\n",
      "2017-12-01         0.853629\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "conjunto = converteDataStringParaDateTime(conjunto)\n",
    "conjunto = conjunto.loc['01-01-2015':'12-01-2017']\n",
    "# prev_teste pd.DataFrame(prev_teste, columns=['Previsão do FEC'],\n",
    "previsao_final = pd.DataFrame(prev_teste.values, columns=['Previsão do DEC'], index= pd.to_datetime(teste.iloc[-len(prev_teste):].index))\n",
    "print(previsao_final)\n",
    "ax = conjunto.plot(y=indicador,figsize=(12,7))\n",
    "previsao_final.plot(y='Previsão do DEC',ax=ax)\n",
    "plt.title('Resultado da previsão')\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}