Laboratorio_ARIMA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bem vindo ao Laboratório ARIMA "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comece conhecendo a interface do Jupyter Notebook disponível em \"Help/User Interface Tour\"\n",
    "\n",
    "Para uma introdução básica ao funcionamento do Jupiter Notebook [clique aqui](https://letscode-academy.com/blog/introducao-ao-jupyter-notebook/#abrindo) (pule a parte de instalação, 5 minutos de leitura bastam)\n",
    "\n",
    "Caso queira se aprofundar um pouco mais, [clique aqui (en-US)](https://mybinder.org/v2/gh/jvns/pandas-cookbook/master), espere página carregar e dirija-se ao 'CookBook'; ou ainda [aqui (pt-BR)](https://www.digitalocean.com/community/tutorials/como-configurar-o-jupyter-notebook-com-python-3-no-ubuntu-18-04-pt), a partir do passo 6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É comum, antes de iniciar o código, declarar todas as bibliotecas que serão utilizadas, para informar à outros programadores quais os pré-requisitos para o programa.\n",
    "Nesse caso, utilizando o Binder, não há necessidade de instalar nenhuma delas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ____ as pd\n",
    "import ____ as np\n",
    "import ____ as plt\n",
    "from statsmodels.tsa.arima_model import ARIMA\n",
    "from statsmodels.tsa.stattools import adfuller\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n",
    "import matplotlib.dates as mdates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Numpy**: utilizada para efetuar todo tipo de cálculo matemático, da mais simples divisão com valor inteiro, até multiplicação de matrizes, passando pelas integrais\n",
    "- **Pandas**: consagrada por importar arquivos csv, excel, html, entre outros; é baseado no Numpy e faz operações vetorizadas \n",
    "- **Matplotlib**: é capaz de fazer gráficos com poucas linhas, e permite a alteração de diversas variáveis de estilo que o excel, por exemplo, não permite \n",
    "- **Statsmodel**: no contexto estatístico, apresentar modelos já preparados para aplicação. Com documentação farta nos permite, por exemplo, usar o ARIMA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Acessando dados de um diretório\n",
    "\n",
    "O diretório é a localização dentro do computador (como uma pasta) que guarda os arquivos necessários para o código funcionar assim como ele próprio. Nesse caso, o diretório se parece com esse: \n",
    "![](imagens/repositorio.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A forma de acessar esses arquivos é usando **funções** como a `plt.plot()`\n",
    "\n",
    "![](imagens/funcao.jpg)\n",
    "\n",
    "Nesse exemplo temos:\n",
    "- A biblioteca que contém a função (`plt`)\n",
    "- A própria função (`plot()`)\n",
    "- Os argumentos posicionais, que são necessários para que a função opere corretamente, têm que ser postos nessa ordem\n",
    "- Argumentos de palavra-chave (keyword arguments) são opcionais e tem convenções vindas da própria biblioteca, como cores, dimensões e tipo de gráfico\n",
    "\n",
    "A seguir, usaremos `pd.read_csv()` para abrir os dados dos radares, mas antes, vamos olhar como um csv ( _Comma Separated Values_ ) ou seja, um arquivo de valores separados por vírgula, realmente é:\n",
    "\n",
    "![](imagens/csv.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1=pd.read_csv(\"____\", decimal='.')\n",
    "display(____)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É assim que os dados estão organizados, podemos obter mais informações a partir deles:\n",
    "\n",
    "`df.info()` nos fornece as colunas, qual o tipo de dados delas (float e int) e o uso de memória (33.6MB)\n",
    "\n",
    "`df.describe()` sumariza as estatísticas das colunas de valores numéricos:  quantidade, desvio padrão, média e quartis \n",
    "\n",
    "`df.columns` é um método, não termina com parêntesis (normalmente informam atributos da tabela), nos dá as colunas\n",
    "\n",
    "`df.shape` outro método, fornece as dimensões da tabela"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(____) #informações\n",
    "print('================================================')\n",
    "print(____) #descrição sumária\n",
    "print('================================================')\n",
    "print(____) #colunas\n",
    "print('================================================')\n",
    "print(____) #dimensões"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pelo fato dos arquivos serem muito grandes, eles estão divididos em 2, logo os juntaremos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importa os csvs agrupados\n",
    "\n",
    "df_old1=pd.read_csv(\"radares_20180906.csv\",\n",
    "                sep=';',\n",
    "                decimal='.')\n",
    "df_old1['Data']=pd.to_datetime(df_old1['Data'])\n",
    "\n",
    "# faça o mesmo para o outro arquivo \"radares_20180921.csv\"\n",
    "\n",
    "df_old2=pd.read_csv(\"radares_20180921.csv\",\n",
    "                sep=';',\n",
    "                decimal='.')\n",
    "df_old2['Data']=pd.to_datetime(df_old2['Data'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqui foi possível ver os Argumentos de palavra-chave em ação. O csv aqui é separado por semi-vígulas, e temos que informar isso à função (`sep = ';'`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transforma as datas em dias consecutivos, para transformá-los em dados de manipulação mais fácil\n",
    "df_old1['Data']=df_old1['Data'].apply(lambda x: x.replace(month=1, day=2, hour=x.hour, minute=x.minute, second=x.second))\n",
    "df_old2['Data']=df_old2['Data'].apply(lambda x: x.replace(month=1, day=3, hour=x.hour, minute=x.minute, second=x.second))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agrupando os dois dias num único dataframe\n",
    "Um \"Dataframe\" é um formato de apresentação de dados muito parecido com o do Excel, mas pensado para as necessidade e limitações da Ciência de Dados\n",
    "\n",
    "Nessa etapa, iremos junta-los e dar uma olhada.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_old = pd.concat([df_old1,df_old2],axis=0).reset_index(drop=True)\n",
    "\n",
    "df_old.dropna(inplace=True)\n",
    "\n",
    "display(df_old), display(df_old.head(n=5));\n",
    "# Troque o valor de n para ver quantas linhas do topo desejar, o padrão é n=5\n",
    "\n",
    "df = df_old"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Consolida os todos dias em um unico dataframe\n",
    "\n",
    "# Copie esse código quantas vezes forem necessárias para o numero de dias que voce escolheu\n",
    "\n",
    "df1 = pd.read_csv(r\"D:\\\\Users\\\\guilh\\\\Documents\\\\GitHub\\\\Dados_CET\\\\Marco_2018_nAg\\\\\"+ \"1\" +\"_nAg.csv\")\n",
    "\n",
    "df2 = pd.read_csv(r\"D:\\\\Users\\\\guilh\\\\Documents\\\\GitHub\\\\Dados_CET\\\\Marco_2018_nAg\\\\\"+ \"2\" +\"_nAg.csv\")\n",
    "\n",
    "df3 = pd.read_csv(r\"D:\\\\Users\\\\guilh\\\\Documents\\\\GitHub\\\\Dados_CET\\\\Marco_2018_nAg\\\\\"+ \"3\" +\"_nAg.csv\")\n",
    "\n",
    "#concatene os dataframes\n",
    "df_novo = pd.concat([df1,df2,df3],axis=0).reset_index(drop=True)\n",
    "\n",
    "# Transforma a coluna de data (e hora) para para o formato que o Python consegue interpretar\n",
    "df_novo['Data']=pd.to_datetime(df_novo['Data'])\n",
    "\n",
    "# A velocidade nos arquivos da CET está em dm/s\n",
    "# a etapa a seguir transforma para km/h\n",
    "# df['Velocidade'] = df['Velocidade']* 0.36\n",
    "\n",
    "df_novo.dropna(inplace=True)\n",
    "\n",
    "df_novo.reset_index(inplace=True, drop=True)\n",
    "\n",
    "\n",
    "display(df_novo), display(df_novo.head(n=5))\n",
    "# Troque o valor de n para ver quantas linhas do topo desejar, o padrão é n=5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com 4 colunas e mais de 1 milhão de linhas, aí estão os nossos dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotando o seu primeiro gráfico\n",
    "\n",
    "O histograma que faremos a seguir concentra a frequência que uma variável ocorre em uma barra.\n",
    "\n",
    "No eixo x estão as velocidades, e no y a frequência com que cada uma delas ocorre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.rcParams.update({'figure.figsize':(6,3), 'figure.dpi':120})\n",
    "\n",
    "plt.hist(____,____,____) # com df['VelMed'], estamos selecionando apenas essa coluna das 4\n",
    "plt.ylabel('Frenquência de ocorrência')\n",
    "plt.xlabel('Velocidade média medida pelo radar (km/h)')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No nosso dataset, é possível concluir que as velocidade médias se concentram entre 70 e 120 km/h (mais de 500000 veículos!)\n",
    "\n",
    "Mas, caso queira tirar o argumento `range=(0,150)`, mostra que há ocorrências de velocidades de 1000 km/h! Claramente são falhas de medição do radar, os famosos **outliers**\n",
    "\n",
    "Para lidar com eles, existe outro gráfico, o boxplot, formado pelo primeiro e terceiro quartil (limites da caixa) e pela mediana (risco do meio). Os valores fora das hastes são outliers\n",
    "\n",
    "Para mais do boxplot, [cliquei aqui](http://www.portalaction.com.br/estatistica-basica/31-boxplot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "____.____(____);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apesar de parecerem muitos os outliers, que são velocidades negativas ou acima de 170 km/h, temos tantos dados que esses poucos absurdos não serão problema"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='cell'></a>\n",
    "## Seleção do radar e hora a serem previstos\n",
    "\n",
    "A partir de agora vamos pensar no modelo\n",
    "\n",
    "Pensando ter uma previsão mais precisa, vamos modelar o tráfego de apenas uma via, a Av. Alcântara Machado, sentido Centro/Bairro. Com os seus dados históricos, tentaremos estimar o fluxo dos próximos 45 minutos (que já é uma grande dificuldade)\n",
    "\n",
    "Para tal, selecionamos o radar referente à essa via ( _4326_ ) e dividimos os dataframe em 2 partes:\n",
    "- Treino: sobre os quais o modelo se baseia para as previsões;\n",
    "- Teste: que serve para validação, avaliar qual o erro dessa previsão\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# df_ = df.groupby(['Numero Agrupado','Especie',pd.Grouper(key='Data', freq='3Min')]).agg({\n",
    "#                                                                         \"Registro\": \"count\",\n",
    "#                                                                         'Velocidade': 'mean',\n",
    "#                                                                         })\n",
    "# df_.columns=[\"Qtde\",'Vel_media'] # Renomeia\n",
    "\n",
    "# # Seleciona um único radar e horário para realizar a previsão\n",
    "radar = 4326\n",
    "hora = '13:00:00'\n",
    "\n",
    "df_rad = df.loc[df['Local']== radar].reset_index(drop=True)\n",
    "\n",
    "division = df_rad.loc[df_rad['Data']=='2018-01-03 ' + hora].index[0]\n",
    "start = division - 100\n",
    "\n",
    "# Separa em treino e validação\n",
    "treino = df_rad.loc[start:division]\n",
    "teste  = df_rad.loc[division:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> _Ao fim desse roteiro será recomendado para você testar a previsão em outros horários do dia. A variável que deverá ser alterada é `hora`, para qualquer hora cheia_\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Determinação dos parâmetros do ARIMA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checar se a série é estacionária"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A série estacionária é condição _sine qua non_ para a aplicação do método; caso nao for, é possível utilizar a diferenciação da série - quantas vezes forem necessárias -  para torná-la estacionária. Escolhido o radar, observa-se se a série pode ser considerada estacionária (p-value inferior a 0.05) por meio do teste de Dickey-Fuller aumentado (ADF)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = adfuller(df_rad.Qtde)\n",
    "print('ADF Statistic: %f' % result[0])\n",
    "print('p-value: %f' % result[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por isso, não será realizado nenhuma diferenciação. No entanto, faremos a validação visual para certificar-nos do resultado apontado pelo teste ADF."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validação Visual\n",
    "\n",
    "Para validar visualmente o resultado do teste ADF, plotamos funções de autocorrelação para a série original, com diferenciação de primeira e de segunda ordem. \n",
    "\n",
    "Espera-se que a série original tenha uma curva da Função de Autocorrelação (ACF) decrescente enquanto as outras possuam uma queda abrupta pois, segundo o teste ADF, elas já serão diferenciadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams.update({'figure.figsize':(9,7), 'figure.dpi':120})\n",
    "fig, axes = plt.subplots(3, 2, sharex=False)\n",
    "\n",
    "# Original Series\n",
    "axes[0, 0].plot(____); axes[0, 0].set_title('Original Series')\n",
    "plot_acf(____, ____, ____, ____)\n",
    "\n",
    "# 1st Differencing\n",
    "axes[1, 0].plot(____); axes[1, 0].set_title('1st Order Differencing')\n",
    "plot_acf(____.dropna(), ____)\n",
    "\n",
    "# 2nd Differencing\n",
    "axes[2, 0].plot(____); axes[2, 0].set_title('2nd Order Differencing')\n",
    "plot_acf(____.dropna(), ____)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os plots mostram que na primeira diferenciação, a série já se torna super diferenciada (o que pode ser notado pela queda abrupta na curva de autocorrelação). Isso indica que o parâmetro d=0 é realmente o ideal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ordem da Auto-Regressão\n",
    "\n",
    "Por se tratar de uma regressão feita sobre os valores anteriores da série, deve-se ver até que ponto há correlação entre os pontos de observação. Isso é definido através da Função de Autocorrelação Parcial (PACF)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PACF\n",
    "plt.rcParams.update({'figure.figsize':(9,7), 'figure.dpi':120})\n",
    "\n",
    "fig, axes = plt.subplots(2, 1, sharex=False)\n",
    "axes[0].plot(____); axes[0].set_title('Series')\n",
    "axes[1].set(____)\n",
    "plot_pacf(____, ____, ____)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pelo gráfico devemos observar até que ponto a correlação está acima do nível de confiança, adotado em 95%.\n",
    "\n",
    "Desconsiderando o primeiro (já que a autocorrelação parcial com o primeiro ponto da série é consigo mesmo, ou seja, sempre PACF=1), podemos ver que os quatro pontos seguintes possuem correlação acima do nível de confiança exigido (delimitado pela área azul). Por isso, utilizaremos p=4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ordem da Média-Móvel\n",
    "\n",
    "O plot da ACF fornece um threshold, um limite, superior para o ordem do modelo MA. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(2,1, sharex=False)\n",
    "\n",
    "\n",
    "axes[0].plot(df_rad.Qtde); axes[0].set_title('Series')\n",
    "axes[1].set(ylim=(0,1.2), xlim=(0,60))\n",
    "plot_acf(df_rad.Qtde, ax=axes[1], lags=100)\n",
    "\n",
    "\n",
    "plt.annotate('Entra na área de significância', \n",
    "             xytext=(30, 1),\n",
    "             xy=(43,0.4),\n",
    "             arrowprops=dict(facecolor='black', shrink=0.05))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A autocorrelação decai muito lentamente para a série em questão. \n",
    "\n",
    "\n",
    "Isso nos daria um treshold máximo da ordem de 40. No entanto, vale ressaltar que esse valor pode ser muito elevado, então deve-se sempre levar em conta tanto o fator de **performance do modelo** quanto **custo computacional**, evitando o uso de parâmetros muito elevados em quaisquer modelos.\n",
    "\n",
    "Nos modelos ARIMA, a componente de média móvel raramente ultrapassa 3 ou 4. Por isso, utilizaremos o valor 1 para manter o modelo simples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construção do modelo e previsão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# De_para para mostrar a localizacao do radar\n",
    "de_para = pd.read_csv('de_para.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos criar nosso modelo com os parâmetros que encontramos (p,d,q) = (4,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = ____ #Autoregressao\n",
    "d = ____ #Diferenciacao\n",
    "q = ____ #MediaMovel\n",
    "steps = 15 # Steps a serem previstos\n",
    "\n",
    "teste=teste[:steps]\n",
    "\n",
    "# Istancia o modelo e faz o fit no treino\n",
    "model = ARIMA(____,order=(____,____,____))\n",
    "model_fit=____.____(disp=-1)\n",
    "\n",
    "# Realiza FORECAST\n",
    "fc, se, conf = model_fit.forecast(____,____)  # 95% conf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fc_series = pd.Series(fc, index=teste.index)\n",
    "\n",
    "lower_series = pd.Series(conf[:, 0], index=teste.Data)\n",
    "upper_series = pd.Series(conf[:, 1], index=teste.Data)\n",
    "\n",
    "# Plot\n",
    "fig, ax = plt.subplots(figsize=(12, 5))\n",
    "ax.plot(____, ____, label='Observações de fato, usadas para treino')\n",
    "ax.plot(____, ____, label='Comportamento de fato, após %s h'%hora)\n",
    "ax.plot(____, fc_series, label='ARIMA')\n",
    "ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))\n",
    "plt.fill_between(lower_series.index, lower_series, upper_series, \n",
    "                  color='k', alpha=.15)\n",
    "plt.title('Local: '+str(de_para.loc[de_para['Local']==radar,'Descricao'].reset_index(drop=True)[0])+' / Hora: '+hora)\n",
    "plt.legend(loc='upper left', fontsize=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A legenda para as linhas do gráfico é autoexplicativa. \n",
    "\n",
    "Ademais, a área cinza é o intervalo de confiança da previsão,lembre-se, 95%, ou seja, a probabilidade da previsão estar *fora* dessa área é de 5%. A confiança pode ser alterada mudando o valor em `forecast`->`alpha=x` com x entre 0 e 1 (duas células acima)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Considerações Finais\n",
    "\n",
    "Conseguimos, por fim, estimar o tráfego da via em questão no horário desejado, mas é possível prever em outras condições como, por exemplo, em outra [hora](#cell) do dia (tente para as 19:00 e 12:00, veja as diferenças das previsões)\n",
    "\n",
    "\n",
    "- **A qualidade da previsão é comprometida quando o comportamento que queremos prever (dados de teste) é muito mais variável do que o comportamento que o algoritmo está observando (dados de treino)**, casos em que há variação muito abrupta do volume de tráfego. Assim, o treino reduzido (100 lags) torna a previsão impossível.\n",
    "\n",
    "- Outro fato observado é que **as previsões para radares com menor volume de tráfego são mais imprecisas**. Isso deve-se ao fato que a **variação relativa** nesses locais é mais crítica que a variação em pontos mais movimentados. Por exemplo, num cenário onde o volume médio é de _20 veículos a cada 3 minutos_ , a variação de 2 veículos representa um incremento de **10%**. Caso o volume médio fosse de _2 veículos a cada 3 minutos_ , a alteração seria de **100%**. Isso torna a série histórica mais volátil e, portanto, mais difícil de se prever.\n",
    "\n",
    "# Obrigado\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fc_series"
   ]
  }
 ],
 "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.7.6"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}