NN_Prophet_derivatives_code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 646,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Activation\n",
    "from tensorflow.keras import regularizers\n",
    "import tensorflow.random\n",
    "import pandas as pd\n",
    "import numpy as np \n",
    "import matplotlib \n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import metrics\n",
    "import math\n",
    "from math import log\n",
    "from prophet import Prophet\n",
    "from prophet.diagnostics import cross_validation\n",
    "from prophet.diagnostics import performance_metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary of code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code provides a way of predicting functions using discrete derivative regressors.\n",
    "Functions can be predicted either with a neural network or using Facebook Prophet.\n",
    "The prediction can be done in one of two ways (nonrecursively and recursively).\n",
    "\n",
    "For the nonrecursive version, the derivative regressors for future values are calculated after making one pass of predictions without any regressors.\n",
    "Then the future derivatives are calculated using these predictions.\n",
    "\n",
    "For the nonrecursive version, the future predictions are made iteratively, each time with an additional derivative regressor.\n",
    "This may improve the accuracy of the derivatives, leading to better predictions each time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Utilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 614,
   "metadata": {},
   "outputs": [],
   "source": [
    "def derivative(xy_coords):\n",
    "    '''\n",
    "    Parameters:\n",
    "        xy_coords (np array): 0th column is x-coordinates, 1st column is y-coordinates\n",
    "        \n",
    "    Returns:\n",
    "        np array where 0th column is x-coordinates and 1st column is the backwards discrete derivative\n",
    "    '''\n",
    "    sort = np.argsort(xy_coords[:,0]) \n",
    "    xy_coords = xy_coords[sort,:]\n",
    "    x_coords = xy_coords[:,0]\n",
    "    y_coords = xy_coords[:,1]\n",
    "    deriv = [(y_coords[i]-y_coords[i-1])/(x_coords[i]-x_coords[i-1]) for i in range(1,len(xy_coords))]\n",
    "    return np.column_stack((x_coords[1:], deriv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 615,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [2., 3.],\n",
       "       [3., 5.],\n",
       "       [4., 7.]])"
      ]
     },
     "execution_count": 615,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# derivative example:\n",
    "x = [0,1,2,3,4]\n",
    "y = [0,1,4,9,16]\n",
    "xy = np.column_stack((x,y))\n",
    "derivative(xy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 616,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nthderiv(xy_coords_extended, n, original_length):\n",
    "    '''\n",
    "    Parameters:\n",
    "        xy_coords_extended (2-column np array): points to take derivatives of with at least n historical points\n",
    "        n (int): number of backwards discrete derivatives to take\n",
    "        original_length (int): number of points to take derivatives of\n",
    "    \n",
    "    Returns:\n",
    "        derivatives (numpy array): the 0th column has x-coordinates,\n",
    "                                  ith column has the ith backwards discrete derivative\n",
    "    '''\n",
    "    \n",
    "    derivatives = xy_coords_extended[-original_length:, 0]\n",
    "\n",
    "    for i in range(1,n+1):\n",
    "        next_deriv = xy_coords_extended[-original_length - i:, [0,-1]]\n",
    "        for j in range(i):\n",
    "            next_deriv = derivative(next_deriv)\n",
    "        derivatives = np.column_stack((derivatives, next_deriv[:,1]))\n",
    "    return derivatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 617,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  3.,  19.,  12.],\n",
       "       [  4.,  37.,  18.],\n",
       "       [  5.,  61.,  24.],\n",
       "       [  6.,  91.,  30.],\n",
       "       [  7., 127.,  36.]])"
      ]
     },
     "execution_count": 617,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nthderiv example:\n",
    "x = [0,1,2,3,4,5,6,7]\n",
    "y = [0,1,8,27,64,125,216,343]\n",
    "xy = np.column_stack((x,y))\n",
    "nthderiv(xy, 2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 618,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weighted_mape(pred_values, true_values):\n",
    "    '''\n",
    "    Parameters:\n",
    "        pred_values (array): predicted values\n",
    "        true_values (array): correct future values\n",
    "        \n",
    "    Returns:\n",
    "        Weighted MAPE on holdout\n",
    "    '''\n",
    "    abs_differences = np.abs(pred_values - true_values)\n",
    "    return np.sum(abs_differences)/np.abs(np.sum(true_values))\n",
    "\n",
    "\n",
    "def holdout_variance_explained(pred_values, true_values):\n",
    "    '''\n",
    "    Parameters:\n",
    "        pred_values (array): predicted values\n",
    "        true_values (array): correct future values\n",
    "        \n",
    "    Returns:\n",
    "        Percentage of variance explained for holdout\n",
    "    '''\n",
    "    pred_length = len(pred_values)\n",
    "    score = np.sqrt(metrics.mean_squared_error(pred_values[-pred_length:],true_values[-pred_length:]))\n",
    "    variance_explained = ((true_values[:-pred_length].std()-score)/true_values[:-pred_length].std())*100\n",
    "    return variance_explained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 619,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variability(my_array):\n",
    "    '''\n",
    "    Parameters:\n",
    "        my_array (np array)\n",
    "    Returns:\n",
    "        float: variability of values in my_array\n",
    "    '''\n",
    "    my_array = my_array - min(my_array)\n",
    "    my_array = my_array/max(my_array)\n",
    "    sum_square_differences = sum([(my_array[i] - my_array[i-1])**2 for i in range(1, len(my_array))])\n",
    "    return (sum_square_differences/len(my_array))**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensorflow Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 620,
   "metadata": {},
   "outputs": [],
   "source": [
    "# withhold first k values and take derivatives backwards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 621,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_on_array(func, x_coords):\n",
    "    '''\n",
    "    Parameters:\n",
    "        func (function): function to apply to x_coordinates\n",
    "        x_coords (np array): x-coordinates to get function values of\n",
    "    \n",
    "    Returns:\n",
    "        np array of y-values\n",
    "    '''\n",
    "    return np.array([func(x) for x in x_coords])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 623,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creates a neural network with three hidden layers\n",
    "seed = 5\n",
    "def forecast(x_train, y_train, x_pred, dim, layers, neurons):\n",
    "    '''\n",
    "    Parameters:\n",
    "        x_train (numpy array): each row is a single input, contains the appropriate derivatives\n",
    "        y_train (numpy array): k x 1 array of all of the training labels\n",
    "        x_pred (numpy array): array with row length the same as x, used as input for predictions\n",
    "        dim (int): number of columns in x\n",
    "        layers (int): number of layers (excluding output)\n",
    "        neurons (int): total number of neurons\n",
    "    \n",
    "    Returns:\n",
    "        pred (np array): predicted values for x-coordinates in x_pred\n",
    "    \n",
    "    1. Creates a feedforward neural network where each layer is half the size of the previous one\n",
    "    2. Trains the network based on x_train and y_train\n",
    "    3. Returns network output when x_pred is put in the network\n",
    "    '''\n",
    "    \n",
    "    tensorflow.random.set_seed(seed)\n",
    "    \n",
    "    model = Sequential()\n",
    "    layer_size = 2**(layers - 1) * neurons//(2**(layers) - 1)\n",
    "    model.add(Dense(layer_size, input_dim=dim, activation='relu'))\n",
    "    \n",
    "    for i in range(1,layers):\n",
    "        layer_size = 2**(layers - i - 1) * neurons//(2**(layers) - 1)\n",
    "        model.add(Dense(layer_size, activation='relu')) # Add hidden layer half the size of the previous one\n",
    "        \n",
    "    model.add(Dense(1)) # Output\n",
    "    model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "    model.fit(x_train,y_train,verbose=0,epochs=512)\n",
    "    pred = model.predict(x_pred) # generate predicted values (output)\n",
    "    return np.squeeze(pred)\n",
    "\n",
    "def nderiv_extrapolation_nonrecursive(func, x_known, x_pred, n_derivs, layers=3, neurons=2000): \n",
    "    '''\n",
    "    Parameters:\n",
    "        func (function): function to predict\n",
    "        x_known (numpy array): x-coordinates of training data\n",
    "        x_pred (numpy array): x-coordinates to predict at\n",
    "        n_derivs (int): number of derivatives to use\n",
    "        layers (int): number of layers (excluding output)\n",
    "        neurons (int): total number of neurons\n",
    "    \n",
    "    Returns:\n",
    "        weighted_mape (float): weighted mape on holdout\n",
    "    \n",
    "    1. Predict function values for x_pred\n",
    "    2. Create array of backwards derivative regressors\n",
    "    3. Train network again with all but first n_derivs points and predict values for x_pred\n",
    "    4. Return weighted mape\n",
    "    '''\n",
    "    \n",
    "    y_known = func_on_array(func, x_known)\n",
    "    y_future = func_on_array(func, x_pred)\n",
    "    known_length = len(x_known)\n",
    "    pred_length = len(x_pred)\n",
    "    \n",
    "    pred_values = forecast(x_known,y_known, x_pred, 1, layers, neurons)\n",
    "    \n",
    "    if (n_derivs == 0):\n",
    "        return weighted_mape(pred_values, y_future)\n",
    "    \n",
    "    xy_all = np.column_stack((np.concatenate((x_known, x_pred)), np.concatenate((y_known, pred_values))))\n",
    "    all_derivs = nthderiv(xy_all, n_derivs, known_length + pred_length - n_derivs)\n",
    "    x_derivs = all_derivs[:-pred_length,:]\n",
    "    x_derivs_pred = all_derivs[-pred_length:,:]\n",
    "    y_known_truncated = y_known[n_derivs:]\n",
    "\n",
    "    pred_values = forecast(x_derivs, y_known_truncated, x_derivs_pred, n_derivs+1, layers, neurons) # forecast based on added regressors\n",
    "\n",
    "    return weighted_mape(pred_values, y_future)\n",
    "\n",
    "def nderiv_extrapolation_recursive(func, x_known, x_pred, n_derivs, layers=3, neurons=2000): \n",
    "    '''\n",
    "    Parameters:\n",
    "        func (function): function to predict\n",
    "        x_known (numpy array): x-coordinates of training data\n",
    "        x_pred (numpy array): x-coordinates to predict at\n",
    "        n_derivs (int): number of derivatives to use\n",
    "        layers (int): number of layers (excluding output)\n",
    "        neurons (int): total number of neurons\n",
    "    \n",
    "    Returns:\n",
    "        weighted_mape (float): weighted mape on holdout\n",
    "    \n",
    "    1. Predict function values for x_pred\n",
    "    Loop (with an additional derivatve regressor each time):\n",
    "        1. Create array of backwards derivative regressors\n",
    "        2. Update predicted values\n",
    "    3. Train network again with all but first n_derivs points and predict values for x_pred\n",
    "    4. Return weighted mape\n",
    "    '''\n",
    "    \n",
    "    y_known = func_on_array(func, x_known)\n",
    "    y_future = func_on_array(func, x_pred)\n",
    "    known_length = len(x_known)\n",
    "    pred_length = len(x_pred)\n",
    "    \n",
    "    pred_values = forecast(x_known,y_known, x_pred, 1, layers, neurons)\n",
    "    \n",
    "    if (n_derivs == 0):\n",
    "        return weighted_mape(pred_values, y_future)\n",
    "    \n",
    "    for deriv in range(1, n_derivs + 1):\n",
    "        xy_all = np.column_stack((np.concatenate((x_known, x_pred)), np.concatenate((y_known, pred_values))))\n",
    "        all_derivs = nthderiv(xy_all, deriv, known_length + pred_length - deriv)\n",
    "        x_derivs = all_derivs[:-pred_length,:]\n",
    "        x_derivs_pred = all_derivs[-pred_length:,:]\n",
    "        y_known_truncated = y_known[deriv:]\n",
    "        pred_values = forecast(x_derivs, y_known_truncated, x_derivs_pred, deriv + 1, layers, neurons)\n",
    "    \n",
    "    return weighted_mape(pred_values, y_future)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensorflow example on y = sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 625,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(a):\n",
    "    return math.sin(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 626,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:8 out of the last 8 calls to <function Model.make_predict_function.<locals>.predict_function at 0x144c68280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "WARNING:tensorflow:9 out of the last 9 calls to <function Model.make_predict_function.<locals>.predict_function at 0x144c680d0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "WARNING:tensorflow:10 out of the last 10 calls to <function Model.make_predict_function.<locals>.predict_function at 0x144a7faf0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "14.835859696595731"
      ]
     },
     "execution_count": 626,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_known = np.array([i for i in range(200)])\n",
    "x_pred = np.array([i for i in range(200,220)])\n",
    "nderiv_extrapolation_recursive(my_function, x_known, x_pred, n_derivs=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prophet Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 630,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prophet_deriv(df):\n",
    "    '''\n",
    "    Parameters:\n",
    "        df (DataFrame): DataFrame with ['ds'] column (dates) and ['y'] column (values)\n",
    "    \n",
    "    Returns:\n",
    "        diff (DataFrame): DataFrame with ['ds'] column (dates) and ['y'] column (backwards discrete derivatives)\n",
    "    '''\n",
    "    diff = pd.DataFrame()\n",
    "    diff['ds'] = pd.to_datetime(df['ds'])\n",
    "    diff = diff.iloc[1:]\n",
    "    \n",
    "    dates_diff1 = pd.DataFrame(df['ds'][1:])\n",
    "    dates_diff2 = pd.DataFrame(df['ds'][:-1])\n",
    "    dates_diff2.index += 1\n",
    "    dates_diff = (dates_diff1['ds'] - dates_diff2['ds']).dt.days.values\n",
    "    \n",
    "    values_diff1 = pd.DataFrame(df['y'][1:])\n",
    "    values_diff2 = pd.DataFrame(df['y'][:-1])\n",
    "\n",
    "    values_diff2.index += 1\n",
    "    values_diff = (values_diff1['y'] - values_diff2['y']).values\n",
    "\n",
    "    diff['y'] = values_diff/dates_diff\n",
    "    return diff\n",
    "\n",
    "def prophet_nthderiv(df, n, original_length):\n",
    "    '''\n",
    "    \n",
    "    Parameters:\n",
    "        df (DataFrame): DataFrame with ['ds'] column (dates) and ['y'] column (values)\n",
    "    \n",
    "    Returns:\n",
    "        derivatives (DataFrame): DataFrame with ['ds'] column (dates) columns with backwards discrete derivatives\n",
    "    '''\n",
    "    df['ds'] = pd.to_datetime(df['ds'])\n",
    "    derivatives = pd.DataFrame(df['ds'][-original_length:])\n",
    "    for i in range(1,n+1):\n",
    "        next_deriv = df.tail(original_length + i)\n",
    "        for j in range(i):\n",
    "            next_deriv = prophet_deriv(next_deriv)\n",
    "        derivatives['derivative_'+str(j+1)] = next_deriv['y']\n",
    "    return derivatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 631,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use to test Prophet on plain functions\n",
    "def create_df(x, y):\n",
    "    df = pd.DataFrame()\n",
    "    df['ds'] = pd.to_datetime(x, unit='D')\n",
    "    df['y'] = y\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 634,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          ds         y\n",
      "1 1970-01-02  0.841471\n",
      "2 1970-01-03  0.067826\n",
      "3 1970-01-04 -0.768177\n",
      "4 1970-01-05 -0.897923\n",
      "5 1970-01-06 -0.202122\n",
      "6 1970-01-07  0.679509\n",
      "7 1970-01-08  0.936402\n",
      "          ds  derivative_1  derivative_2\n",
      "3 1970-01-04     -0.768177     -0.836004\n",
      "4 1970-01-05     -0.897923     -0.129745\n",
      "5 1970-01-06     -0.202122      0.695801\n",
      "6 1970-01-07      0.679509      0.881631\n",
      "7 1970-01-08      0.936402      0.256893\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "x = [0,1,2,3,4,5,6,7]\n",
    "y = func_on_array(my_function, x)\n",
    "df = create_df(x,y)\n",
    "print(prophet_deriv(df))\n",
    "print(prophet_nthderiv(df,2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 612,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prophetpredict(training_data, future_dates, regressors, retail_data = True):\n",
    "    '''\n",
    "    Parameters:\n",
    "        training_data (DataFrame): DataFrame with ['ds'] column (dates) and ['y'] column (values) for known values\n",
    "        future_dates (list, np array, Series, etc.): dates to predict values at\n",
    "        regressors (DataFrame): regressor values for all points, including points to predict at\n",
    "        retail_data (bool): set to True if running Prophet on real data\n",
    "    \n",
    "    Returns:\n",
    "        forecast (DataFrame): DataFrame with ['ds'] column (dates) and ['yhat'] column (values) for predicted values\n",
    "    '''\n",
    "    future_dates = pd.DataFrame(future_dates)\n",
    "    horizon = len(future_dates.index)\n",
    "\n",
    "    if retail_data:\n",
    "        m = Prophet(yearly_seasonality=True, daily_seasonality=False, weekly_seasonality=False)\n",
    "        m.add_country_holidays(country_name='US')\n",
    "        m.train_holiday_names\n",
    "    else:\n",
    "        m = Prophet(yearly_seasonality=False, daily_seasonality=False, weekly_seasonality=False)\n",
    "    \n",
    "    for col in regressors:\n",
    "        m.add_regressor(col)\n",
    "        \n",
    "    all_input = pd.concat((training_data, regressors.head(training_length)), axis=1)\n",
    "    m.fit(all_input)\n",
    "    all_future_input = pd.concat((future_dates, regressors.tail(horizon)), axis=1)\n",
    "    forecast = m.predict(all_future_input)\n",
    "    return forecast[['ds', 'yhat']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 642,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prophetnderivatives_nonrecursive(training_data, future_data, n_derivs, regressors, retail_data=True):\n",
    "    '''\n",
    "    Parameters:\n",
    "        training_data (DataFrame): DataFrame with ['ds'] column (dates) and ['y'] column (values) for known values\n",
    "        future_dates (list, np array, Series, etc.): dates to predict values at\n",
    "        regressors (DataFrame): regressor values for all points, including points to predict at\n",
    "        retail_data (bool): set to True if running Prophet on real data\n",
    "    \n",
    "    Returns:\n",
    "        forecast (DataFrame): DataFrame with ['ds'] column (dates) and ['yhat'] column (values) for predicted values\n",
    "        \n",
    "    1. Predict future values for future_dates with economic indicators\n",
    "    2. Create DataFrame of backwards derivative regressors and economic indicators\n",
    "    3. Train Prophet again with regressors on all but first n_derivs points and predict values\n",
    "    4. Return weighted mape\n",
    "    '''\n",
    "    training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
    "    future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
    "    training_length = len(training_data)\n",
    "    horizon = len(future_data.index)\n",
    "    forecast = prophetpredict(training_data, future_data['ds'], regressors, retail_data)\n",
    "    \n",
    "    if n_derivs == 0:\n",
    "        return weighted_mape(forecast['yhat'].values, np.array(future_data['y']))\n",
    "    \n",
    "    col_names = [f'derivative_{i+1}' for i in range(n_derivs)]\n",
    "    \n",
    "    forecast.rename(columns={'yhat':'y'}, inplace=True)\n",
    "    forecast.index += training_length\n",
    "    training_and_forecast = pd.concat((training_data, forecast))\n",
    "\n",
    "    all_derivatives = prophet_nthderiv(training_and_forecast, n_derivs, len(training_and_forecast.index)-n_derivs).drop('ds', axis=1)\n",
    "    all_regressors = pd.concat((all_derivatives, regressors.iloc[n_derivs:]), axis=1)\n",
    "    new_training = training_data.iloc[n_derivs:training_length]\n",
    "    \n",
    "    updated_forecast = prophetpredict(new_training, future_data['ds'], all_regressors, retail_data)\n",
    "    return weighted_mape(updated_forecast['yhat'].values, future_data['y'].tail(horizon).values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 643,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prophetnderivatives_recursive(training_data, future_data, n_derivs, regressors, retail_data=True):\n",
    "    '''\n",
    "    Parameters:\n",
    "        training_data (DataFrame): DataFrame with ['ds'] column (dates) and ['y'] column (values) for known values\n",
    "        future_dates (list, np array, Series, etc.): dates to predict values at\n",
    "        regressors (DataFrame): regressor values for all points, including points to predict at\n",
    "        retail_data (bool): set to True if running Prophet on real data\n",
    "    \n",
    "    Returns:\n",
    "        forecast (DataFrame): DataFrame with ['ds'] column (dates) and ['yhat'] column (values) for predicted values\n",
    "    \n",
    "    \n",
    "    1. Predict future values for future_dates with economic indicators\n",
    "    Loop (with an additional derivatve regressor each time):\n",
    "        1. Create DataFrame of backwards derivative regressors and economic indicators\n",
    "        2. Update predicted values\n",
    "    3. Train Prophet again with regressors all but first n_derivs points and predict values\n",
    "    4. Return weighted mape\n",
    "    '''\n",
    "    training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
    "    future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
    "    training_length = len(training_data)\n",
    "    horizon = len(future_data.index)\n",
    "    forecast = prophetpredict(training_data, future_data['ds'], regressors, retail_data)\n",
    "    \n",
    "    if n_derivs == 0:\n",
    "        return weighted_mape(forecast['yhat'].values, np.array(future_data['y']))\n",
    "\n",
    "    for deriv in range(1, n_derivs + 1):\n",
    "        col_names = [f'derivative_{i+1}' for i in range(n_derivs)]\n",
    "        forecast.rename(columns={'yhat':'y'}, inplace=True)\n",
    "        forecast.index += training_length\n",
    "        training_and_forecast = pd.concat((training_data, forecast))\n",
    "\n",
    "        all_derivatives = prophet_nthderiv(training_and_forecast, deriv, len(training_and_forecast.index)-deriv).drop('ds', axis=1)\n",
    "        all_regressors = pd.concat((all_derivatives, regressors.iloc[deriv:]), axis=1)\n",
    "        new_training = training_data.iloc[deriv:training_length]\n",
    "\n",
    "        forecast = prophetpredict(new_training, future_data['ds'], all_regressors, retail_data)\n",
    "    return weighted_mape(forecast['yhat'].values, future_data['y'].tail(horizon).values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sales Data Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 644,
   "metadata": {},
   "outputs": [],
   "source": [
    "salesdata = pd.read_excel('All_Data_Formatted.xlsx', header=1)\n",
    "salesdata = salesdata.rename({'date':'ds'}, axis=1)\n",
    "salesdata = salesdata.iloc[84:204, :]\n",
    "ds = salesdata['ds']\n",
    "sales = salesdata.iloc[:, 1:13]\n",
    "indicators = salesdata.iloc[:, 13:]\n",
    "indicators.reset_index(inplace=True, drop=True)\n",
    "sales = pd.concat((ds, sales), axis=1)\n",
    "sales.reset_index(inplace=True, drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 645,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:14 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:14 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:16 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS 0 0.00964486254705542\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:16 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:18 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:18 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS break_inflate10 0 0.0047503699421485865\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:20 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:20 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS employ_rate 0 0.009315295367897897\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:22 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:22 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS indust_prod 0 0.006063286006654556\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:24 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:25 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS mortgage_rate30 0 0.007313990824114053\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:27 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Sticky_Price_Cpi 0 0.010751641188927028\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:27 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:28 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:28 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS International_Trade 0 0.00732974914288497\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:30 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:30 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Med_Cpi 0 0.009994678480384276\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:32 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:32 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS CPI 0 0.006394557225610731\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:34 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:35 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:36 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:36 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS 1 0.012885664766571112\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:38 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:38 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:40 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:40 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS break_inflate10 1 0.005980950417931104\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:42 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:42 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:45 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:45 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS employ_rate 1 0.012961117625580418\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:47 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:47 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:49 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:49 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS indust_prod 1 0.007346749775035881\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:51 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:51 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:53 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:53 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS mortgage_rate30 1 0.008310869295718058\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:00:55 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:55 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:00:57 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:00:57 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Sticky_Price_Cpi 1 0.014810911632656435\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:00 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:00 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:03 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:03 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS International_Trade 1 0.007569389039850086\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:06 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:06 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:08 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:08 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Med_Cpi 1 0.012621258139070368\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:10 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:10 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:12 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:12 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS CPI 1 0.008592398739069662\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:14 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:14 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:17 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:17 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:20 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS 2 0.013199153319583809\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:20 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:22 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:23 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:25 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:25 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:27 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:27 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS break_inflate10 2 0.006316055609424734\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:30 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:30 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:32 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:32 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:34 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:34 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS employ_rate 2 0.0133759873330199\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:36 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:36 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:38 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:38 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:40 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:40 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS indust_prod 2 0.007696562252077025\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:42 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:42 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:44 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:44 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:46 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:46 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS mortgage_rate30 2 0.008396132069614167\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:48 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:48 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:50 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:50 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:52 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:52 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Sticky_Price_Cpi 2 0.015419799216919296\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:54 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:54 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:01:56 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:56 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:01:57 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:57 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS International_Trade 2 0.008455665427798359\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:01:59 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:01:59 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:01 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:01 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:02:03 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:03 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Med_Cpi 2 0.01341691708708526\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:02:06 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:06 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:09 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:09 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:02:11 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:11 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS CPI 2 0.009035686188962264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:02:14 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:14 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:18 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:18 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:20 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:20 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:02:22 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:22 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS 3 0.0141280622779469\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:02:24 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:24 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:27 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:27 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:30 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:30 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:02:32 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS break_inflate10 3 0.007888114332406014\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:02:33 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:35 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:35 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:38 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:38 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:41 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:41 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:02:43 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS employ_rate 3 0.014588813577111871\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:02:43 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:46 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:46 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:49 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:49 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:02:53 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:54 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:02:55 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:56 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS indust_prod 3 0.008348177838836079\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:02:58 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:02:58 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:01 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:01 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:03 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:03 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:03:06 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS mortgage_rate30 3 0.008500125820726897\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:03:06 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:09 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:09 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:12 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:12 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:15 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:16 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:03:20 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:20 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Sticky_Price_Cpi 3 0.016085441799750223\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:03:23 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:23 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:25 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:25 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:27 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:27 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:03:29 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:29 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS International_Trade 3 0.0067129647980458135\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:03:31 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:31 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:33 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:33 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:35 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:35 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:03:37 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:38 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS Med_Cpi 3 0.014694873445768893\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:03:40 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:40 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:43 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:43 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:45 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:46 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:03:48 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:48 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS CPI 3 0.009281301250795326\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:03:52 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:52 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:54 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:54 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:56 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:56 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:03:59 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:03:59 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:04:02 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS 4 0.015812340474087794\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:04:02 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:05 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:05 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:07 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:07 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:09 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:10 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:12 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:12 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:04:14 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:15 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS break_inflate10 4 0.011912741791850031\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:04:17 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:17 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:18 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:19 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:20 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:21 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:23 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:23 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:04:25 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:25 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS employ_rate 4 0.016056373187319246\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:04:27 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:27 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:29 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:29 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:32 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:32 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:35 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:35 - cmdstanpy - INFO - Chain [1] done processing\n",
      "<ipython-input-643-aabf7bbada85>:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  training_data['ds'] = pd.to_datetime(training_data['ds'])\n",
      "<ipython-input-643-aabf7bbada85>:21: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  future_data['ds'] = pd.to_datetime(future_data['ds'])\n",
      "16:04:37 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:37 - cmdstanpy - INFO - Chain [1] done processing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RSAFS indust_prod 4 0.007835754640182725\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16:04:39 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:40 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:42 - cmdstanpy - INFO - Chain [1] start processing\n",
      "16:04:42 - cmdstanpy - INFO - Chain [1] done processing\n",
      "16:04:44 - cmdstanpy - INFO - Chain [1] start processing\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-645-e0d545feb500>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m         \u001b[0mprophet_results\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mderiv\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mindicator\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mindicators\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprophetnderivatives_recursive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfuture_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mderiv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindicators\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindicator\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m             \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindicator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mderiv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m             \u001b[0mprophet_results\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindicator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mderiv\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-643-aabf7bbada85>\u001b[0m in \u001b[0;36mprophetnderivatives_recursive\u001b[0;34m(training_data, future_data, n_derivs, regressors, retail_data)\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0mnew_training\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtraining_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mderiv\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mtraining_length\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m         \u001b[0mforecast\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprophetpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_training\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfuture_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'ds'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mall_regressors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretail_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     40\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mweighted_mape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mforecast\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'yhat'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfuture_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'y'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtail\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhorizon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-612-1a8fec6b658a>\u001b[0m in \u001b[0;36mprophetpredict\u001b[0;34m(training_data, future_dates, regressors, retail_data)\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mall_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mregressors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhead\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_length\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m     \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mall_input\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m     \u001b[0mall_future_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfuture_dates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mregressors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtail\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhorizon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[0mforecast\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mall_future_input\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/prophet/forecaster.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, df, **kwargs)\u001b[0m\n\u001b[1;32m   1169\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstan_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msampling\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstan_init\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmcmc_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1170\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1171\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstan_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstan_init\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1173\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstan_fit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstan_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstan_fit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/prophet/models.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, stan_init, stan_data, **kwargs)\u001b[0m\n\u001b[1;32m    100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstan_fit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mRuntimeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m             \u001b[0;31m# Fall back on Newton\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/cmdstanpy/model.py\u001b[0m in \u001b[0;36moptimize\u001b[0;34m(self, data, seed, inits, output_dir, sig_figs, save_profile, algorithm, init_alpha, tol_obj, tol_rel_obj, tol_grad, tol_rel_grad, tol_param, history_size, iter, save_iterations, require_converged, show_console, refresh, time_fmt)\u001b[0m\n\u001b[1;32m    722\u001b[0m             \u001b[0mdummy_chain_id\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    723\u001b[0m             \u001b[0mrunset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mRunSet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchains\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtime_fmt\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtime_fmt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 724\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_cmdstan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrunset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdummy_chain_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshow_console\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshow_console\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    726\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mrunset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_retcodes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/cmdstanpy/model.py\u001b[0m in \u001b[0;36m_run_cmdstan\u001b[0;34m(self, runset, idx, show_progress, show_console, progress_hook)\u001b[0m\n\u001b[1;32m   1580\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0mproc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1581\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mproc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstdout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1582\u001b[0;31m                     \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mproc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstdout\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1583\u001b[0m                     \u001b[0mfd_out\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1584\u001b[0m                     \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstrip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "prophet_results = {}\n",
    "horizon = len(sales.index)//10\n",
    "training_length = len(sales.index) - horizon\n",
    "\n",
    "for sale in sales.iloc[:,1:]:\n",
    "    data = sales[['ds', sale]]\n",
    "    data = data.rename(columns={sale: 'y'})\n",
    "    training_data = data.head(training_length)\n",
    "    future_data = data.tail(horizon)\n",
    "    for deriv in range(0,5):\n",
    "        result = prophetnderivatives_recursive(training_data, future_data, deriv, pd.DataFrame())\n",
    "        print(sale, deriv, result)\n",
    "        prophet_results[sale, '', deriv] = result\n",
    "        for indicator in indicators:\n",
    "            result = prophetnderivatives_recursive(training_data, future_data, deriv, pd.DataFrame(indicators[indicator]))\n",
    "            print(sale, indicator, deriv, result)\n",
    "            prophet_results[sale, indicator, deriv] = result"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}