shortened.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:52.760709Z",
     "start_time": "2024-07-02T19:08:38.941359Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import yfinance as yf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from arch import arch_model\n",
    "\n",
    "from sklearn.model_selection import TimeSeriesSplit,GridSearchCV\n",
    "from scikeras.wrappers import KerasRegressor\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "from tensorflow.keras.regularizers import L2\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Input, LSTM, Dense"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Data Processing"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b895fb3b9ce98e80"
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[*********************100%%**********************]  1 of 1 completed\n",
      "[*********************100%%**********************]  1 of 1 completed\n",
      "[*********************100%%**********************]  1 of 1 completed\n",
      "[*********************100%%**********************]  1 of 1 completed\n"
     ]
    }
   ],
   "source": [
    "sp500_prices = yf.download(\"^GSPC\", start='2018-01-05', end='2023-07-01')['Adj Close'].rename('sp500_price')\n",
    "implied_vol = yf.download(\"^VIX\", start='2018-02-01', end='2023-07-01')['Adj Close'].rename('implied_vol')\n",
    "treasury_yield = yf.download(\"^IRX\", start='2018-02-06', end='2023-07-01')['Adj Close'].rename('treasury')\n",
    "volume = yf.download(\"^GSPC\", start='2018-02-06', end='2023-07-01')['Volume'].rename('sp500_vol')\n",
    "\n",
    "merged_data = pd.DataFrame(sp500_prices).join([implied_vol, treasury_yield, volume], how='outer')\n",
    "\n",
    "Sentiment_Index = pd.read_csv(\"Sentiment_Index.csv\", index_col=0)\n",
    "Sentiment_Index.index = pd.to_datetime(Sentiment_Index.index, dayfirst=True)\n",
    "merged_data = merged_data.join(Sentiment_Index, how='outer')\n",
    "\n",
    "merged_data.to_csv('files/data.csv')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:53.974916Z",
     "start_time": "2024-07-02T19:08:52.761161Z"
    }
   },
   "id": "dd79d0cb4496a7b9"
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "merged_data = pd.read_csv('files/data.csv')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:53.978655Z",
     "start_time": "2024-07-02T19:08:53.971584Z"
    }
   },
   "id": "1f6b4afef9c1453d"
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "merged_data.implied_vol = merged_data.implied_vol / (100 * np.sqrt(252))\n",
    "merged_data['returns'] = merged_data.sp500_price/merged_data.sp500_price.shift(1) - 1\n",
    "\n",
    "merged_data['realized_volatility'] = merged_data.returns.rolling(window=21).std()\n",
    "\n",
    "merged_data['target'] = merged_data.implied_vol.shift(-1)\n",
    "merged_data['implied_vol_lag_1'] = merged_data.implied_vol.shift(1)\n",
    "merged_data['implied_vol_lag_2'] = merged_data.implied_vol.shift(2)\n",
    "\n",
    "merged_data = merged_data[21:-1]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:53.990116Z",
     "start_time": "2024-07-02T19:08:53.979066Z"
    }
   },
   "id": "9ffb437d59f28eef"
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "# Splitting into 60:20:20 train:validate:test sets\n",
    "n= len(merged_data)\n",
    "\n",
    "train = merged_data[:round(0.6*n)]\n",
    "validate = merged_data[round(0.6*n):round(0.8*n)]\n",
    "test = merged_data[round(0.8*n):]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:53.990256Z",
     "start_time": "2024-07-02T19:08:53.984613Z"
    }
   },
   "id": "39241ca4ee06fc70"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## GARCH"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d5317481d6d96e3d"
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration:      1,   Func. Count:      6,   Neg. LLF: 85292073677.67297\n",
      "Iteration:      2,   Func. Count:     19,   Neg. LLF: 30122116.535324637\n",
      "Iteration:      3,   Func. Count:     31,   Neg. LLF: 16632.6932224298\n",
      "Optimization terminated successfully    (Exit mode 0)\n",
      "            Current function value: -2609.007627560215\n",
      "            Iterations: 4\n",
      "            Function evaluations: 38\n",
      "            Gradient evaluations: 3\n",
      "                     Constant Mean - GARCH Model Results                      \n",
      "==============================================================================\n",
      "Dep. Variable:                returns   R-squared:                       0.000\n",
      "Mean Model:             Constant Mean   Adj. R-squared:                  0.000\n",
      "Vol Model:                      GARCH   Log-Likelihood:                2609.01\n",
      "Distribution:                  Normal   AIC:                          -5210.02\n",
      "Method:            Maximum Likelihood   BIC:                          -5191.20\n",
      "                                        No. Observations:                  815\n",
      "Date:                Tue, Jul 02 2024   Df Residuals:                      814\n",
      "Time:                        20:08:53   Df Model:                            1\n",
      "                                 Mean Model                                 \n",
      "============================================================================\n",
      "                 coef    std err          t      P>|t|      95.0% Conf. Int.\n",
      "----------------------------------------------------------------------------\n",
      "mu         1.0775e-03  1.598e-04      6.744  1.545e-11 [7.643e-04,1.391e-03]\n",
      "                              Volatility Model                              \n",
      "============================================================================\n",
      "                 coef    std err          t      P>|t|      95.0% Conf. Int.\n",
      "----------------------------------------------------------------------------\n",
      "omega      4.1032e-06  3.342e-12  1.228e+06      0.000 [4.103e-06,4.103e-06]\n",
      "alpha[1]       0.2000  3.502e-02      5.711  1.120e-08     [  0.131,  0.269]\n",
      "beta[1]        0.7800  1.980e-02     39.385      0.000     [  0.741,  0.819]\n",
      "============================================================================\n",
      "\n",
      "Covariance estimator: robust\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anthony.li/Documents/GitHub/Neural-Network-Approach-to-Implied-Volatility-Forecasting/.venv/lib/python3.11/site-packages/arch/univariate/base.py:311: DataScaleWarning: y is poorly scaled, which may affect convergence of the optimizer when\n",
      "estimating the model parameters. The scale of y is 0.0002051. Parameter\n",
      "estimation work better when this value is between 1 and 1000. The recommended\n",
      "rescaling is 100 * y.\n",
      "\n",
      "This warning can be disabled by either rescaling y before initializing the\n",
      "model or by setting rescale=False.\n",
      "\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# Fitting a GARCH(1,1) model\n",
    "garch_model = arch_model(train['returns'], vol='Garch', p=1, q=1)\n",
    "garch_results = garch_model.fit()\n",
    "\n",
    "print(garch_results.summary())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:54.104374Z",
     "start_time": "2024-07-02T19:08:53.988206Z"
    }
   },
   "id": "a8e0a7a318b20f33"
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:2: 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",
      "  train['garch_forecast'] = garch_results.conditional_volatility.values\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:4: 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",
      "  validate['garch_forecast'] = None\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Root Mean Squared Error for the GARCH model is:  0.003925963590286438\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/2068899185.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  validate['garch_forecast'].iloc[i] = forecasted_volatility\n"
     ]
    }
   ],
   "source": [
    "parameters = garch_results.params\n",
    "train['garch_forecast'] = garch_results.conditional_volatility.values\n",
    "last_volatility = garch_results.conditional_volatility.values[-1]\n",
    "validate['garch_forecast'] = None\n",
    "\n",
    "# Obtaining the Garch Forecasted Volatility for Validation data\n",
    "for i in range(len(validate)):\n",
    "    forecasted_volatility = np.sqrt(parameters['omega'] +\n",
    "                                    parameters['alpha[1]'] * validate['returns'].iloc[i]**2 +\n",
    "                                    parameters['beta[1]'] * last_volatility**2)\n",
    "\n",
    "    validate['garch_forecast'].iloc[i] = forecasted_volatility\n",
    "    last_volatility = forecasted_volatility\n",
    "\n",
    "# Calculating OOS-RMSE\n",
    "GARCH_MSE = np.mean((validate.target - validate.garch_forecast) ** 2)\n",
    "GARCH_RMSE = np.sqrt(GARCH_MSE)\n",
    "print(\"The Root Mean Squared Error for the GARCH model is: \", GARCH_RMSE)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:54.183480Z",
     "start_time": "2024-07-02T19:08:54.080724Z"
    }
   },
   "id": "4a2fffe13a3b546e"
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The OOS R-squared is:  0.13739332738492505\n",
      "The OOS Adjusted R-squared is:  0.13418661112985042\n"
     ]
    }
   ],
   "source": [
    "r_squared = r2_score(validate.garch_forecast, validate.target )\n",
    "\n",
    "# Calculating adjusted R-squared\n",
    "n = len(validate.garch_forecast)\n",
    "p = 1\n",
    "adjusted_r_squared = 1 - (1 - r_squared) * (n - 1) / (n - p - 1)\n",
    "\n",
    "print('The OOS R-squared is: ', r_squared)\n",
    "print('The OOS Adjusted R-squared is: ',adjusted_r_squared)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:54.198026Z",
     "start_time": "2024-07-02T19:08:54.177780Z"
    }
   },
   "id": "db946632fd05ebc"
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1200x600 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(train.index, train.implied_vol, label='Implied Volatility - Train', color='blue', linestyle=':', linewidth=2)\n",
    "plt.plot(train.index, train.garch_forecast, label='GARCH Forecast - Train', color='orange', linestyle=':', linewidth=2)\n",
    "plt.plot(validate.index, validate.implied_vol, label='Implied Volatility - Validate', color='blue', linestyle='-', linewidth=2)\n",
    "plt.plot(validate.index, validate.garch_forecast, label='GARCH Forecast - Validate', color='orange', linestyle='-', linewidth=2)\n",
    "\n",
    "plt.xlabel('Date Index')\n",
    "plt.ylabel('Volatility')\n",
    "plt.title('Implied Volatility vs GARCH Conditional Volatility')\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:54.521626Z",
     "start_time": "2024-07-02T19:08:54.188247Z"
    }
   },
   "id": "8396549717d3c8f3"
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:2: 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",
      "  test['garch_forecast'] = None\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
      "\n",
      "df[\"col\"][row_indexer] = value\n",
      "\n",
      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\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",
      "\n",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/484451870.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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",
      "  test['garch_forecast'].iloc[i] = forecasted_volatility\n"
     ]
    }
   ],
   "source": [
    "last_volatility = validate.garch_forecast.values[-1]\n",
    "test['garch_forecast'] = None\n",
    "\n",
    "# Obtaining the Garch Forecasted Volatility for Validation data\n",
    "for i in range(len(test)):\n",
    "    forecasted_volatility = np.sqrt(parameters['omega'] +\n",
    "                                    parameters['alpha[1]'] * test['returns'].iloc[i]**2 +\n",
    "                                    parameters['beta[1]'] * last_volatility**2)\n",
    "\n",
    "    test['garch_forecast'].iloc[i] = forecasted_volatility\n",
    "    last_volatility = forecasted_volatility"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:54.629546Z",
     "start_time": "2024-07-02T19:08:54.572502Z"
    }
   },
   "id": "6d7d0ec8d67d4a4"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## LSTM"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d81a131f179e34ff"
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [
    "input_variables = ['implied_vol', 'treasury', 'sp500_vol',\n",
    "                   'Sentiment_Index', 'returns', 'realized_volatility',\n",
    "                   'implied_vol_lag_1', 'implied_vol_lag_2']"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:54.629657Z",
     "start_time": "2024-07-02T19:08:54.579349Z"
    }
   },
   "id": "5e1e5a29c354f263"
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/1464570711.py:3: 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",
      "  train[input_variables] = scaler.fit_transform(train[input_variables])\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/1464570711.py:4: 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",
      "  validate[input_variables] = scaler.fit_transform(validate[input_variables])\n",
      "/var/folders/kh/_8wngh1d14l0cp2_xfplc2_w0000gr/T/ipykernel_54284/1464570711.py:5: 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",
      "  test[input_variables] = scaler.fit_transform(test[input_variables])\n"
     ]
    }
   ],
   "source": [
    "# Scaling input tensors using Min-Max scaler\n",
    "scaler = MinMaxScaler()\n",
    "train[input_variables] = scaler.fit_transform(train[input_variables])\n",
    "validate[input_variables] = scaler.fit_transform(validate[input_variables])\n",
    "test[input_variables] = scaler.fit_transform(test[input_variables])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-02T19:08:54.629766Z",
     "start_time": "2024-07-02T19:08:54.582642Z"
    }
   },
   "id": "46eb072c8a5045a9"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Rolling Window K-Fold CV for Hyperparameter cross validation"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "259d44c8591b26bb"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 11 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x3146fbb00> 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 reduce_retracing=True option 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:5 out of the last 11 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x3146fbb00> 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 reduce_retracing=True option 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"
     ]
    }
   ],
   "source": [
    "input_data = train[input_variables].values.reshape(train.shape[0], -1, len(input_variables))\n",
    "target_data = train['target'].values\n",
    "\n",
    "def create_model(lstm_1, lstm_2, dense):\n",
    "    model = Sequential()\n",
    "    model.add(Input(shape=(input_data.shape[1], input_data.shape[2])))  # Using Input layer\n",
    "    model.add(LSTM(lstm_1, return_sequences=True))\n",
    "    model.add(LSTM(lstm_2))\n",
    "    model.add(Dense(dense, activation='linear'))\n",
    "    model.add(Dense(1, activation='linear'))\n",
    "    model.compile(optimizer='adam', loss='mean_squared_error')\n",
    "    return model\n",
    "\n",
    "\n",
    "# Defining the grid search of parameters\n",
    "param_grid = {\n",
    "    'model__lstm_1': [32, 64, 128, 256],\n",
    "    'model__lstm_2': [32, 64, 128, 256],\n",
    "    'model__dense': [16, 32, 64, 128]\n",
    "}\n",
    "\n",
    "# Creating a TimeSeriesSplit for cross-validation\n",
    "tscv = TimeSeriesSplit(n_splits=5)\n",
    "model = KerasRegressor(model=create_model, epochs=10, batch_size=32, verbose=0)\n",
    "\n",
    "# Perform grid search with cross-validation\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=tscv)\n",
    "grid_result = grid.fit(input_data, target_data)\n",
    "\n",
    "# Print the best parameters and corresponding accuracy\n",
    "print(\"The Best parameters: \", grid_result.best_params_)"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true,
    "ExecuteTime": {
     "start_time": "2024-07-02T19:08:54.596502Z"
    }
   },
   "id": "408e723dcb0c6116"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "best_model = grid_result.best_estimator_.model_\n",
    "\n",
    "validate_input = validate[input_variables].values.reshape(validate.shape[0], -1, len(input_variables))\n",
    "validate_output = validate['target'].values\n",
    "\n",
    "\n",
    "# Calculating OOS RMSE\n",
    "NN_predictions = best_model.predict(validate_input)\n",
    "\n",
    "NN_mse = np.mean((validate_output - NN_predictions.flatten()) ** 2)\n",
    "NN_rmse = np.sqrt(NN_mse)\n",
    "print(\"The Root Mean Squared Error for the Neural Network model is: \", NN_rmse)"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "6eca05165505592b"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "NN_r_squared = r2_score(NN_predictions, validate_output)\n",
    "\n",
    "n = len(validate_output)\n",
    "p = 8\n",
    "NN_adjusted_r_squared = 1 - (1 - NN_r_squared) * (n - 1) / (n - p - 1)\n",
    "\n",
    "print('The OOS R-squared is: ', NN_r_squared)\n",
    "print('The OOS Adjusted R-squared is: ', NN_adjusted_r_squared)"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "2db797b856962e93"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Plotting actual IV against NN forecasted IV for test set\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(validate.index,validate_output, label='Implied Volatility')\n",
    "plt.plot(validate.index,NN_predictions, label='NN Forecast')\n",
    "plt.xlabel('Date Index')\n",
    "plt.ylabel('Implied Volatility')\n",
    "plt.title('Actual vs Predicted values')\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "db54b2094f96a045"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Extracting the optimal hyperparameters\n",
    "LSTM1 = grid_result.best_params_['model__lstm_1']\n",
    "LSTM2 = grid_result.best_params_['model__lstm_2']\n",
    "DENSE = grid_result.best_params_['model__dense']\n",
    "\n",
    "# Defining NN model with the addition of L2 Regularization\n",
    "model_REG = Sequential([\n",
    "    LSTM(LSTM1, input_shape=(input_data.shape[1], input_data.shape[2]), return_sequences=True, kernel_regularizer= L2(0.001)),\n",
    "    LSTM(LSTM2),\n",
    "    Dense(DENSE, activation = 'linear'),\n",
    "    Dense(1, activation = 'linear')\n",
    "])\n",
    "\n",
    "# Compiling the model\n",
    "model_REG.compile(optimizer='adam', loss='mean_squared_error')\n",
    "\n",
    "# Training the model on the Training dataset\n",
    "history_REG = model_REG.fit(input_data, target_data, epochs=10, batch_size=64, validation_data=(validate_input, validate_output))\n",
    "\n",
    "# Predicting the OOS Implied Volatility using NN model\n",
    "NN_REG_predictions = model_REG.predict(validate_input)\n",
    "\n",
    "# Calculating OOS RMSE\n",
    "NN_REG_mse = np.mean((validate_output - NN_REG_predictions.flatten()) ** 2)\n",
    "NN_REG_rmse = np.sqrt(NN_REG_mse)\n",
    "print(\"The Root Mean Squared Error for the Neural Network model is: \", NN_REG_rmse)\n"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "4e778189abcd8cdc"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "NN_r_squared = r2_score(validate_output, NN_REG_predictions)\n",
    "\n",
    "n = len(validate_output)\n",
    "p = 8\n",
    "NN_adjusted_r_squared = 1 - (1 - NN_r_squared) * (n - 1) / (n - p - 1)\n",
    "\n",
    "print('The OOS R-squared is: ', NN_r_squared)\n",
    "print('The OOS Adjusted R-squared is: ', NN_adjusted_r_squared)"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "3b3a1b1417eaafaa"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Plot the true IV against the NN forecasted IV for test data\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(validate.index,validate_output, label='Implied Volatility')\n",
    "plt.plot(validate.index,NN_REG_predictions, label='NN Forecast')\n",
    "plt.xlabel('Date Index')\n",
    "plt.ylabel('Implied Volatility')\n",
    "plt.title('Actual vs Predicted values')\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "4d1324f4d5934ece"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Unseen Test Data: GARCH vs LSTM with hyperparameter optimisation vs LSTM with hyperparameter optimisation and regularization"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b34f4f3c53d0aeb5"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "test_input = test[input_variables].values.reshape(test.shape[0], -1, len(input_variables))\n",
    "test_output = test['target'].values\n",
    "\n",
    "\n",
    "# Calculating OOS RMSE\n",
    "NN_test_predictions = best_model.predict(test_input)\n",
    "NN_REG_test_predictions = model_REG.predict(test_input)"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "cab428b79ec4e38c"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Plot the true IV against the NN forecasted IV for test data\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(test.index,test_output, label='Implied Volatility')\n",
    "plt.plot(test.index,NN_test_predictions, label='NN Forecast')\n",
    "plt.plot(test.index,NN_REG_test_predictions, label='NN with Regularization Forecast')\n",
    "plt.plot(test.index,test.garch_forecast, label='GARCH')\n",
    "plt.xlabel('Date Index')\n",
    "plt.ylabel('Implied Volatility')\n",
    "plt.title('Actual vs Predicted values')\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "398b79c3f4ec5345"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Improvements\n",
    "Since time and length of the report was a constraint, I was unable to look at other variables and architectures that could lead to better forecasts. Further analysis could be done on validating the model by looking at the ICE and PDP plots.\n",
    "\n",
    "Additionally, a rolling window training period would likely perform better as it will take in the latest available information which will better tune the parameters. However, this would be computationally expensive as Neural Networks are complex architectures with exponentially large number of computations.\n",
    "\n",
    "Given the recent research in gradient boosting, I believe a gradient boosted regression model could potentially outperform all models discussed in this project."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ffbbf9470ef006ff"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   },
   "id": "c9f765429d5cf9c7"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}