previsao_indicadores_ver2.0_implementacao_inicial_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "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, RNN\n",
    "from keras.optimizers import Adam\n",
    "from keras import optimizers\n",
    "from keras.callbacks import EarlyStopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.layers import Dense, RNN, SimpleRNN"
   ]
  },
  {
   "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",
    "    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",
    "    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 analisePorIntervalosDeProbabilidade(serie,intervalos,showPlot=False):\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",
    "    if(showPlot):\n",
    "        plt.hist(valores,cumulative=True,density = True)\n",
    "        plt.title('Distribuição de probabilidade acumulada')\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",
    "    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",
    "    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'],index=serie.index) \n",
    "    \n",
    "    return dataSetInvertido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diferenciaSerie(dataset, interval=1):\n",
    "    data = dataset.values.flatten()\n",
    "    diff = list()\n",
    "    for i in range(interval, len(dataset)):\n",
    "        value = data[i] - data[i - interval]\n",
    "        diff.append(value)\n",
    "    index = dataset.index[interval:len(dataset)]\n",
    "    return pd.DataFrame(data=diff,index=index,columns=[dataset.columns[0]])\n",
    "\n",
    "def inverteDiferenciaSerie(original, diff):\n",
    "    data_diff = diff.values.flatten()\n",
    "    data_original = original.values.flatten()\n",
    "    inverted = [(data_original[i] + data_diff[i]) for i in range(len(data_diff))]\n",
    "    return pd.DataFrame(data=inverted,index=diff.index,columns=diff.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def codificaMesesDoConjunto(conjunto):\n",
    "    indexData = [i.strftime(\"%m-%d-%Y\") for i in conjunto.index]\n",
    "    mesCodificado = np.array([float(i.split(\"-\")[0])/12 for i in indexData])\n",
    "    mesCodificado = pd.DataFrame(data=mesCodificado,index=conjunto.index,columns=['mes_codificado'])\n",
    "    return mesCodificado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def configuraConjuntosDeEntradaEDeReferenciaPorJanelas(conjunto, janelasDeObservacao=12, janelasDeAtraso=0):\n",
    "    \n",
    "    conjuntoDeDados = np.ndarray.flatten(conjunto.values)\n",
    "    dataSetDeEntrada = []\n",
    "    dataSetDeReferencia = []\n",
    "    \n",
    "    for ii in range(len(conjuntoDeDados) - (janelasDeObservacao + janelasDeAtraso)):\n",
    "        janelaDeDados = conjuntoDeDados[ii+janelasDeAtraso:ii+ janelasDeObservacao+janelasDeAtraso]\n",
    "        valorDeReferencia = conjuntoDeDados[ii+janelasDeObservacao+janelasDeAtraso]\n",
    "        dataSetDeEntrada.append(janelaDeDados)\n",
    "        dataSetDeReferencia.append(valorDeReferencia)\n",
    "    \n",
    "    dataSetDeEntrada = np.array(dataSetDeEntrada)\n",
    "    dataSetDeReferencia = np.array(dataSetDeReferencia)\n",
    "    conjuntoDeEntrada = pd.DataFrame(dataSetDeEntrada,index=conjunto.index[janelasDeObservacao + janelasDeAtraso:])\n",
    "    conjuntoDeReferencia = pd.DataFrame(dataSetDeReferencia,index=conjunto.index[janelasDeObservacao + janelasDeAtraso:])\n",
    "    return conjuntoDeEntrada,conjuntoDeReferencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def concatenaConjuntos(conjunto1,conjunto2):\n",
    "    return pd.concat([conjunto1, conjunto2], axis=1, join='inner')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def configuraRedeMLP(conjuntoEntrada,conjuntoSaida,neuronios_1=None,neuronios_2=None,metricas=['mse'],funcObjetivo='mean_squared_error',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'))\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.001), loss=funcObjetivo,metrics=metricas)\n",
    "    historico = model.fit(conjuntoEntrada , conjuntoSaida,\n",
    "                validation_split=0.20, epochs=2000,\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.legend(['val_loss'])\n",
    "        plt.grid(True)\n",
    "        plt.show()\n",
    "    return model,historico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def configuraRedeRNN(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",
    "    model = Sequential()\n",
    "    if neuronios_1 is None:\n",
    "        neuronios_1 = 12\n",
    "    model.add(SimpleRNN(neuronios_1,  input_shape=(dimEntrada,),activation='relu'))\n",
    "    \n",
    "    if neuronios_2 is not None:\n",
    "        model.add(SimpleRNN(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.001), loss=funcObjetivo,metrics=metricas)\n",
    "    historico = model.fit(conjuntoEntrada , conjuntoSaida,\n",
    "                validation_split=0.20, epochs=2000,\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.legend(['val_loss'])\n",
    "        plt.grid(True)\n",
    "        plt.show()\n",
    "    return model,historico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def executaPrevisaoEmMultiEstagios(modelo:Sequential,conjuntoEntradaInicial,numeroEstagios,indexPrevisao,horizonte=12):\n",
    "    \n",
    "    dadosDeEntrada = conjuntoEntradaInicial.iloc[0:1]\n",
    "    labels = [i for i in conjuntoEntradaInicial]\n",
    "    previsaoFinal = []\n",
    "    \n",
    "    if numeroEstagios > horizonte:\n",
    "        horizonteMaximo = range(horizonte)\n",
    "        iteracoesAdicionais = range(numeroEstagios - horizonte)\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",
    "    previsaoFinal = pd.DataFrame(np.array(previsaoFinal),index=indexPrevisao,columns=['Previsão da série'])\n",
    "    return previsaoFinal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def comparaPrevisaoComSerieReal(conjuntoReal,previsao):\n",
    "    plt.figure(figsize=(12,7))\n",
    "    plt.plot(conjuntoReal)\n",
    "    plt.plot(previsao)\n",
    "    plt.legend(['Real','Previsão'])\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def converteDateStringParaDateTime(conjunto):\n",
    "    return conjunto.set_index(pd.to_datetime(conjunto.index),drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Execução do código a partir daqui"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "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.72024, 0.94048, 1.0]\n",
      "\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.5]\n",
      "Probabilidades acumuladas:\n",
      "[0.0, 0.625, 1.0]\n"
     ]
    }
   ],
   "source": [
    "indicador = 'DEC'\n",
    "conjunto = configuraConjuntoInicial(colunas=[indicador])\n",
    "# conjunto = conjunto.iloc[132:]\n",
    "treino,teste = separaConjuntosDeTreinoETeste(conjunto=conjunto,dataReferencia='2014-01-01')\n",
    "\n",
    "# treino_diff = diferenciaSerie(treino,interval=12)\n",
    "# teste_diff = diferenciaSerie(teste,interval=12)\n",
    "\n",
    "# treinoNormalizado,scalerTreino = normalizaConjunto(conjunto=treino)\n",
    "probAcumuladaTreino,intervalosTreino = analisePorIntervalosDeProbabilidade(treino,intervalos=[0,1,2,6],showPlot=True)\n",
    "treinoNormalizado = normalizaSeriePorTrechos(serie=treino,trechos=intervalosTreino,probabilidades=probAcumuladaTreino)\n",
    "print('')\n",
    "# testeNormalizado,scalerTeste = normalizaConjunto(conjunto=teste)\n",
    "probAcumuladaTeste,intervalosTeste = analisePorIntervalosDeProbabilidade(teste,intervalos=[0,1,2.5],showPlot=True)\n",
    "testeNormalizado = normalizaSeriePorTrechos(serie=teste,trechos=intervalosTeste,probabilidades=probAcumuladaTeste)\n",
    "\n",
    "janela = 13\n",
    "atraso = 1\n",
    "horizonteMaximo = 12\n",
    "treinoInput,treinoOutput = configuraConjuntosDeEntradaEDeReferenciaPorJanelas(conjunto=treinoNormalizado,janelasDeObservacao=janela,janelasDeAtraso=atraso)\n",
    "testeInput,testeOutput = configuraConjuntosDeEntradaEDeReferenciaPorJanelas(conjunto=testeNormalizado,janelasDeObservacao=janela,janelasDeAtraso=atraso)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 469,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesCodificadoTreino = codificaMesesDoConjunto(treinoNormalizado)\n",
    "mesCodificadoTeste = codificaMesesDoConjunto(testeNormalizado)\n",
    "treinoInput = concatenaConjuntos(conjunto1=treinoInput,conjunto2=mesCodificadoTreino)\n",
    "testeInput = concatenaConjuntos(conjunto1=testeInput,conjunto2=mesCodificadoTeste)\n",
    "\n",
    "teste12mesesDefasado = testeNormalizado[janela:].shift(atraso).dropna()\n",
    "treino12mesesDefasado = treinoNormalizado[janela:].shift(atraso).dropna()\n",
    "treinoInput = concatenaConjuntos(conjunto1=treinoInput,conjunto2=treino12mesesDefasado)\n",
    "testeInput = concatenaConjuntos(conjunto1=testeInput,conjunto2=teste12mesesDefasado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.layers import Embedding,LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "lstm_29 (LSTM)               (None, 12)                672       \n",
      "_________________________________________________________________\n",
      "dense_28 (Dense)             (None, 1)                 13        \n",
      "=================================================================\n",
      "Total params: 685\n",
      "Trainable params: 685\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"
    }
   ],
   "source": [
    "conjuntoEntrada = treinoInput\n",
    "conjuntoSaida = treinoOutput\n",
    "neuronios_1 = 12\n",
    "showPlot = True\n",
    "# neuronios_2 = 12\n",
    "# def configuraRedeRNN(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",
    "trainX = np.reshape(conjuntoEntrada, (conjuntoEntrada.shape[0],conjuntoEntrada.shape[1], 1))\n",
    "\n",
    "\n",
    "model = Sequential()\n",
    "model.add(LSTM(12,input_shape=(janela,1)))\n",
    "model.add(Dense(1))\n",
    "\n",
    "\n",
    "if neuronios_1 is None:\n",
    "    neuronios_1 = 12\n",
    "    \n",
    "# model.add(SimpleRNN(neuronios_1,  input_shape=(dimEntrada,),activation='relu'))\n",
    "# model.add(SimpleRNN(1))\n",
    "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['mae'])\n",
    "\n",
    "historico = model.fit(trainX , conjuntoSaida,\n",
    "            validation_split=0.20, epochs=500, verbose=0)\n",
    "\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.legend(['val_loss'])\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "#     return model,historico\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "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.121507\n",
      "Mean Absolute Percentage Error: 24.760918\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.12150738496080306, 24.76091793866694)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testX = np.reshape(testeInput.values, (testeInput.shape[0],  testeInput.shape[1],1))\n",
    "previsao = model.predict(testX) \n",
    "plt.figure(figsize=(12,7))\n",
    "plt.plot(previsao)\n",
    "plt.plot(testeOutput.values)\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "calculaErros(previsao=previsao,verdadeiro=testeOutput.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 00255: early stopping\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 15)                135       \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 16        \n",
      "=================================================================\n",
      "Total params: 151\n",
      "Trainable params: 151\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"
    }
   ],
   "source": [
    "\n",
    "# for i in range(15):\n",
    "modelo = Sequential()\n",
    "modelo,historico = configuraRedeMLP(conjuntoEntrada=treinoInput,conjuntoSaida=treinoOutput,neuronios_1=15,neuronios_2=None,metricas=['mse','mape','mae'],funcObjetivo='mean_squared_error',showPlot=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "\"labels ['mes_codificado'] not contained in axis\"",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-41-e2b718297713>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mprev_teste\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprev_teste\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mexecutaPrevisaoEmMultiEstagios\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodelo\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmodelo\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mconjuntoEntradaInicial\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtesteInput\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mnumeroEstagios\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtesteOutput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mindexPrevisao\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtesteOutput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mhorizonte\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mhorizonteMaximo\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mdadosReais\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minverteNormalizacaoPorTrechos\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mserie\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtesteOutput\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtrechos\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mintervalosTeste\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mprobabilidades\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mprobAcumuladaTeste\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprevisaoDeDados\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minverteNormalizacaoPorTrechos\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mserie\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mprev_teste\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtrechos\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mintervalosTeste\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mprobabilidades\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mprobAcumuladaTeste\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-15-d296f6cf4219>\u001b[0m in \u001b[0;36mexecutaPrevisaoEmMultiEstagios\u001b[1;34m(modelo, conjuntoEntradaInicial, numeroEstagios, indexPrevisao, horizonte)\u001b[0m\n\u001b[0;32m     34\u001b[0m                             \u001b[0mdadosDeEntrada\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdataFrameDeEntrada\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlabels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     35\u001b[0m             \u001b[1;32mbreak\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 36\u001b[1;33m         \u001b[0mproximaEntrada\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdadosDeEntrada\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'mes_codificado'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtolist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     37\u001b[0m         \u001b[0mproximaEntrada\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mprevisao\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     38\u001b[0m         \u001b[0mproximaEntrada\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconjuntoEntradaInicial\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'mes_codificado'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\python\\tf_test\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36mdrop\u001b[1;34m(self, labels, axis, index, columns, level, inplace, errors)\u001b[0m\n\u001b[0;32m   3692\u001b[0m                                            \u001b[0mindex\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcolumns\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3693\u001b[0m                                            \u001b[0mlevel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlevel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minplace\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minplace\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3694\u001b[1;33m                                            errors=errors)\n\u001b[0m\u001b[0;32m   3695\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3696\u001b[0m     @rewrite_axis_style_signature('mapper', [('copy', True),\n",
      "\u001b[1;32mc:\\python\\tf_test\\lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36mdrop\u001b[1;34m(self, labels, axis, index, columns, level, inplace, errors)\u001b[0m\n\u001b[0;32m   3106\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[1;32min\u001b[0m \u001b[0maxes\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3107\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mlabels\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3108\u001b[1;33m                 \u001b[0mobj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_drop_axis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlevel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merrors\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0merrors\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3109\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3110\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0minplace\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\python\\tf_test\\lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36m_drop_axis\u001b[1;34m(self, labels, axis, level, errors)\u001b[0m\n\u001b[0;32m   3138\u001b[0m                 \u001b[0mnew_axis\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlevel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merrors\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0merrors\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3139\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3140\u001b[1;33m                 \u001b[0mnew_axis\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merrors\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0merrors\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3141\u001b[0m             \u001b[0mdropped\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;33m{\u001b[0m\u001b[0maxis_name\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mnew_axis\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3142\u001b[0m             \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\python\\tf_test\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mdrop\u001b[1;34m(self, labels, errors)\u001b[0m\n\u001b[0;32m   4385\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0merrors\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[1;34m'ignore'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   4386\u001b[0m                 raise KeyError(\n\u001b[1;32m-> 4387\u001b[1;33m                     'labels %s not contained in axis' % labels[mask])\n\u001b[0m\u001b[0;32m   4388\u001b[0m             \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m~\u001b[0m\u001b[0mmask\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   4389\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdelete\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: \"labels ['mes_codificado'] not contained in axis\""
     ]
    }
   ],
   "source": [
    "prev_teste = []\n",
    "prev_teste = executaPrevisaoEmMultiEstagios(modelo=modelo,conjuntoEntradaInicial=testeInput,numeroEstagios=testeOutput.size,indexPrevisao=testeOutput.index,horizonte=horizonteMaximo)\n",
    "\n",
    "dadosReais = inverteNormalizacaoPorTrechos(serie=testeOutput,trechos=intervalosTeste,probabilidades=probAcumuladaTeste)\n",
    "previsaoDeDados = inverteNormalizacaoPorTrechos(serie=prev_teste,trechos=intervalosTeste,probabilidades=probAcumuladaTeste)\n",
    "\n",
    "calculaErros(previsao=previsaoDeDados.values,verdadeiro=dadosReais.values)\n",
    "\n",
    "dadosReais = converteDateStringParaDateTime(dadosReais)\n",
    "previsaoDeDados = converteDateStringParaDateTime(previsaoDeDados)\n",
    "comparaPrevisaoComSerieReal(conjuntoReal=dadosReais,previsao=previsaoDeDados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "conjuntoTodo = converteDateStringParaDateTime(conjunto)\n",
    "conjuntoParcial = conjuntoTodo.loc['01-01-2011':'12-01-2017']\n",
    "# prev_teste pd.DataFrame(prev_teste, columns=['Previsão do FEC'],\n",
    "previsao_final = pd.DataFrame(previsaoDeDados.values, columns=['Previsão do DEC'], index= pd.to_datetime(teste.iloc[-len(previsaoDeDados):].index))\n",
    "ax = conjuntoParcial.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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}