{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Practice Session 09: Forecasting\n", "\n", "In this session we will do some time series forecasting on a weather-related time series, which contains temperature, precipitation, and wind speed data for the Barcelona airport. \n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Author: Your name here\n", "\n", "E-mail: Your e-mail here\n", "\n", "Date: The current date here" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import io\n", "import json\n", "import pandas as pd\n", "import datetime\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import scipy.stats as stats\n", "from sklearn.linear_model import LinearRegression\n", "from sklearn.metrics import mean_squared_error\n", "import math" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 1. Dataset" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The dataset we will use is was obtained from [AEMET's Open Data](https://opendata.aemet.es/centrodedescargas/inicio) initiative. Anyone can request an API Key and then use their services to obtain climatological variables (\"*valores climatológicos*\").\n", "\n", "We will read it into a dataframe using Pandas' [read_csv](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html) function.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
fechaindicativonombreprovinciaaltitudtmedprectminhoratmintmaxhoratmaxdirvelmediarachahorarachasolpresMaxhoraPresMaxpresMinhoraPresMin
02016-07-010201DBARCELONABARCELONA624,10,021,903:4026,311:5099.03,15,810:50NaNNaNNaNNaNNaN
12016-07-020201DBARCELONABARCELONA624,60,022,304:4027,011:5013.03,67,512:10NaNNaNNaNNaNNaN
22016-07-030201DBARCELONABARCELONA623,40,021,911:0024,908:1020.04,28,908:50NaNNaNNaNNaNNaN
32016-07-040201DBARCELONABARCELONA623,80,021,804:4025,910:3025.03,36,723:20NaNNaNNaNNaNNaN
42016-07-050201DBARCELONABARCELONA625,30,023,200:1027,414:0035.03,16,402:00NaNNaNNaNNaNNaN
\n", "
" ], "text/plain": [ " fecha indicativo nombre provincia altitud tmed prec tmin \\\n", "0 2016-07-01 0201D BARCELONA BARCELONA 6 24,1 0,0 21,9 \n", "1 2016-07-02 0201D BARCELONA BARCELONA 6 24,6 0,0 22,3 \n", "2 2016-07-03 0201D BARCELONA BARCELONA 6 23,4 0,0 21,9 \n", "3 2016-07-04 0201D BARCELONA BARCELONA 6 23,8 0,0 21,8 \n", "4 2016-07-05 0201D BARCELONA BARCELONA 6 25,3 0,0 23,2 \n", "\n", " horatmin tmax horatmax dir velmedia racha horaracha sol presMax \\\n", "0 03:40 26,3 11:50 99.0 3,1 5,8 10:50 NaN NaN \n", "1 04:40 27,0 11:50 13.0 3,6 7,5 12:10 NaN NaN \n", "2 11:00 24,9 08:10 20.0 4,2 8,9 08:50 NaN NaN \n", "3 04:40 25,9 10:30 25.0 3,3 6,7 23:20 NaN NaN \n", "4 00:10 27,4 14:00 35.0 3,1 6,4 02:00 NaN NaN \n", "\n", " horaPresMax presMin horaPresMin \n", "0 NaN NaN NaN \n", "1 NaN NaN NaN \n", "2 NaN NaN NaN \n", "3 NaN NaN NaN \n", "4 NaN NaN NaN " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# LEAVE AS-IS\n", "\n", "INPUT_FILE = \"aemet-barcelona-airport-2016-2022.json\"\n", "weather = pd.read_json(INPUT_FILE)\n", "\n", "weather.head(5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The columns on this dataset are as follows:\n", "\n", "| id | description | data_type | units |\n", "| ----------- | ------------------------------------------------------------------- | ---------- | --------------------------- |\n", "| fecha | date (AAAA-MM-DD) | string | |\n", "| indicativo | *indicativo climatológico* | string | |\n", "| nombre | name (location) of the station | string | |\n", "| provincia | province of the station | string | |\n", "| altitud | altitude of the station above sea level | float | m |\n", "| tmed | average daily temperature | float | grados celsius |\n", "| prec | daily rainfall from 07 to 07 | float | mm (Ip = less than 0.1 mm) |\n", "| tmin | minimum temperature of the day | float | ºC |\n", "| horatmin | hour and minute of minimum temperature | string | UTC |\n", "| tmax | maximum temperature of the day | float | ºC |\n", "| horatmax | hour and minute of maximum temperature | string | UTC |\n", "| dir | direction of the fastest wind gust | float | decenas de grado |\n", "| velmedia | average wind speed | float | m/s |\n", "| racha | fastest wind gust | float | m/s |\n", "| horaracha | hour and minute of fastest wind gust | string | UTC |\n", "| sol | hours of sun | float | hours |\n", "| presmax | maximum pressure at the level of reference of the station | float | hPa |\n", "| horapresmax | hour of maximum pressure (rounded to nearest hour) | string | UTC |\n", "| presmin | minimum pressure at the level of reference of the station | float | hPa |\n", "| horapresmin | hour of minimum pressure (rounded to nearest hour) | string | UTC\n", "\n", "Next, we will rename columns so that more people can understand their names, using the following equivalence:\n", "\n", "(Remove this cell when delivering.)\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "COLUMN_NAMES = {\n", " \"fecha\" : \"date\",\n", " \"indicativo\" : \"station_num\",\n", " \"nombre\" : \"station_name\",\n", " \"provincia\" : \"station_province\",\n", " \"altitud\" : \"station_altitude\",\n", " \"tmed\" : \"temp_avg\",\n", " \"tmin\" : \"temp_min\",\n", " \"tmax\" : \"temp_max\",\n", " \"horatmin\" : \"time_temp_min\",\n", " \"horatmax\" : \"time_temp_max\",\n", " \"prec\" : \"rainfall\",\n", " \"dir\" : \"windspeed_dir\",\n", " \"velmedia\" : \"windspeed_avg\",\n", " \"racha\" : \"windspeed_gusts\",\n", " \"horaracha\" : \"time_windspeed_gusts\",\n", " \"sol\" : \"sun\",\n", " \"presMax\" : \"pressure_max\",\n", " \"horaPresMax\" : \"time_pressure_max\",\n", " \"presMin\" : \"pressure_min\",\n", " \"horaPresMin\" : \"time_pressure_min\"\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code to rename column names, and print the first 5 rows of the data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code to drop the station_num, station_name, station_province, station_altitude, and time_* columns, which we will not use, and print the first 5 rows of the data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we need to process the numerical data. First, create a function ``str_commas_to_float(x)`` that converts numbers with commas, possibly represented as strings, into floating point numbers.\n", "\n", "Please follow the specification above to interpret ``Ip`` as 0.0. Everything else should be converted into a not-a-number (``np.nan``).\n", "\n", "Please note that this dataset contains many gaps as an instrument may malfunction, or some variable might not be recorded properly on a given day.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code implementing *str_commas_to_float*." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Test it with the following cases:\n", "\n", "* When giving an empty string, the string \"Varias\", or the string \"06:30\", the function should return not a number.\n", "* With the strings \"0,0\" and \"Ip\", it should return a zero.\n", "* With a decimal string using a comma (e.g., \"13,5\") it should return the corresponding number (13.5)\n", "* With an integer as a string (e.g., \"13\") it should return the corresponding number (13.0)\n", "\n", "Use the assert function to do these tests, e.g.:\n", "\n", "```python\n", "assert 1 + 1 == 2\n", "```\n", "\n", "Use the function [numpy.isnan](https://numpy.org/doc/stable/reference/generated/numpy.isnan.html) to test whether something is a NaN (not a number) or not.\n", "\n", "```python\n", "assert np.isnan(...)\n", "```\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code testing *str_commas_to_float*." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Apply this function to columns 'temp_min', 'temp_max', 'temp_avg', 'rainfall', 'windspeed_dir', 'windspeed_avg', 'windspeed_gusts', 'sun', 'pressure_min', 'pressure_max'.\n", "\n", "To apply function *f* to column *c* of dataframe *df*, we use `df[c] = df[c].apply(f)`.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code applying the above function to the specified columns." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The next code indexes the data by date.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
temp_avgrainfalltemp_mintemp_maxwindspeed_dirwindspeed_avgwindspeed_gustssunpressure_maxpressure_min
date
2016-07-0124.10.021.926.399.03.15.8NaNNaNNaN
2016-07-0224.60.022.327.013.03.67.5NaNNaNNaN
2016-07-0323.40.021.924.920.04.28.9NaNNaNNaN
\n", "
" ], "text/plain": [ " temp_avg rainfall temp_min temp_max windspeed_dir \\\n", "date \n", "2016-07-01 24.1 0.0 21.9 26.3 99.0 \n", "2016-07-02 24.6 0.0 22.3 27.0 13.0 \n", "2016-07-03 23.4 0.0 21.9 24.9 20.0 \n", "\n", " windspeed_avg windspeed_gusts sun pressure_max pressure_min \n", "date \n", "2016-07-01 3.1 5.8 NaN NaN NaN \n", "2016-07-02 3.6 7.5 NaN NaN NaN \n", "2016-07-03 4.2 8.9 NaN NaN NaN " ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# LEAVE AS-IS\n", "\n", "weather.set_index('date', inplace=True)\n", "weather.index = pd.to_datetime(weather.index)\n", "weather.head(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following functions, which you can leave as-is, are useful for plotting.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "# Configure font sizes\n", "plt.rc('font', size=10) \n", "plt.rc('axes', labelsize=16)\n", "plt.rc('legend', fontsize=16)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "# Plot function\n", "def plot(df, column, xlabel='Date', ylabel=''):\n", " \n", " # Create a figure\n", " plt.figure(figsize=(16,5))\n", "\n", " # Plot for dates\n", " plt.plot_date(df.index, df[column],\n", " fmt='.-', color='black')\n", "\n", " # Label axis\n", " plt.xlabel(xlabel)\n", " plt.ylabel(ylabel)\n", "\n", " plt.show()\n", "\n", "\n", "def plot_min_avg_max(df, min_column='temp_min', avg_column='temp_avg', max_column='temp_max', xlabel='Date', ylabel='Daily temperature [C]'):\n", "\n", " # Create a figure\n", " plt.figure(figsize=(16,5))\n", "\n", " # Plot for dates\n", " plt.plot_date(df.index, df[avg_column],\n", " fmt='.-', color='black', label='Average')\n", " plt.fill_between(df.index, df[min_column], df[max_column],\n", " color='lightgray')\n", " plt.legend()\n", "\n", " # Label axis\n", " plt.xlabel(xlabel)\n", " plt.ylabel(ylabel)\n", "\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now plot some values. Note that there are gaps in the temperature series, particularly on the first half of 2018.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# LEAVE AS-IS\n", "\n", "# Retrieve the last 7 years\n", "weather_sample = weather.tail(7*365)\n", "\n", "# Plot temperature\n", "plot_min_avg_max(weather_sample)\n", "\n", "# Plot precipitation\n", "plot(weather_sample, \"rainfall\", ylabel=\"Daily precipitation [mm]\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary on these two plots. Answer the following: is seasonality clear in both of them, on one of them?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 1. Smooth this series\n", "\n", "The original series has strong variations from one day to the next one, so we will smooth the series before using it. Here we will use three smoothing methods: moving averages, binning by floating time periods, and binning by calendar time periods.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.1 Smooth the series using moving averages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will compute a moving average of the previous `window_size` days (e.g., 7) as a way of smoothing the time series. Create a function `moving_average(df, window_size)` that computes a **moving average on all columns** of the given dataframe, and returs a new dataframe with the averages. This function can assume that all columns in the input dataframe are numeric.\n", "\n", "A possible implementation is to iterate through numbers from `0` to `len(df)` and create a sub-dataframe of up to `window_size` rows with the corresponding rows. If you choose to implement in this way, you can use the following template:\n", "\n", "```python\n", "def moving_average(df, window_size):\n", "\n", " smoothed = pd.DataFrame(columns=df.columns)\n", "\n", " for i in range(len(df)):\n", " # YOUR CODE HERE\n", " \n", " smoothed.set_index(df.index, inplace=True)\n", " \n", " return smoothed\n", "```\n", "\n", "The following might be helpful:\n", "\n", "* `len(df)` to obtain the length of a data frame\n", "* `df.iloc[a:b]` to return rows from *a* to *b* on a dataframe.\n", "* `df.mean()` to obtain a series containing the averages of all columns in a dataframe.\n", "\n", "If you feel more comfortable working with matrices, you can also use matrices instead of dataframes, and you can also instead of creating a sub-dataframe compute in-place.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your implementation of \"moving_average\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Apply this code over the `weather` correct by verifying the following:\n", "\n", "* For day 1, it should be equivalent to the original series\n", "* For day 2, it should be the average of the first two days of the original series\n", "* For day 7, it should be the average of the first 7 days of the original series\n", "* For day 8, it should be the average of the second to the eight day of the original series\n", "* For the last day, it should be the average of the last 7 days in the series\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n", "/var/folders/pl/vf44jbfn4xxc621svk132sx00000gn/T/ipykernel_76126/1905647745.py:14: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " smoothed = smoothed.append(average, ignore_index=True)\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
temp_avgrainfalltemp_mintemp_maxwindspeed_dirwindspeed_avgwindspeed_gustssunpressure_maxpressure_min
date
2016-07-0124.1000000.00000021.90000026.30000099.0000003.1000005.800000NaNNaNNaN
2016-07-0224.3500000.00000022.10000026.65000056.0000003.3500006.650000NaNNaNNaN
2016-07-0324.0333330.00000022.03333326.06666744.0000003.6333337.400000NaNNaNNaN
2016-07-0423.9750000.00000021.97500026.02500039.2500003.5500007.225000NaNNaNNaN
2016-07-0524.2400000.00000022.22000026.30000038.4000003.4600007.060000NaNNaNNaN
2016-07-0624.5000000.00000022.36666726.66666735.3333333.7166677.833333NaNNaNNaN
2016-07-0724.6285710.00000022.55714326.72857144.4285713.7428578.185714NaNNaNNaN
2016-07-0824.9285710.01428622.85714327.02857133.5714293.6571438.871429NaNNaNNaN
2016-07-0925.2142860.01428623.21428627.24285734.2857143.5857148.757143NaNNaNNaN
2016-07-1025.7000000.01428623.64285727.77142934.1428573.6571438.800000NaNNaNNaN
\n", "
" ], "text/plain": [ " temp_avg rainfall temp_min temp_max windspeed_dir \\\n", "date \n", "2016-07-01 24.100000 0.000000 21.900000 26.300000 99.000000 \n", "2016-07-02 24.350000 0.000000 22.100000 26.650000 56.000000 \n", "2016-07-03 24.033333 0.000000 22.033333 26.066667 44.000000 \n", "2016-07-04 23.975000 0.000000 21.975000 26.025000 39.250000 \n", "2016-07-05 24.240000 0.000000 22.220000 26.300000 38.400000 \n", "2016-07-06 24.500000 0.000000 22.366667 26.666667 35.333333 \n", "2016-07-07 24.628571 0.000000 22.557143 26.728571 44.428571 \n", "2016-07-08 24.928571 0.014286 22.857143 27.028571 33.571429 \n", "2016-07-09 25.214286 0.014286 23.214286 27.242857 34.285714 \n", "2016-07-10 25.700000 0.014286 23.642857 27.771429 34.142857 \n", "\n", " windspeed_avg windspeed_gusts sun pressure_max pressure_min \n", "date \n", "2016-07-01 3.100000 5.800000 NaN NaN NaN \n", "2016-07-02 3.350000 6.650000 NaN NaN NaN \n", "2016-07-03 3.633333 7.400000 NaN NaN NaN \n", "2016-07-04 3.550000 7.225000 NaN NaN NaN \n", "2016-07-05 3.460000 7.060000 NaN NaN NaN \n", "2016-07-06 3.716667 7.833333 NaN NaN NaN \n", "2016-07-07 3.742857 8.185714 NaN NaN NaN \n", "2016-07-08 3.657143 8.871429 NaN NaN NaN \n", "2016-07-09 3.585714 8.757143 NaN NaN NaN \n", "2016-07-10 3.657143 8.800000 NaN NaN NaN " ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# LEAVE AS-IS\n", "\n", "window_size = 7\n", "\n", "weather_smoothed = moving_average(weather, window_size)\n", "\n", "weather_smoothed.head(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we plot the resulting series, observing that it is, well, smoother.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6wAAAE9CAYAAAAPnu+LAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAACRW0lEQVR4nO3deZgU1dk28PvM9PQsMCzDOqAyEEEBFVQUC1kGJmLcIqivxg1jTAbUxBh9A8boG7O4QDQxMYjTRhNN1KhBMZ9xn9CgUoqIoiJRVBYX9kVGgVnP90fPKaqrq7prenqp7rp/1zXXTFf3dJ+urq6qp85zniOklCAiIiIiIiLymoJsN4CIiIiIiIjIDgNWIiIiIiIi8iQGrERERERERORJDFiJiIiIiIjIkxiwEhERERERkScxYCUiIiIiIiJPCmS7AW707t1bVlVVZbsZRERERERElAZvvvnmdillH+vynAhYq6qqsGLFimw3g4iIiIiIiNJACLHBbjlTgomIiIiIiMiTGLASERERERGRJzFgJSIiIiIiIk9iwEpERERERESexICViIiIiIiIPIkBKxEREREREXkSA1YiIiIiIiLyJAasRERERERE5ElpC1iFECVCiOVCiFVCiNVCiF+2Lx8shHhdCPGREOJRIUQwXW0gIiLKV6FQCCNGjMDIkSMRCoWy3RwiIqK0CKTxuRsBTJFSfiWEKALwihDiWQDXAPi9lPIfQoh7AFwGYEEa20FERJRXQqEQZs6cadxWf9fW1marSURERGmRth5WGfFV+82i9h8JYAqAf7YvfwDAtHS1gYiIKB899thjMcsWLlyYhZYQERGlV1rHsAohCoUQbwPYCuBFAB8D2C2lbGl/yGcABqazDURERPnm9NNPj1l29tlnZ6ElRERE6ZXWgFVK2SqlHA3gIADHAzjc7f8KIWqFECuEECu2bduWriYSERHlnBkzZhh/B4NB1NXVMR2YiIjyUkaqBEspdwNYDEAD0EMIocbOHgTgc4f/CUkpx0gpx/Tp0ycTzSQiIsoJUkrj78rKSgarRESUt9JZJbiPEKJH+9+lAE4CsAaRwPWc9oddAuCpdLWBiIgoH5kD1v3792exJUREROmVzirBlQAeEEIUIhIYPyalfFoI8T6AfwghfgPgLQD3pbENREREeaetrQ0AEAgEGLASEVFeS1vAKqV8B8DRNss/QWQ8KxERESVB9bCWlpYyYCUioryWkTGsRERElDoqYC0rK0NjY2NUijAREVE+YcBKRESUY1RKcGlpKQCgsbExm80hIiJKGwasREREOcacEgyw8BIREeUvBqxEREQ5xpwSDAD79u3LZnOIiIjShgErERFRjrGmBLOHlYiI8hUDViIiohyjeljV2NXXXnstm80hIiJKGwasREREOUYFrG+++SYA4NJLL4Wu69lsEhERUVowYCUiIsoxKiVY/W5ubkY4HM5ii4iIiNKDASsREVGOUT2shYWFAICioiJUV1dnsUVERETpwYCViIgox6iAderUqQCAP/zhD9A0LZtNIiIiSgsGrERERDlGpQL3798fADBixIhsNoeIiChtGLASERHlGNXDWlBQEHWbiIgo3zBgJSIiyjEMWImIyC8YsBIREeUYlRKsii4xYCUionzFgJWIiCjHWKsEqwCWiIgo3zBgJSIiyjFMCSYiIr9gwEpERJRjmBJMRER+wYCViIgox7CHlYiI/IIBKxERUY7hGFYiIvILBqxEREQ5hinBRETkFwxYiYiIcgxTgomIyC8YsBIREeUYa0owA1YiIspXDFiJiIhyjDUlmGNYiYgoXzFgJSIiyjFMCSYiIr9gwEpERJRjGLASEZFfMGAlIiLKMawSTEREfsGAlYiIKMdwHlYiIvILBqxEREQ5hinBRETkFwxYiYiIcgxTgomIyC8YsBIREeUY9rASEZFfBJzuEEK84+L/t0kpa1LYHiIiIkqAY1iJiMgvHANWAIUATo1zvwDwr9Q2h4iIiBJhSjAREflFvIB1ppRyQ7x/FkJcEee+gwE8CKAfAAkgJKX8gxDiJgA/ALCt/aHXSymf6VCriYiIfIwpwURE5BeOAauU8pVE/5zgMS0ArpVSrhRClAN4UwjxYvt9v5dS3t6xphIRERHAgJWIiPwjYdElIcTpQoi3hBA7hRB7hBANQog9if5PSrlJSrmy/e8GAGsADOx8k4mIiPyNKcFEROQXbqoE3wngEgC9pJTdpJTlUspuHXkRIUQVgKMBvN6+6IdCiHeEEPcLIXp25LmIiIj8jkWXiIjIL9wErJ8CeE8meflWCNEVwEIAV0sp9wBYAOAbAEYD2ATgDof/qxVCrBBCrNi2bZvdQ4iIiHyJKcFEROQX8YouKbMBPCOEWAKgUS2UUv4u0T8KIYoQCVYfklI+0f5/W0z33wvgabv/lVKGAIQAYMyYMTwSExERtWNKMBER+YWbgPVmAF8BKAEQdPvEQggB4D4Aa8zBrRCiUkq5qf3mdADvuW8uERERsYeViIj8wk3AOkBKeUQSz30igIsBvCuEeLt92fUAzhdCjEZkqpv1AGYm8dxERES+xTGsRETkF24C1meEEFOllC905Inbp7wRds/XkechIiKiaEwJJiIiv3BTdOlyAM8JIfZ1ZFobIiIiSg+mBBMRkV8k7GGVUpZnoiFERETkjjUlmAErERHlKzcpwRBCHAWgyvx4VfWXiIiIMsuaEswxrERElK8SBqxCiPsBHAVgNQB1RJQAGLASERFlAVOCiYjIL9z0sJ4gpRyR9pYQERGRKwxYiYjIL9wUXdKFEAxYiYiIPIJVgomIyC/c9LA+iEjQuhlAIyJT1Ugp5VFpbRkRERHZ4jysRETkF24C1vsAXAzgXRwYw0pERERZwpRgIiLyCzcB6zYp5b/S3hIiIiJyhSnBRETkF24C1reEEA8D+H+IpAQD4LQ2RERE2cIeViIi8gs3AWspIoHqVNMyTmtDRESUJRzDSkREfpEwYJVSXpqJhhAREZE7TAkmIiK/cJzWRghRm+if3TyGiIiIUospwURE5BfxelivE0Jsj3O/APBjAKHUNomIiIjisaYEM2AlIqJ8FS9gXQLgjAT//2IK20JEREQuWFOCOYaViIjylWPAyrGrRERE3sSUYCIi8gvHMaxERETkTQxYiYjILxiwEhER5RhWCSYiIr9gwEpERJRjOA8rERH5heMYViHENfH+UUr5u9Q3h4iIyBtCoRBuueUW7Nu3D9/97ncxd+7cbDfJwJRgIiLyi3hVgsvbfx8G4DgA/2q/fQaA5elsFBERUTaFQiHMnDnTuD1v3jwA8EzQypRgIiLyC8eUYCnlL6WUvwRwEIBjpJTXSimvBXAsgEMy1UAiIqJMe/jhh2OWPfHEE1loiT32sBIRkV+4GcPaD0CT6XZT+zIiIqK8NGXKlJhlZ511VhZaYo9jWImIyC/cBKwPAlguhLhJCHETgNcBPJDWVhEREWXRt7/9bQBAly5dAMBzY1iZEkxERH6RMGCVUt4M4FIAu9p/LpVS3pLuhhEREWXL3r17AQCXXHIJAOBHP/pRNpsTQwWoQoio20RERPnG7bQ2ZQD2SCn/AOAzIcTgNLaJiIgoq/bt2wfgQA+r11JuzWNYhRAMWImIKG8lDFiFEL8AMAfAz9oXFQH4ezobRURElE0qYO3atSsA7wWsqj1CCAghPNc+IiKiVHHTwzodwLcBfA0AUsovcGDKGyIioryjUoK93sOqAlb2sBIRUb5yE7A2yciRUAKAEKJLeptERESUXaqHtaysDID3xogyJZiIiPzCTcD6mBCiDkAPIcQPALwE4N70NouIiCh7ci0lmAErERHlq0CiB0gpbxdCnARgD4DDAPyflPLFtLeMiIgoS3IpJbigoMBz7SMiIkqVhAErALQHqAxSiYjIFz744AMAwIYNGwB4N2BlSjAREeU7N1WCzxJCrBVCfCmE2COEaBBC7HHxfwcLIRYLId4XQqwWQvy4fXmFEOLF9ud8UQjRMxVvhIiIKBV0Xcf9998PAPjZzyIF8r0WsDIlmIiI/MLNGNZ5AL4tpewupewmpSyXUnZz8X8tAK6VUo4AcAKAK4UQIwBcB6BeSjkUQH37bSIiIk8Ih8NobW0FADQ3NwPwbtElBqxERJTv3ASsW6SUazr6xFLKTVLKle1/NwBYA2AggDMBPND+sAcATOvocxMREaVLdXU1CgsLAQBFRUUAvNfDak4JLigoYMBKRER5yzFgbU8FPgvACiHEo0KI89Wy9uWuCSGqABwN4HUA/aSUm9rv2gygX5JtJyIiSjlN03DWWWchGAzij3/8IwDvBazWlGCvtY+IiChV4hVdOsP0914AU023JYAn3LyAEKIrgIUArpZS7hFCHHgSKaUQwvaysBCiFkAtABxyyCFuXoqIiCglKisrUVJSgqOOOgqA9wLWjRs3AgBee+01pgQTEVFecwxYpZSXAoAQ4kQp5avm+4QQJ7p5ciFEESLB6kNSShXgbhFCVEopNwkhKgFsdXj9EIAQAIwZM4ZHYiIiypi2tjYj3Vbd9gpd1/HAA5GRNSeddBJTgomIKK+5GcN6l8tlUUSkK/U+AGuklL8z3fUvAJe0/30JgKdctIGIiChjpJRGui3grYDVXBSqqakJra2tDFiJiChvOfawCiE0AOMA9BFCXGO6qxuAQhfPfSKAiwG8K4R4u33Z9QBuA/CYEOIyABsAnJtEu4mIiNJGBayqh9VLAaEqCtXS0oJgMIhAIOCpgJqIiCiV4vWwBgF0RSSoLTf97AFwTqInllK+IqUUUsqjpJSj23+ekVLukFLWSCmHSim/KaXcmYo3QkRElCrWgNVLAaGmaTjvvPMQCARQX1+PYDDoqYCaiIgoleKNYV0CYIkQ4q9Syg3txZMgpfwqY60jIiLKAi8HrADQr18/FBcXQ9M0XxZdmjt3Lh544AEMHToU1113HTRNy3aTiIgoTeJVCVbKhRBvAagAACHEdgCXSCnfS2vLiIiIssTrAWtra6sxV6zfii6FQiFcd911AIA1a9bg2WefxZIlSxi0EhHlKTdFl0IArpFSDpJSDgJwbfsyIiKivOTloktAdMDqt3lY6+rqom43NzcjHA5npzFERJR2bgLWLlLKxeqGlDIMoEvaWkRERJRlXi66BEQC1kAgkiTlp5RgXdexatWqqGVFRUWorq7OToOIiCjt3ASsnwghbhRCVLX/3ADgk3Q3jIiIKFu8nhLc0tIS1cPql4A1HA5HvddevXoxHZiIKM+5CVi/B6APgCfaf/q0LyMiIspLbW1tKCgo8GzA6tcxrNXV1UbPMgCcfPLJDFaJiPJcwoBVSrlLSnkVgEkAJkopfyyl3JX+phEREWWH13tYrSnBXmtfumiahp/97GfG7f79+2exNURElAkJA1YhxJHtVYLfA7BaCPGmEOKI9DeNiIgoO7xedMmvKcEAMHjwYONvP71vIiK/cpMSXAdWCSYiIh/JhaJLfg1YW1pajL+9diGBiIhSj1WCiYiILHIhJdiPY1iB6IDVT++biMivAokfEqkSDOBv7bcvAqsEExFRHsuFgNWPY1gB9rASEfkNqwQTERFZeD1g9fMY1tbWVgD+61kmIvKrhD2s7RWBr8pAW4iIiDzB60WXOIYVKCoq8tznQkREqZcwYBVCjAFwPYAq8+OllEelr1lERETZkwtFl1RKsN96Gs0Bq5/eNxGRX7kZw/oQgJ8CeBcAL2USEVHea2trQ0FBQc6kBHutfemkAtZgMOir901E5FduxrBuk1L+S0q5Tkq5Qf2kvWVERERZ4vUxrOaU4P379+P999+HrutZblVmMCWYiMhf3PSw/kII8WcA9QAa1UIp5RNpaxUREVEW5UrAqus6Pv30U2zcuBE1NTWor6+HpmnZbl5atbS0QAiBQCDAlGAiIh9wE7BeCuBwAEU4kBIsEakYTERElHdyoehSSUkJwuGwEbQ1NTUhHA77ImANBAK+S4UmIvIrNwHrcVLKw9LeEiIiIo/wetElNYa1urraqBIcDAZRXV2d7aalnQpY/VZsiojIr9yMYV0mhBiR9pYQERF5RK6kBGuahm984xsYPny4L9KBAfawEhH5jZse1hMAvC2EWIfIGFYBQHJaGyIiyle5ELCqaW3Ky8tx0EEH+SJYBQ68d/awEhH5g5uA9VtpbwUREZGHeD1gNU9rU1BQ4Ln2pZN67+xhJSLyBzcpwQEAm9unshkM4EwAX6a1VUQEXddx6623+maqCiIvyYWiS34OWNnDSkTkH256WBcCGCOEOBRACMBTAB4GcGo6G0bkZ7quY8qUKdi/fz9KS0t9MzaNyCva2tpQUFDg2aJL1oC1tbU1yy3KHHPA6qdAnYjIr9z0sLZJKVsAnAXgLinlTwFUprdZRP4WDoexf/9+AEBjYyPC4XB2G0TkM15PCTaPYS0sLPRc+9KJRZeIiPzFTcDaLIQ4H8AMAE+3LytKX5OIqLq62jhRLioq8sVUFURe4vWA1e9jWJkSTETkH24C1ksBaABullKuE0IMBvC39DaLyN80TcOYMWMAALfeeivTgYkyjGNYvYs9rERE/pJwDKuU8n0AV5lurwMwN52NIiKgoqICAHDYYYdluSVEEbquIxwOo7q6Ou8vouRCwKpSgv0asALeG1tMRESp56boEhFlgeo98dOJKHmXuRBYSUkJ/vOf/+R10KoCVgCeTD21pgQ3NzdnuUWZo957W1sb949ERD7gJiWYiLLAq2PnyJ/C4TAaGxsB+KMQmDVg9dr30JwS7LeiS6p32YsXEoiIKPUYsBJ5lApY/TRdBXmXuRCYlBLPPPNMXs8R7PWAtbGxEW+99RZ0Xfdk+9KJY1iJiPylwwGrEOIWIcQcIUSvdDSIiCLYw0peY7548sorr2DSpEl5G7R6OWDVdR1fffUVXnvtNdTU1ODLL7/0VPvSbceOHdi8eTP27t3LHlYiIh9Ipod1OYAWAL+P9yAhxP1CiK1CiPdMy24SQnwuhHi7/efUJF6fyBdUuh97WMkL7FKAm5ub8zY1WEppXDTyWk+eWudSSjQ1NWHXrl2eal866bqOlStXYsOGDVi7di127NiR7SYREVGadbjokpRykcuH/hXAnwA8aFn+eynl7R19XSK/YdEl8hK7uYDzeY7gtrY2zxZdUutcCIFgMIjevXvj66+/zm6jMiQcDhv7RCkltm/fnuUWERFRuiXsYRVC9BFCXC+ECLX3mt4vhLg/0f9JKZcC2JmSVhL5EFOCyUs0TcORRx6J3r17o6CgAIMHD8aSJUvytlKwl1OCNU1DMBjEhAkTUF9fjz59+niqfelkHktdUFBgTP9FRET5y00P61MAXgbwEoBU5Cb+UAgxA8AKANdKKXel4DmJ8g4DVvKasrIyHHPMMXjrrbdw8skn522wCng7YFU0TYOmaZ5tXzpomobDDjsMLS0tCAaD6NatW7abREREaeYmYC2TUs5J0estAPBrALL99x0Avmf3QCFELYBaADjkkENS9PJEuYNVgslr1FQqhYWFeb9dej1gNY+x9WL70qm0tBSVlZXYtWuXp1K1iYgoPdwUXXo6VcWRpJRbpJStUso2APcCOD7OY0NSyjFSyjF9+vRJxcsT5RSOYSWvUfNf+mHeT3PA6rWiS0DsGFuvtS+d1IUTL34uRESUem4C1h8jErTuF0I0tP/sSebFhBCVppvTAbzn9Fgiv2MPK3lNS0sLCgsLUVBQkPfbZa71sOb752GmAlavFcMiIqL0SJgSLKUsT+aJhRCPAKgG0FsI8RmAXwCoFkKMRiQleD2Amck8N5EfsIeVvMacEpzv26U1YPVaYGTuYfXD52HW1taGgoIC9rASEfmEq2lthBDfBjCx/WZYSvl0ov+RUp5vs/i+DrSNyNdYdIm8xtyzle89el4eI6qCZ6+2L93M26Gf3jcRkV+5mdbmNkTSgt9v//mxEOLWdDeMyO8YsJLXtLS0+GoMq1cDQhWwejllOZ0YsBIR+YubMaynAjhJSnm/lPJ+AN8CcFp6m0VEXhnDqus6br31Vui6ntV2UPb5qYfVnHLb3NyMt956yzPfAfawsugSEZGfuEoJBtADwM72v7unpylEZKbGsGYzMNB1HZMnT0ZTUxNKSkpQX1+f13NvUnx+HMOq6zq2b9+Obdu2oaamxhPfAbXuzT2s+X4BwYxFl4iI/MVND+utAN4SQvxVCPEAgDcB3JzeZhGRF1KCw+EwGhsbIaVEU1MTwuFw1tpC2adSgv0QIKmANRwOG0GRV74D1h5WP1xAMGMPKxGRv7ipEvyIECIM4Lj2RXOklJvT2ioi8kSV4OrqauPvQCAQdZv8x9zD6peAtbq62ujJDAaDnvgO2PWw+ilwYw8rEZG/OPawCiEOb/99DIBKAJ+1/wxoX0ZEaeSFHlbzySBPDMmPKcGapqFfv34YNWqUJ9KBVdsAjmFlDysRkT/E62G9BkAtgDts7pMApqSlRUQEwBtFl5577jnj79bWVoTDYU+csFN2tLa2+i4lGABKS0txxBFHeGbbZw8re1iJiPzEMWCVUta2/3mKlHK/+T4hRElaW0VEnkgJHj58uPG3V9IhKXtaWlp818MKwHOBkV0Pa75fQDBjDysRkb+4Kbq0zOUyIkohL/Sw9u/f3/j7ueee80wPE2WHn6a1MQesXguMrD2sfriAYMYeViIif3HsYRVC9AcwEECpEOJoAKL9rm4AyjLQNiJf80IP69KlS42/jzvuuDiPJD/w2xhWddFICOGpwMjvY1jb2tpQUFDgu/dNRORX8cawngzguwAOAvA70/IGANensU1EZJKtnixd13HzzQdmsHr11VfxzW9+MyttIW/w07Q2bW1tUT2sXgpYOYaVKcFERH4SbwzrAwAeEEKcLaVcmME2EREOnJRmKzAIh8NoaWkxbi9dupQBq49JKdHW1mb0sJq3jXxkTQn2UsDKMaxMCSYi8hM387AuFEKcBmAkgBLT8l+ls2FEfqdOxF599VXoup7x8aPV1dVRgQnHr/qbuoDi1zGsXgqM2MPKHlYiIj9JWHRJCHEPgPMA/AiRcaz/A2BQmttF5HuffvopgEjP5uTJk6HrekZfX9M0nHHGGcbto48+OqOvT96iLlwEAgEUFhYyYM0iaw+rH8YUK1JKSCnZw0pE5CNuqgSPk1LOALBLSvlLABqAYeltFhG98847xt+NjY049dRTEQqFMtqGLl26GH/newooxacCVD8VXfJqwOrnHlbzdsgeViIif3ATsO5r/71XCDEAQDOAyvQ1iYgAxJwg7969GzNnzsxo0PrVV18Zf+d7jxrFZw4UmBKcXXZjWM3L85l1O/TDeyYi8js3AevTQogeAH4LYCWA9QAeSWObiAjAEUccYbt84cLM1UBraGgw/mYPq7+pQEGlBOd7z5Y5YPVaYGTXwwr446ISe1iJYoVCIVRVVaFfv36YM2dOtptDlHIJiy4BmCelbASwUAjxNCKFl/ant1lENGDAANtUv7PPPjtjbTD3sDJg9Tf1+fu1h9VLgZHdGFYgu3M2Zwp7WImi3X333bjyyiuN2/PmzcPnn3+Ov//971lsFVFquelhNSq9SCkbpZRfmpcRUXpIKREMBlFXV4euXbuiuLgYdXV1qK2tzVgbtm7davzNgNXf/DiGVQWEXksJduphzffPBIgNWP3wnoniefzxx2OWPfzwwxkv1EiUTo4BqxCivxDiWAClQoijhRDHtP9UAyjLVAOJ/Er18NTW1uKkk07CYYcdltFgNRQKYd26dcbtlStXZuy1yXvMKcF+6GFta2vz7BhWFaRZx7D6IXgzv3ev9XwTZcNpp51muzwcDme2IURpFK+H9WQAtwM4CMDvANzR/nMNgOvT3zQif8tmSqKu67jiiiuilr3++usZe33yHnNKsF96WL0asDoVXcr3zwRgSjCR1QUXXAAAKC8vN5aVlJSguro6Sy0iSj3HgFVK+YCUcjKA70opJ5t+vi2lfCKDbSTyJXNKYqZPzB588MGYHjTOw+pvrBLsncCIRZdYdIlIUd+B3/3udxg8eDBGjhyJ+vp6aJqW5ZYRpU68lOCL2v+sEkJcY/3JUPuIfMuakpjtE7MRI0Zk9fUpu6xjWPM9OPJywMqiS53rYQ2FQjj55JMzPq81UTqY0+TLy8tx6KGHMlilvBOvSnCX9t9dM9EQomTpuo5wOIzq6uq82kln4oRZ13U8+OCDAIAZM2YY62/GjBmoq6uDlBJFRUVobm5m0SWfU5//v//9bzQ0NOR9cOTlgJVFl5LvYQ2FQpg5cyYA4IUXXgCAjNYGIEo18wUsP1xMJH9yDFillHXtv3+ZueYQdYyu65gyZQqamppQXFycV2kw1nkgU30yqus6qqur0dTUBAD4y1/+gsWLF0PTNGiahm984xsoKirClVdeiR/+8IcMWH3uzTffBBCpSCmEQM+ePbPcovTycsDKMazJ97A+8MADUbfvu+8+BqyU08w9rH6oL0D+lHBaGyHEECHE/xNCbBNCbBVCPCWEGJKJxhElEg6HsX//frS1taGpqSmvquKl+4Q5HA4bwSqAmPVXUlKCww8/HKNGjQLgj/Fx5EwV3Wpra0NbWxsaGxuz3KL0sl4w8lLAyh7W5HtY+/btG3V75cqVnP6Dcpo1YOWxmvKRm3lYHwbwGIBKAAMAPA7gkXQ2isgtcxW8QCCQV1XxrEWXUn0yWl1dbYx9A2LXX1tbGwoLCxEIRBIx2MPqb0cccQSAyLZYUFBgbBdeoOs6pk+fjqqqKgwePBjTp0/vdBCSzSrdiVh7WNevXw/AH5W8OzsP60cffRTzfPl0oZP8hwEr+YGbgLVMSvk3KWVL+8/fAZSku2FEbph7ebzUA5IK6Z4HUtO0qPnb1Mmv0traahwAAQasfveNb3wDAHDZZZfhzDPPjLrYkU26rmPixIlYtGgRNmzYgPXr12PRokWYNGlSp4JW8wUjr6UEm3tYdV3H73//ewDAeeedl/e9hZ1JCb722mvx3nvvRS0LBoN5daGT/IcBK/mBm4D1WSHEdUKIKiHEICHEbADPCCEqhBAV6W4gUTw33XST8Xe+XSlP9xhWAPj666+Nv1taWqLWX2trK3tYybB3714AwMyZMzFgwADPnBSFw2HbbbO5ublT+4N0XzDqDHMPq/n9d/Y954JkU4LNgb1SUlJijNsnylXmC1h+mHKM/MlNTte57b9nWpZ/B4AEwPGslBUXXXQRlixZYtwuKCjIqyvlmSj6cvDBBxt/W3sa2traolI/eRD0N3Vxo6yszFOFPaqrq20v6BQVFXVqf+DlokvmE9Tq6moEAgE0Nzd3+j3nArUfWrRoEZqbm11/LuFwOOaxI0eOZLBKOc/aw5rv9QXInxL2sEopB8f5YbDqghpfNWLEiJSMraLI1AQPPfRQ1LKjjz46r04+MlH0pbKy0nh+a4Vl9rCSmephLSsr89RVfE3TMH36dAQCAfTv3x8AMG7cOCxZsqRT+wMvB6zmHlZN0zB79mwAwEMPPZRX+0A7b7/9NgDgkUcewRNPPIHm5mZX/6cCeyCy3ioqKjB48OB0NZMoY5gSTH7gGLAKIaa0/z7L7idzTcxt5vFVa9asScnYKgIWLlwYs+yyyy7LQkvSJxNFX9SBra2tDSeccELUfaroEsewEnAgYO3SpYvnToq6dOmCgQMH4oknngAA/N///V+nAzcvB6zWKsFDhw4FAIwePTpbTcqY5cuXA4isg9bWVtf7JU3TcO655yIQCOCVV15BZWWlZ7IEiDqDASv5Qbwe1kntv8+w+Tk90RMLIe5vnwbnPdOyCiHEi0KIte2/83siP9iPr/LDOKN0O+us6GsmZWVleTeXXiaKvpgPbNbtVBVdUr0SixYt4oUWHzP3sHopJRgAGhoaUF5ebgRwqWiblwNWa5Vg1U4vtTFdRo4cCeBAterW1lbX+6UBAwagqKgImqZ57jMlShbnYSU/cAxYpZS/aP99qc3P91w8918BfMuy7DoA9VLKoQDq22/nNTW+yswP44zS7dxzI0OrDzvsMIwbNw4VFflX/8tc9CVdRZfMQao1tU6lBK9atQpApFe7pqaGQatPqTGsJSUlnkoJBmID1lQEIl4OWJ3mYfVSG9NFpfGeeeaZACL7Kbf7JetUYX5YX5T/2MNKfpBwDKsQ4hYhRA/T7Z5CiN8k+j8p5VIAOy2LzwTwQPvfDwCY5rqlOUrTNJx33nnGQfLQQw/t9NgqAnbujGxa119/PYYPH56XJx6ZOGGO18OqUoLV3I5SSjQ1NTE7wKf27t2L0tJST17FVwGr2s+muofVa8GNUw+rlz6TdFE9/Ycccojxft3ul6yVn/2wvij/MWAlP3Azrc0pUsrd6oaUcheAU5N8vX5Syk3tf28G0C/J58kpH3/8MYLBIILBIL797W8zWE0BdXKydevWvD3xyMS0NuYDm10Pa0FBAcaNG2e0gXMW+tcnn3xizPuptkevBHGbN2/G559/jnfffRdAenpYvbSPsfaw+iklWAWs48ePN4YruN0vebnXnChZDFjJD9wErIVCiGJ1QwhRCqA4zuNdkZEjhePRQghRK4RYIYRYsW3bts6+XNb8/ve/x/Lly7F//340NTUZFQ4pebqu48orrwQA3HDDDdi2bVtennhkuofVKSX4+OOPBwCcccYZMZWEyR90XcdTTz2FvXv3oqamBl988QUAbwRIuq5j48aNWL16Na644goAqQtY0z2GPFnWHlY/pQSbA1Z1HHjiiSdc7Ze8/JkSJcscsHptuAZRqrgJWB8CUC+EuEwIcRmAF3EgrbejtgghKgGg/fdWpwdKKUNSyjFSyjF9+vRJ8uWy79FHH426vXbt2iy1JH+Ew2EjuGppacGmTZs81fuRKtbxVpkew6pSglUbpk6dymDVp8LhsHES1NTUhPXr1wPwxty85vk11faciu+KNX3US8GNUw9rPu4HrczFv1QBJvU7EWtdAC99pkTJMl/AYg8r5Ss387DOBfAbAMPbf34tpZyX5Ov9C8Al7X9fAuCpJJ8nZ0yaNCnqNud96zzzfHpFRUUYOHBgXp54ZOKE2U2V4FSOC6TcVF1dbUxvFAwG0bVrVwDAsmXLstksADBSQYUQxn4h34su+blKsApYS0tLUVZWFrUsES+neRMliynB5AduelgBYA2A56SU/wvgZSFEeaJ/EEI8AkAHcJgQ4rP23tnbAJwkhFgL4Jvtt/Pa6adHZgA69thjUV5ejsMPPzzLLcp9mqbh5z//OQDg/vvvz9v59DJR9MVNSrCfem/InqZpmDx5Mnr16oU777wT//73vwEAp5xyStarRmuahm7dumHs2LG49957AeT/tDZ+rhK8d+9eFBUVoaioqNMBqx/WF+U/BqzkB26qBP8AwD8B1LUvGghgUaL/k1KeL6WslFIWSSkPklLeJ6XcIaWskVIOlVJ+U0pprSKcd9SO47e//S26du3Kk/4UOfTQQwEAxxxzTN6mdmWiNyBewGpNCc7HdUzuVVRUoE+fPtixY4fRG++VqtGFhYUYM2YMRo8eDcC/Pax+OL7s3bvXCFS7dOliLHOD09pQPmLASn7gpof1SgAnAtgDAFLKtQD6prNR+UTtOAoLC7kjSSHzCVu+pnZl4oQ50TysTAkmRW0P5pR8r1SNVoFIKi+ueDlg9XOV4E8++QRtbW3Qdb3DPayc1obykXl/4LUpx4hSxU3A2iilbFI3hBABxKnuS9EYsKaHeQedr1fKszmtjZQypoeVB0F/U9uDpmlGNd4nn3zSE4W4VCCSyp5GLwesfq0SrOs6nnnmGTQ0NKCmpsYoYsiUYPIz9rCSH7gJWJcIIa4HUCqEOAnA4wD+X3qblT/UjoQBa2qpEw11kpqPwVQmpmBwKrqkXosBKyltbW3GtqBS8o899thsNsmgApF09bB67aKYX6sEW6tVv/POOwCARx55xNVYaqYEUz7itDbkB24C1jkAtgF4F8BMAM8AuCGdjconasfBK1+pZd1B5+OJh3UKhkxOa2Pebv1yMkzxqZRg4ECPnlf2ZyoQSWcPq5e2f79WCbZWq+7bNzI66bHHHkNNTU3CoJUpwZSP2MNKfhA3YBVCFAJYI6W8V0r5P1LKc9r/zu+jYgoxJTg9/NLDmslpbVatWoVbb70Vuq5Hbbd+STek+FRKMADjt1e+dyoQSXUPa7ozHJLl1yrBmqZh4sSJ6Nu3L+rr69HQ0AAg8r7dFABjSjDlIwas5AeBeHdKKVuFEB8IIQ6RUm7MVKPyifXE3ysneNkWCoWwcOFCnH322aitre3w//uhhzXTY1h/8pOfAIj0XKhpS5gSTIrfelgzMQ9ysvxcJbhnz57o06cPNE3D7t27AUTWg5sCYEwJpnzEgJX8wE1KcE8Aq4UQ9UKIf6mfdDcsX7CHNVYoFMLMmTPxwgsvYObMmQiFQh1+DvawpkZrayuKi4uNv1tbW9HU1IQlS5YAOHBBAPDHyTA5y4Ue1lSmxnq5N84rVYJ1Xcf06dNRWVmJfv36Yc6cOWl/TfNY6hNOOAFAZD7g+vr6hAXAmBJM+YgBK/lB3B7WdjemvRV5jAFrrIULF8bc7mgvK3tYU6OlpQWlpaVobGwEEDmJCwaDGDduHAD2sNIB5kDBiz2s6Sy65LWA1QtVgnVdx4QJE6K2gXnz5gEA5s6dm7bXNfeSqgsnkydPdlWt2sufKVGyGLCSHyTsYZVSLgHwAYDuALoB+KB9GbnAKsGxzj777Li33fBDD6s5QEhnD2tJSYlx++STT0Z9fT3GjBkDILLd+indkJyZU4JVoOCV/Zn6rvhlWhsvVAk2V+w1e+KJJ9L6uuZe0o729Ht5XDJRsqwBK4/VlI8SBqxCiO8DWA7gLADnAHhNCPG9dDcsX7BKcCxzb+qNN96Y1BhWcw9Dvp54ZDolGABGjBgBTdNYJZhieDkl2G89rOYTVCA7KcHV1dXG65qdddZZaX1d6zhUwP2FE2vldS99pkTJsgtYuW1TvnEzhvWnAI6WUn5XSnkJgGMRmeqGXGBKcHzf/va3k/o/cw9DvhazysQ8kK2trVHPe9ddd8VUCU7n61Pu8FvRJS8HrF5ICdY0DSeccAK6d++O7t27AwC+973vpTUdGIjOPOloT7+XpyoiSpZ5f8AhPJSv3ASsOwA0mG43tC8jF1glOD7zPKAd4cceVrUslazrv7W1FeFwOKYHh9suebmHNR1Fl9ra2rBs2TLouu65CzZeSAkGItvBscceiz//+c8AgKuvvjrtr2mXEpxswOqlz5QoWdYeVsA7FxOJUsVNwPoRgNeFEDcJIX4B4DUAHwohrhFCXJPe5uU+9rDGl2zAau1hBfJvDkJrDyuQ+hPS1tZWDBo0yLgdCARQXV1t28PqleCEssOrRZfS0bug6zqklFiyZAlqamqwY8cOT23/TtPaZHof+OWXX6Jbt24Z7dXpbEowp7WhfGM+H2LASvnKTcD6MYBFANSe/SkA6wCUt/9QHAxY40tVD6t5Wb6wFghRy1KptbUVffr0MW6fd955UWNYGbCSYld0yQvbhLUAm3lZssLhsPE8TU1N2LZtm6f2L9Ye1mxdtNuzZ49twKqmu6mqqsLIkSOTmrrMibUYXUdSe5kSTPmIPazkBwmntZFS/jITDclX1irB+/fvz3KLvIU9rM6sBULUslRqbW3F7t27jdv/+Mc/cPnll6Nfv35Rr8uTOzKnBHuxhzWV+4JJkyYZzxkMBtGvXz9s2LChcw1NIace1kx/R3fu3Im1a9fiww8/NF5f13WMHz8+qi0zZ84EgKQK7FmZ94sAOnQhmCnBlI8YsOYvXdcxb948rFy5Eq2trTjuuOMwe/ZsV9N45Rs3PazUCawSHF9zc3NS/2fXw5pvAVWmxrBu3749KgAxT1fBokukeL2HNZX7grFjxwIAampqUF9fjz59+nhq+3caw5rJNi5btgwNDQ147bXXcOONNxqv/8tf/tJ2/Vvn306WOfME6HjAypRgyjfmgHXjxo0AgNdeey2bTaIU0HUdEydOxKJFi7Bx40Z8/vnnWLRoESZNmgRd17PdvIxjwJpmTAmOjz2szuwC1nT0sFZWVhpT2xQWFqK6ujoqMwBgSjB5dwxrOvYF6jmrq6uhaZrneuO8UCX4P//5j/Gaaj/e1tZmnDBbJTPftp3O9LCa/5dZI5Qv1Hb81ltv4e677wYATJs2zZdBTT4Jh8O258jNzc3GsBU/cTMPa69MNCRfWQNWHiCjpXIMa76tW7uiS6k+Id27dy+2bdtmTEVRW1sbMw+r+p1v65c6xq5KsBcC1nTsC+x6ML0UsHqhSvCECROM1y4qKjJe/5RTTol5bF1dXUrSgYHO97B69TMlSpb63r/++uvGOZVfg5p8Ul1dHbWvU4qKilBdXZ35BmWZmx7W14QQjwshThV2s4RTXNZpbbxwgucl7GF1lu4eVl3XsWXLFrz11luYMycytfLAgQMBgEWXKEaqU4LvvvtuDBo0CD179uxUipN5X5Cq1Fi7MaJe2r94oUrw8ccfDwCYOnUqbrvtNgCRz+K0004DABx33HE46aSTUFpamrJgVb2G+SSuI/smpgRTPlLb/4knnohAIFKaxq9BTT7RNM34DPv37w8AGD58OJYsWcIxrA6GAQgBuBjAWiHELUKIYeltVv5gSnB87GF1Zjd9QypPsKyVUIEDY4qtKcFMn6NUFl1asGABrrzySmzcuBG7d+/G0qVLMXHixKSC1nQUXbLOQ+y1gNULVYJVG2pqanDEEUcYy1Qb7rjjDhx99NEp328wJZgomtqOjzvuOFxzTWS2yUcffdSXQU0+0XXdOE/78ssvAQAXXHCBbz/XhAGrjHhRSnk+gB8AuATAciHEEiGEP9daB1irBDNgjZZs0SU/9LBaT66A1L5HdeVOVUIFDlxAsEsJzrf1Sx1j7tnqbA/rP//5z5hlLS0tSaWwmYPLVKcEe3X790KVYKf1bl6ejvXGlGCiaObv3NChQwEARx99dDabRCkQDoeNz1Z1Kvj5IpurMaxCiB8LIVYA+F8APwLQG8C1AB5Oc/tyHqsEx8ceVmd2Y1hT+R41TUOXLl2gaRrq6+tRVFQUE7A+8cQT0HWdKcEUlRLc2R7WM844I2ZZIBBIKoUtUz2sXtr+vVAl2BqYqmXW5enoYWWVYKIDnL6LlNvMY1hVp4KfP1c3KcE6gG4ApkkpT5NSPiGlbJFSrgBwT3qbl/sYsMbHMazOMjGtDRAJXDVNQyAQMD6PVatWAQD+/ve/o6amBi0tLb7eUZJ90aVkt4kZM2YAAHr27IlAIICSkhIsXbo0qVQnPxZdSmeVYF3XceuttyZMz85mwMqUYKID0pFlQtmnaRpGjx6NQYMGob6+3vf7rICLxxwmHY6CUsq5KW5P3lG9EkIIVgm2wR5WZ+nuYQUiKdmqSIM5YF2xYoXxek1NTQgEAnm3fikxNYamuro6pT2salv65S9/iffeew9PPfVU0uNy0nHxyutFl9auXQsAWLlyJQYNGpSyfaCu66ipqUFjYyOKi4tRX1/v+LnYrfdMBKzWlOCOFl3y6kUIomSxhzV/lZeXo2vXrtA0zfeZbo4BqxDi/wGQ7X/H3C+l/Hb6mpU/WltbowqVsIc1ekfKMazOzCdm6ephbWlpMaakCAQCxudx1FFHAYhss8FgEMXFxb7eUfqRCl7279+PkpISdOnSJWU9rOZidN27d8fu3buTbmc6e1i9GLDquo7bb78dQKQAx3/+8x9jHuXOtjEcDqOxsRFtbW1obGxEOBxOGLCaT5KllI7LUzXJQGd6WK37VK98pkSdwYA1f7W1tRmdCn6PIeL1sN6esVbkMXPAypTgCPM66GwPq3kqi3zbQZtTMNPxHlVviLkMvvo8hg8fDgC47LLLcOmll+K8887jyZ3PhMNh7N+/H1JKNDY2GlNzAanrYS0oKMCePXuM4CiZMazpmNbGywGreTJ5Ndeimvu0s22srq42MoEKCgrifh7mCwXxeljVcrUv66zOFF0yB7scw0r5Ih3j+MkbzGP2/d7D6jiGVUq5JN5PJhuZy6zjvhiwpiZg9UsPazqnrVCfg11KsPp9ySWXMBXFp1TwAkT2XYFAIKZKcGcD1nXr1uH+++8HAJxyyimc1saF6upq4zsbDAZRXV2dsgtamqbh8ssvBwCcddZZcdO0E41htaYKp0pniy5xDCvlG/aw5i9rdX4/f66OAasQ4rH23+8KId6x/mSuibnNPO6LAWtEqnpYrQWJ8u2LnO73qNJ/4wWs5nT2fFu/FJ+maZg2bRoA4IorrjCm5gJSlxL80UcfxfQWdpTfii5pmobvfe97AIDnnnsOmqaldMiAyq7o2bNn3Mc5nSQ79bymSmdTgr34mRJ1BgPW/MUe1gPipQT/uP336ZloSL5iSnAsc5DamR7WdFTI9JJ097CqdW83htXa++r3HaVfDRw4EAAwaNCgtBRdOvzww1FUVISmpiYUFRV1OiXYDz2sANC3b18IITBhwgQAqd0/lJSUAAD27dsX93FuqgSn40JbZ4sucVobyjcMWPMXA9YD4qUEb2r/vcHuJ3NNzG3WgNXPG5tiPslNtugSe1g7TwWsdmNYrfcxfS43hUIhjBgxApWVlRg8eDCmT5/eobRbc89dKqe1Uf83bNgwXH/99QCAv/71r56Z1sZu2hgvBTeqEFY69g/qPe/fvz/u49xOa5OqdplfNxVjWFO9T9N1HaeffjrGjh2LUCiUsuclSoQBa/5iwHpAwmlthBAnALgLwHAAQQCFAL6WUnZLc9vyAqsEx0rVGFY/9LCm8z1ag9JEKcH5tn7zXSgUwsyZM6OWrV+/Hv/+97+xZMkSV8GhtfprqntYCwsLcdhhhwEARo0a1annSnfRJS+dKKiAVUllSrC6iNiRgNUcMDtVCU4VL6YE67qOCRMmGO1Yvnw5AKC2tjYlz08UDwPW/GXNbPLz5+rYw2ryJwDnA1gLoBTA9wHMT2ej8skXX3yBffv2Qdf1nEkJnjNnDvr06YPKysoO98i4wTGs7lh7A4DUnvhZx7A2Njbi/fffh67rMcGs33eUuWjhwoW2yzsyVtT83bKOx1fLk6H2AeYTrGT3jX6b1gaIDVhTGRg2NTUBAF566SWMHDnSsbcwWz2snakSnK6U4FtuuSWmDU7fP6JUy/WAVdd13HrrrSk/18wH7GE9wE3ACinlRwAKpZStUsq/APhWZ15UCLG+vZjT20KIFZ15Li/TdR3PPPMMGhoaUFNTg82bN3s+YP3JT36CefPmYfv27di8eTMWLVqESZMmpXRHkuoe1nTNUZptdmNY05USrOs6Pv74Y6xZswY1NTX473//a9ynXt/PO8pcdPbZZ9su78hYUWsPq7nHHUjNtDapSi9OZc9ZrgWsqbxopy5m7N27F++//z5mzpxpG7Q6VQPOREpwsj2s6UgJDoVCePrpp2OWO33/iFIt3ZW500nXdUyePBnXX389ampqGLRaWI+7Xo8h0slNwLpXCBEE8LYQYp4Q4icu/y+RyVLK0VLKMSl4Lk8Kh8PGxtXU1ITVq1ejubnZ01/IJ554ImZZc3Mzrr76alx++eUpabv5C3f//fdj2LBhtidE8a66pTuY8wK7XuR0FV0Kh8PGc6ttFWDAmstqa2sxePBglJWVoW/fvgCAI4880nU6MJC+HtZUBjXmaW3Uc6YqYPVqRdl9+/alLSX47bffjllm11volPqb6TGsHS26lOrP1G7dnHHGGUwHpoxRF2JyMWANh8NobGwEEDn3SKZSfD5jD+sBbgLPi9sf90MAXwM4GAAvHbpgncfwnXfegZTS01eRJk+ebLt8+fLluOeeezB58uROt93cq9rQ0IC1a9fGXMXXdR1TpkzBz3/+c9v15bce1nQXXaqurjbWZzAYxNChQwFwWptc16dPH0ycOBEffvghAODSSy/tUGGjdPWwqv8rLCxMaUowkJqeM7vn9NL+JZ0pwWpaGzO73sJszcPqtZRgu3Xz4x//2OaRROmxceNGAJHzplwLWM3nHq2trXjuuec8e36cDZyH9YCEAWt7ReByAMVSyl9KKa9pTxHuDAngBSHEm0KIvL0MqWkapkyZgoqKCnzve98zNjQvX0VSk8Z3794dhYWFKCsri7q/sbER8+bN69RrOJ1cmK9Uh8Nh7N+/H1JK2/Xllx7WVBZdev755/GLX/zCOBiYA1ZN03DkkUdi8ODBqK+vR1VVlXEf4L2iM+SO6hVNNii0FtOx9rB6MSU4lT2suRKwpvKC1ujRowEA/fr1AwDccccdtr2FTvOtenke1nSkBNfW1iIQCKB///444ogjAABjxuRt4hh5jK7reOihh4zOEDWcJ1eO15qmYdiwYcbtpUuXpnwYWi5jD+sBjgGriLhJCLEdwAcAPhRCbBNC/F8KXne8lPIYAKcAuFIIMdHm9WuFECuEECu2bduWgpfMjp49e6JPnz6YMWOGcWIWDAaTmm8wE1QhnscffxyjRo1C7969Yx6zaNGiTpXtdzq5UCdKQOSqmzqxsBtzZw7m8rGHdc6cOXj33Xfx6quvQtf1Tp+Q6rqOb33rW/jVr35l9Fhbiy5VVFRg4MCB0DTNtuhSPq1fv1C9oskGhWq7U9uDl1OCU9nDmqsBa6qqBBcWFuKmm24CAJx//vm2j8vVokupTgn++uuv0dLSglGjRqGmpgZA8hdyiOzEGx5lHXr27rvvAsidgBWIjJc360hhwHzHgPWAeD2sPwFwIoDjpJQVUsqeAMYCOLF9HGvSpJSft//eCuBJAMfbPCYkpRwjpRzTp0+fzrxcVqlpbTRNw2WXXQYAePbZZ5OabzATVBBTVFSE0tJSOK37zlRAVDvXH/zgBxgwYACAyMnDXXfdZeyQNU0zrvDPnz8/Zn2Zr5Tn27Q255xzDubNm4eWlhbs3LkTEydOxEcfRZIaknmP4XDYOPkEDvTwm8ewAtEnfnbT2vh5R5mr1P4n2R5R9d2y2x4AJJ2+ZZ7WJlUFnPxQdEnXdaP34e233zbWfaqrBAeDQQSDQQDOc2Xn4jys1gudqVhfzz//PADghRdewN133w2AASuljq7rqK6uxo033mg7PMo89CwYDBoX/nPpeH3ooYdG3e5IYcB8x4D1gHgB68UAzpdSrlMLpJSfALgIwIxkX1AI0UUIUa7+BjAVwHvJPp/Xmcd9DR48GABw3HHHZbNJcamTk2AwiLKyMgSDQQwaNCjmcZ2pgKgO5ieffDIuuugiALBN/e3SpQsA4OCDD455Drse1nz4Iuu6HnMxoKWlBWvWrAHQ8ff4yiuvYPLkyXjhhReMZaqH39qLaj7xU79ZdCm3pSol2NrD+uabbwIA/v3vfyc1Jt88rU1ne2szUXTJCxkGuq5j/PjxWLp0KVpbW7Fr1y5MnDgxJRkYZipgVRey1DQ3Vm4C1nTsm60pwR3ZN1kvdKbiM126dCmAyHZo3X8SddbixYvR1NSE1tZW2+FRmqbhrLPOQjAYRH19PY488kgAuXU+dPjhh6OsrAyFhYUYPHhwhwoD5jvOw3pAvIC1SEq53bpQSrkNQFEnXrMfgFeEEKsALAfwbynlc514Pk+zq6zp5YOZOjlRPax79+5F9+7dMWHCBGNH6DSmyS1zwZUTTzwRQOSLaE2VVutr9+7dMc+Rrz2sf/3rX2OWBQIBY2xUR9/jiy++GLPspZdesk37DQQCMT2sDFhzW2dTgtXjVRVH9TzLli0DYH+hqSPP69WU4HQ8Z2eFw+GYNrS0tCAcDqc8JbioqMgIWN30sFrHOqvl6dg3pzIlOBWf6THHHAMg+uKLl4/xlFvUORLgPJysX79+KCsrg6ZpOVnTo6WlBeXl5RgwYAC6du2a7eZ4CntYD4gXsNpfVk18X1xSyk+klKPaf0ZKKW9O9rlygUrJA3IjYLWmBO/btw+NjY2orKzElVdeCQD4zne+06nXMAdDY8eOBQCcfvrpqK+vj7qqpoKlm266KWbMbL72sFpPDisrK7F06VIcdthhADr+Hu12/vv27Yt6LXMPq/psrCmgXjhhz3dSSnz/+99Hz5490bt3b5x55pmdLjyhLpip70hH9z1qO1ABq/rOTZo0CUBku0hmTL5dSjCLLsVnt46tFb7TkRLcmR5WL6YEp3oMq7qYeMEFF+B///d/AXj7GJ8p8cZdkntHHXWU8bf1HEkxn2fmYsDa3NyMtrY2fP7553j33Xcxfvx4zJkzJ9vN8gTOw3pAvIB1lBBij81PA4AjM9XAXGcXsHp5R2IOWMvKyoyAtbi4OOEJjFvmHla1Tr75zW/G7IhVz6rd5PX52sN63nnnATgQCCxcuDDqqmlH3+OWLVtilp1++unQdT1uSjCLLmXe97//fdx3333YvXs3duzYgX/961+drpaoDnZqipGO7nvUdrBq1SoAwAMPPABd1zFu3DgAwEknneR4EhWPOSXYi9PaeDFg1TQN1dXVKCsrM6YrWrp0KTRNS3lKcEd6WK3T12QiYO1MleBUT2ujXvvcc881qp36+aQSODDW+vrrr0/JVHh+pgoSBYNBx/1sPgSsLS0tRpvb2towb968ThX3zBfsYT3AMWCVUhZKKbvZ/JRLKTuTEuwrdjsSLx/MnHpYzQGr0wmMW+r9P/7448ZYOLt1snPnzqjb5rGd+drDqtLLTj/9dITDYeMAlWzK36hRo2KWqQp88YoumS8qANxRZoIq3mLW2WqJ1vEvHd33qMe/+uqrAIDVq1dj0qRJWL58OQBg/PjxSY014rQ2yenWrRuGDRuGrVu3Ro3zSnVKsHkMa0eKLqn5elWbMlUl2O3zpyMl2O4CbGeO8eFwGBMnTsSgQYMwcuTInDxp/+tf/2psN42NjbjgggsYtCZJBazq4rEd83lmLp4PNTc3o2vXrlHfa6BzxT3zBedhPSDhPKzUObmWEqx6T4PBIHbv3o0vv/wSX331lasUMbdWrlwJINJbM336dACx62TOnDnYv39/1DJzoad86GENhUIYO3Yspk+fbhzM1Xo45ZRTogKBZA9C1up7wIE0wkRjWFXPHMCANRPGjx8fs6yz1RLN6UTJHOzUNmLW3NyMl19+2fF+t+1SbfLiGNZ0VB5OBRVMWqVyH7hp0yZ8+eWXWLt2LYCOpwRneh7WXbt2YevWra4ConSkBKcyYNV1HTU1NXj55ZexceNG2+yiXPDhhx9G3V6/fj3n1kxSRwPWXO1h7datm5FSr3SmuGe+YA/rAQxY08x6wgh4O2BVV0XfeecdPPbYY2hubkZDQwN27NiRkoA1FArhN7/5DYDIulHPZT7xDYVCmDdvXtT/TZs2LarQU673sIZCIcycORPLly/HokWLMG7cuKieK+vBKdkT0q+//jpm2W9/+1tomoZnnnkGAPDUU08BiGyfX331FaZPn477778/5vVzaf3mou9973sAgB49eqCwsBD9+vXrdLXEzvaw2gWkRUVFmDx5cqfG06QyJTgdwaVdEJzpgDUUCuHkk0+OClZUuq5VqvaBuq5j6dKl2Lp1K6699loAzj2sToFpJudh1XUdS5YswbZt21xVqzb/b6pTglMRsNoV1gJyr6eptLQ0Zhnn1kyOCljtvvdKPgSsRUVFmDt3LoYOHYoePXqgrq6uU8U98wUD1gMYsKZZrlUJVicnr7/+elQ7N2/e3OmAVQVpW7duBXBgnCYQvU7sDs7WK2+53sNq9x6XLl2Kc845B8CBbUVJ9oTUOiE3AAwaNAihUAj33HMPAODXv/41QqEQdu7ciS+++AKLFi3Cpk2b0Nraapwss+hS+qng8Pnnn8eECRMwbNiwTpf272wPq5qEXhk1apQRRHdk7KBduwDvT2uTrYBV7StfeOEFzJw5E6NHj4au68aJnVWqUoJDoZDxHOpY4OWiS+Fw2NgG3VSrNh83vJgS7JRNkWs9TXZDUTi3ZnL8FLACQFVVFQ4//HAGq+0YsB7AgDXNci0lWJ2kTJw4MaqX7xvf+EanA9bHH3886raU0qg8bF4nQ4YMifnfMWPGxPxvLvewOp2AqPVvDVhT2cO6d+/emIB54cKFxoUE63L1+rl0QSDTdF3H9OnTMXbs2KTT98wp2m1tbfjwww9TViUYSK6Hdd26dVG3+/XrZwTR5hTyjvL6tDbZCFjvueceDB8+HH369ME111wTdd+qVaswadKkqEwXs1RdtFMVxM06MoY100WXqqurjX2lm2rVXk8J1jQNxxxzDCoqKox50HOxp2nHjh0AIsMcCgoKMGTIEM6tCfusiUT8FrAWFRV1uk5KMtQxvLKyEhUVFZ5JYec8rAcwYE2zXK0SPH78eFx++eXG8kMPPbTTAeuZZ54Zs+ydd94BEH2At1s/1tfM9R7W2tpadO/ePWa5uWKvWbJBuVq/Znv37o0JmM8++2zbNC71OL/vKOPRdR0TJ07EokWLsHz5csycORNDhw7t8MFOBayrV6/Gq6++ii1btrhKc4ynsz2sBx98cNRt83ZjngYpmXap50h1SnA6eljTfcEmFArh8ssvx3//+19s377d9kJTc3Mzdu3aldaU4NNOO814vkRF9twErOm4mGi+WKlpGk499VSUl5e7qlbt9ZRg1a7jjz8eF198MXr06JFzwaqu6/jLX/4CAHjzzTdRXl6Ok08+mcGqJWuisrLSVeDqFLCapw1iwNo55mP45s2bsWvXLixduhQTJ07MetBqndYmlz7XVGPAmma5ViVYBYZFRUUYOnSosby4uNjYoSQbsM6YMSNm2dlnnw0hRNQ6UfPaFRQUOFaqzPUeVgDo3r07Tj31VJx00kkAIhWCH3zwQQDxx7C6nd9O13XccccdMcu//vpr4+JBnz59MHv2bNTW1tp+rupkye87ynjMFZeVjz76qMMHO/UcK1euNNa1mzTHeBL1sCbqGR48eDD69u2LqVOnxvT0dCYl2DyGNVUpwblcdOnuu+9O+JiioiKUlJSkNSV4xIgRAICLLroIDzzwAIDUpASnct1Z52EdOHAgSktLXQVEXk8JBoCGhgaUl5ejZ8+e2LVrV05diAWi94dNTU1oa2vLSo+Z11izmjZv3pywoFYoFMLVV18NIDpbqq6uDieeeKIxbdDWrVtjzjNzabsxB6zBYDDj24vdMRyIHJOzPe7amhLs5fgh3RiwplmupgQXFRVFBU3hcBj//e9/ASQfsJrnqzOfAFtPfNVcdrW1tbjqqqui2qXkeg8rENkZDhgwwChwdPnll+PIIyNTHDv1sK5atQoTJkzA9ddfn7D3zWknvHfvXjz99NMAIqlbd911F3Rdj+lNM2PA6qy6ujqqaqnS0YOd+qxOOOGEDqU5xhOvh9WuZ9h68tTS0oLevXvj+eefj+npSdUY1s72CGSq6JJ5eSrpuo733nvP9j41FnDYsGFYsmRJVLV2s1TtA9V+9oILLsDxxx8ftczKqSc10/OwBgIB1z39Xk8JBiIBa7du3bBnzx40Nzdj8eLFnW5jJlnTtEtLS5POxMgnTsOAnApqqR7ZzZs3A4jMqR4KhaDrOi6//HJj221sbMSGDRvyqoe1szNRdFR1dXXMlDrAgRkVsonT2hzAgDXNcrFKsJrOxHwl/+mnnzZShB999NGk0iTUQWvixIlRJ8DWE1+1s7rssstw2GGHGe0yy4ceVjV1jHm7sM5/qqj3uHLlStdFRswnDmZ79+7Fa6+9BuBApeZwOIyBAwcCiFSptWLRJWeapuG0006LOeDZHezi9Y6r78dxxx2HCy64AAUFBa7SHOOJ18Nqd0HDevLU0tLiOJ1CKsawpiIl2K7oUke3VdXTXFVVhcGDB+OGG24wnsv83OkIWK2VYc0B6cUXX4yKigpMnToVmqYlLLrU2e+oOcMmUUaN03yrmZ6HtaMBazZSgnVdxymnnIJBgwahf//+GDFihGPP2u7du7F8+XLj/tNOOy3raYkdoWkaxo8fj379+qG+vh5du3b1XcBqN2Xd//zP/9g+1imQ/fOf/xyz7L777sPPf/7zmO1WSpnzAas6znQ2JTiZehKapmH69OkoKipC//79UVBQgN69e2Pp0qVZT2Vn0aUDnCd2opTIxSrB6oTJfGIkpTROXB555BE8+uij+N///V/MnTvX9XNb5/1UrAGruZfX6aQpX3pYA4GAsT5aWlocA1bVu92tWzdjWaKrf5qmYfLkyXjxxRejlv/pT38y1mtBQYHRi/fPf/4TQKTA1ptvvhn1Pyy6FF/Pnj1xyCGH4Nxzz8Udd9yBXr16YdGiRVEHu2XLlhnz3xYVFSEcDkfdb/5+VFVVQUrZ6YOlNcPDfLBTV5XNy6wnT+qiip3OjGFNd0pwR7ZVXdcxYcKEqH3Q+vXrAQDvv/8+Jk6cmNaAVV1YamlpQWlpKc455xz87W9/AxAJXnv06IHdu3cDiOwH7XpYU9U+te819+R2ZAyrlDLj87B2ZDvMRkqw3fa1ZcsWzJw5EwCiMhdeffVV7N27N6o6t5oOJtsnzh3RvXt3DBgwAJqmIRAI+ColWPWMKk899RTuuece2+9tvIJajY2NMcvefPPNmPPHoqIiVFZWGt+BXAxY1TER6FzAqus6xo8fb7z35cuX4+OPP3Z1ntq7d29UVFRg06ZNGDVqFIYMGeKJ7xwD1gPYw5pmuZYSbJ7nzxywmk8+gMiXaN68eY5XsOx6kjoasMY7abKmdqk25ZLW1taYgNVuHem6jjlz5gAA7rzzTmO5m5NTu3Wyc+dObNmyBQAwYcIEoxdPbZ+9e/c2Hqs+34KCAjQ0NLgaO9sZ6uroiBEjoq5Oe5064M6dOxeDBw/GN7/5zZiD3W233Ybm5mbj4o8ar2x+DgDGNiGlTMlYTPP+x/w90zTNmPsVAH71q1/FnDxt27YNW7dutf0cvJoS3NGLK+apUazefvvtqOdOR8CqaRpOOukkdOvWDXfeeSceffRR477PPvsMgUAAb7zxRtxpbVJ10c6uh/WZZ56x/fwTjWFNdQ+r6rVqamrCpk2bjOVeTwmOt31ZMxpeeumlmMd4IS2xo8w9Zh35fPKB3WwIs2bNwpNPPmksU9ugef9rpus6Vq9eHbWsS5cutt+jxYsXo1u3bjnfw2oew5psSvAtt9wS875vv/12V+cR5mwiL22zDFgPYMCaZrlYJVjtOMxB0wUXXICbb7455vF24y/uu+8+jBs3DjfccEPUOMt4Aat552DXw2o3htX8JQbyt4c1HA4b79+8HlpbW+OmBM+fPx/hcBglJSWOj2lsbDQCK7X+du7cadyvxjXu2rULa9euxY033tjpyrVOzGMq16xZg0WLFuHEE09MepqYTHJzsLNeMX/uueccL+iYt4nOSFR0qWvXrsbfZ511lvF3KBRCVVUVXn/9dXz++eeYPHlyzGeeioDVnBKcraJLTuOXgEghNPWc5tdKFbWeX3jhBbS1teGtt96K+syXL1+Ojz76CB988AFqamrw9ddfpzUl2LzvXblyJYBIwGr3nY8XsFr3zZ1t10UXXYSZM2di+fLlkFLioYceMtqTbEpwpgJWp6EZQGxGwwknnAAgst7UPmD+/Pme6OnpCPP+MFvTlGTLGWecEbNMSmlMEWb+bJ3Wi/kihxACVVVV6Nevn+12dPTRR0dlwuR6wNqZ7eXjjz+2Xe6mlgQDVu9jwJpmuVYl2LrjUC644ALbq4F9+vSJWfbQQw8BiB4fCTgHrNaxcG4C1nzoYVU7SLV9OAWs1dXVtuMI4xXkCYVC+OEPf4jW1lbs37/fsQ1Tp041/lbrb/v27VGPWbhwIV5++WUAkW23s5VrndiNqZRS4oorrvB8T6v1YGd3wLV+V9avX48JEybYXtBJVcAar+hSKBQyCn4BB3rXVErbhg0bjPsaGxtjeoQ7c1A3BzudzTzpbA+rpmm45JJLAACDBg0CEEnxBg4UPUpHwGpez62trfjqq69w7733Rn33zScoTU1NaGxszFhK8Ouvv248Z2NjY8x33in1N9UBaygUMo4pSltbm9EeNW+xlBKhUAgjRozAyJEjbS90pWMoSaKAVdM0/PrXvwYADBgwAGVlZRBC2KaDqu3t9NNPNyq8qzoOucR64dsrJ/+Z8J3vfMd2udq//uAHPzBShp0CM/NFjpKSEgwZMgTBYNB2vOvevXtzelqbUCiEzz77DEuXLoWu650KWM3nM0pxcbGrDAUvBqx206vlyueaDgxY0yzXUoI///xz7Nu3z9hxKMXFxXjrrbdiHv/QQw/FnBiokz41l5/aWbhNCbZLS4vXw5rOdL10UldF1fowF10yryNr6qYya9YsxyvvTpUHrcwHV7UjPPbYY6MeM3r06KjbBQUFaUlRc+rpMp+cepW1R8HuYLdt27aYZa2trUYgmMkeVhUs7dmzx3jsY489BsD9tpOqaW2y3cMKAH379kVxcTHWr1+P7t27GwFrOvcxjzzySMyy1tZWnH766cbtKVOmRB0/pJQZSwk2X2Bpa2tDr169oh4br0pwKgNWu+3RvA9S35V77rkHM2fOxJo1a/D+++/bVr22u9CZ7oAVAIYMGQIAePHFF3HVVVchEAjYjl1UWRhnnnmmsd+1G8vodW72h/lKXSD+1re+FbX8m9/8JoBIGrCaMtBpvWiahhNOOAGVlZWor69H//790dzcjMGDB8c8NpcDVnUcam5uxsaNGzFp0iRs3bo16ZRgtY7Hjh2L7t27Y9SoUa4LF3o5YDV/tl6OH9KNAWua5VKVYF3X8fzzz+PLL79ETU0N1q5da9xXXFxsXHG3uu+++6Juf/XVVwAiPUp33nmnsbNQOwBrWku8okuqN8G6AzOfeJh30G7nKM02KWXcMazWdXT00UfHPIcaX2dn+vTpjveZn9s8nYb6DMaPH4+6ujpj6qEePXpEFTlJ14FQ0zTbk7jOTu2SCfHGbKlxua+88krC51D/n4qAVZ2I2/Ww2gVL9fX1AOyrVhYWFsbMo5yplOBQKISTTz7ZMTU8FdPamIsZde3aFZ999hkAxAReqQxYrSe0QOSzV3Mkq9vm7565OIlZoiyTROtQMe97d+zYYSwvKCiIum1+LRWwqgsFdhcTO7PPGD58eMyy7373u8ZxRX1X7AJb67JsBazWrCE1lt1KBafBYBDFxcUAkp9GLpvcZJzkq3379gGIVPj+yU9+AgC49tprjWDKPGVgvPXStWtXHHzwwdA0zdhmzN99ta3t27cvZwNW6/ezubkZn332GVpbW5P6XqqLBffeey+GDBlirD83vBywsoc1ggFrmuVSlWDzuImmpqaoYKa4uBg1NTW26WhvvfWWESCGQiGj2uzWrVtx1VVXuRrD2tGUYLuTotWrV2PKlClpHWeZKmqnEwgEjBO+eFWCrSeLAHDqqac6Pv+0adMARKaoMfeQBgIBXHTRRcbtGTNmGOvJHETU1tYaUw9Zx2BJKdPW49mvXz8AMFKQjz76aCxevNjzY7jMgYT5YKeqFi5atAh79+6N+b/i4mIjELTrYe3MiZ65F1P9VstOPvnkmMePHz8eQGQ6KSBSfKuqqgrTpk3Dyy+/HPMZdDRg1XUdkyZNQs+ePfHjH/8YQGTfEW+ohLoC/8ILL9j2mAGpmdZGBay6rmPTpk1GkKCqtaZj2MG5554LAOjVqxd69uyJiRMnYunSpcb8pwCwZs0a4zVbWlogpexwSrCbdaiYU4LNQxHs0uqcTqZSXV/AfOFUOeSQQ4y/VRvt0gGtF1+s09p0tm2Au4BVfbfNxzS77V1td8XFxUbAmos9rH5NCdZ1HfPnzwcQSeU955xzAAAnnXRS1P7d6bzGzG5cp3mMptp+dF3P2YDV+v0sKirCoYceCiC5Y58KWEtKStC9e/eoDKJEciFg5TyslFa5lBJsTskMBoNRqaHFxcXQNA3hcBizZs1CVVWVcZ9K2VQTWpuZxzvapbsC8asEuxnDqtr81ltvYf/+/WkdZ5kq1uBd7SCdAtbq6mqUlpYaPRkAcN555zk+/3PPPQcA2LNnDz744ANj+fz589G3b1/jtpoyAYjdOSqapmH+/PnG67odE5KMxsZGFBUVYfz48ejVq5djsRKvcepRmDdvnu0BZsCAAQCA//znPzEZCKnqYbWmE5kPdipYGjBggPFdVif8qu3XXHMN1q1bhyeffNL2goHaZs1zmDqNHVSB+9KlS7F7927jROK8884zhhrYrSfrFXi7XrRE09q4aZ8KWMOWOVHV9E7pSAlW6/kPf/gDdu7ciSVLlkDTtKiA9Nhjj42pKfDqq6/GXIyLF3y5WYeKOSVY0zScf/75jvMBW/cX5h5Wu+yXZKisHyvrPKzAgYswqjqx3RhR67Q2nWmb0pEe1kTfbRWc5nrA6seiS7qu48QTT8Rdd90FIFKjQBU83L9/v+2F+Hj7d7uAddWqVTGPW7BgAb788suUBaxqHHhlZSUGDx6c1mr9P/jBD1BYWIj+/ftj2rRpWLJkiRGwJpNZoL4rJSUl6NatW94FrOaLsW6zCXVdx7Rp01BVVYXKykrHY2AuYMCaZrlUJViNmxgwYADq6+uj0lDVSZSmaViwYAEefvhhI3hSV+OtJ3tA9FijdI9h/eKLL6Lam+k00o6kI1vXhVoHTutI0zTU19fj5ptvxg033AAg/g5d9VC2tbVFnfBcffXVUQFrUVGRsZ6sPXJmtbW1OPnkk9GjRw/XY0KS0djYiOLiYui6jp07d2LFihWe7y0H7Mds6bqO//f//p/t44877rio3+o51Ml2KgLWeD2satu5/fbbjYwIayVqu9RTs8LCQmzfvh0TJkzAokWLsGHDBmPsoJqGSbHbN6jXsvbwm1mvwNulK8cruqTmwLS2z3rAVgGrdRy16u1MR8CqPgNrj6kKVIBIEZ7f//73AIBLL70UQGQcpPU7ES/4crMOFetnP3jwYLS1tRnVa83s1rsqfpSqMazWaqndu3ePek3gwL5SFYs79NBDUVRUZDu8wCspweZlZvkSsPqxhzUcDkdtS2vWrEkYsLrtYd2+fTsaGhqM4VZmb7zxBj788EMjOOvMd05lY6xZswabN2/G+vXrsWjRIkyaNCktx+CGhga0trbi2muvNS6Mulk3TlQPa3FxMZqamrBhwwbX7fZCwDp//nwccsgh6Nq1K6qqqozhdtaAVdd1TJkyBddffz3GjRuHnj17xhxzgQMzLzz11FPYsGEDNm/e7HgMzAUMWNMs16oEd+3aFYccckjUjgOIPokCIgHUgAEDcNRRRxkBTHV1ddSJBADcfffdtj1IZk49rObUmXhjWNV8ZS+++KJxf2lpKaZNm2b7JU4HXddRXV2N66+/3lWAZR2rmqiHFYis85/97GcYMWIEgPgBq3qMeYyg+h/zVcdFixYZn4+1R85qyJAhKCgoSGt6rgpYzQd/r/eWA/YHO7sgraqqCnV1dRg3bhyA6M/QmlasliUrXg+rXRaDaotTIGWlAla7/Zl17juni0eqNx2w3y+q9GQAuPLKKx2DEMC+6NKDDz5o+7zWXkYVsGqahrFjxxrL1UW7dPawWi8MmPe1wWDQmFpHBWRqHl/zdyJe+8xjj2tra23XIRA5WVXpjOqzV7/ttkO7q/9q7uBUBazmCwglJSVG4SfzPk1t36qoWWVlJRobG21fM1spwW5718xjWNW6z8WA1Y9Fl8z7DSByMbK0tBRAJJDq6JAPFbDquo4nn3wSjY2N+PTTT437zd95KaUxHV1nvnNO2RfmTKxUUr3RjzzyiHG8SEXA+s477+Cll17Crl27XF/wznbAevfdd+OHP/whPv30U3z99dfYsGEDrrrqKgCxAWs4HI6a/WH37t2YN2+e7YVip/fhtriilzBgTbNcSgkGIidudtPaWANWAOjevTuGDh0aFcAUFRWhR48eGDRoEHr37h11ctSRgFUVG1EH7Xg9rCpNxryD3rlzJ7Zu3Wr7JU6HcDgcdcKfaOduTY92E7AqToWozFQ1wSuuuALz589HaWkpCgsLEQwGMWXKFONxJ554YkybnF67W7duaGhoSGs1ZhWwWtPTs1V0qSPFaqwpweYxgIFAAHV1dVi3bh1qa2ttt2vrAVMt64iZM2eiX79+UdPlxOthNRc262gPq3lKJjvm74CmaZg8eTJKS0vRo0cPY/miRYuM3ju7E6xdu3YZf5t7o82SmdbG2svY1NRk7OPUOGr1XObnzkbAqj4fNW6zoKAg5jsRr3133nmn8beaNsVK9ax8+OGHAGBUro63r+nIGNZkA1ZN03DcccfhoIMOQn19vbHt2KUE33LLLQBgjBW3C/SSSQkOhUIYO3asY2pkRwPWeMGK3RhWFl3KDeYMLyDy3VE9rPv27Us6JdicZdDW1oZgMIhZs2bhtttuA3Cg6Jnab3Um1d0p+8KciZUqoVDIyBZbuXKl0YurgvLXXnutw8+pvvOvvfZa1LHOTbCd7YD18ccfd7zPuo+16xwCEDP9l7X+iFm8TBuvYsCaZl4OWO1SWK2pPIpdwBoMBo2DqephbGpqwu7du/HZZ5/FFJmJNw+reedgNxfswoULo9pp7mFNtCN94okn4t6fCuY2uNm5d3QMq5lTEG+mrr6pXqn6+nr8+te/Rn19PSZOnGg8zvxZOI1hVbp164bm5ua0XvFXAaumaRg/fjz69euX1hTkeObMmeO6WI1d0SVN04wrpIsWLYq6eGOXOdDZgPUHP/gBQqEQtm7dildeeQWnnHIKAPseVnMvqrUt5t7XeAoLC223BSGE7Tjnrl274rDDDosKQseOHRs3qDFnTZj/z8xadMncw2qtbAwAv/vd72J6Gc1Vgs3vW7VNzUnrVCk9GU7r2SlgVdPMTJ8+PeY74XSSOmfOHPzsZz8zbt911122QZf1avtTTz0FIH5vRyYCViCSLTNkyJCo8b3mk7X169cDOFAga8WKFQAOVGs162hK8IIFCzBz5kwsX77cMTUyVSnBuq4bFxc++OADpgTnmP/85z9Rt995552UpARXV1dHXdRqamrCfffdZ1zomzJlCg4++GBjqE9nvnO1tbUoLy9H9+7djf3NqFGjjPH1qfS3v/0t6nZzczMefPBBYwjEeeed1+E0ZHXeY54OzO0F72wHrHZV4xXrPlbTNCPzxmzLli1R60zTNPzmN78BEMk86d+/P0aMGGE7vj8XMGBNM/PB20sBqwowb7jhhqiUCbtgEUgcsJp7GIHIe9y3b1/UyUBHeljViYk6CXn88cej2mleryeddBKAA3PdWZ111lnxV0Yn3XXXXTj//PON2z/5yU8S7tztxrCap7WxriMzNz2s5mp5wIF0Yk3TogJS82ecKGBVKYlq+pN0UAErECkI1L1796wEq7qu4/bbb49aFi+FxikFbuDAgQAOVOBV0tHD+uyzz8a0CbDvYTUHS9btydz7Gk9hYSG6detmjGVX29ppp51me5HB/Nman8NpqISu68a4TQC46aabbAtG2BX/UfsdTdNQUlKC8ePHG4Gb3f7AKWAVQkDXddxzzz0AIvNjpmosl9N6Nt82fz5q/NrZZ59t+52wKzb129/+Nuox//3vf21T5KxX21V103j7GmsqdroC1v379xvbjVo35n2UXRVhwDlg7UhK8MMPPxx12y41siNVgs3DXNSyZcuWYeTIkRg3bpxRLG/WrFlGMbJMBazm4mSdLbbjx6JL1jlSx48fH5US7LaXXVHnYpqmGRcfzfc98sgjKC8vx1dffZXSKsGBQAAXX3wx/vvf/wKIjJ1PxzF48uTJUbet34tk0pD379+PkpISjBs3zhhO8txzz+XEPKxqn9u7d29jf6eq6dvNw3rMMcegW7duURlLdjM4qO3ypZdewqZNm7B69eqcDFYBBqwpES9t0Ks9rCrAbGtri0qZMAeLHQlYrakHgUAAUsqok4aOFF1Sr60CVikl9u/fb6Sqma+Ud+/eHYWFhcYVwfHjx6OiogIAcP7552Pu3LkxbXeb6pnI/PnzcdVVVxk9MECkMmwyY1hbW1tTlhJsrpYXj/l14r22ruv405/+BCAyZU66Buybg5ri4uKs9S7YjT+Nl0LjdLCzXjhQ0tHDalcYB4jfwxovJdhND2uXLl3Qo0cPHHfccXj66acBABMnTrQ9QTAHhUpBQYFjMbpwOBx1Qvfll18aBSO6deuGyspKTJ8+He+//z4A+5TglpYW7N+/HyeddJJxRfrLL7+M2zZrD6t5HFAqx1M7pQSbg7H33nvPaE9DQwMA+32x+j9z8GUtAqPYvYcLL7ww6rY6oVGvfdNNN6FPnz4YPHiw8d3PVA+reZ9gF7COHDnS9v/MY7yUjqYEm6cYUq9v7a3pSA9rYWFhVLCiqmerbdj8+FdffRVA5wJWcxAar0KoKs6iipN1tthOvHmp81Xv3r2jbn/yySfGdrtv3764Fy3smDsPKisrY+7fvHkzGhoa8Nprr+Hzzz/HJ598AqDz3zn1fUt3D//pp58OABg2bJhRIXjGjBlR201H05AbGxuNY+3QoUMB2M9hbyfbAavaX82fPx+LFi0CcCBzz65K8P79+9GrVy8888wzcYdPmQu55ToGrJ00b968qLTB0aNHR+3gvVol2HxCad7Incaw2vX4mQNWTdMwbdo0Y3zF//zP/wAALr/88ph5WK0BkV0Pq3ptNf0HEAlS7733Xui6HnWlXAiBsrIy44r0nXfeaVRnveSSS2Laffvtt0d9ZuaTsI6yG3fQ2tqa8KQ2FSnBHelhdSNeD6s5eGhpacEPf/jDtFQN9ErAunv37qjbXbp0ift4uzGswIHPwRqo2aWEdTZgdZrmaNmyZQCce1idii65GcOqsgJU0TXAvmcLsO9hLSgocDzBijf+pqGhAZs3b8aiRYuMMep2RZdUkNe9e3d069YNAGynOogXsJrHIqdyLJfThQHz9+rCCy/EO++8E/VenE48zO8bgOM4J7uTGvXcitofqm1gwYIF2L59O9avX29UgXYTsKZi6hjzdmOXEqwKzAGR9EUVbKciJdichj5ixAjb1Ei3AWtRURGEEFHffaeLCgUFBZg8eTKKioqSHsNqrZAdr0KoU3GWRL1cThd+zUMk8q3oktM0WarokfLTn/4U9957L4qLiztdJXjGjBlR+2O7ffPy5cuh63rOBKzq2LhgwQKjQrCmaUYHwx/+8AdommYMXZs5cyZGjhyJadOmOZ57qB5WAFHp2G5kO2C1qxCu9mF287Du27cPJSUlRnrwIYcc4pjZpJ431zFg7aS//vWvUbdXrVoVdVXSq1WC1dUnIJIiN2PGDMyZM8dxDKsdc8AKRE7q+/fvjxkzZhiB3IMPPojJkydD1/UOpQSrNuzYsSPqsa2trXjwwQejrpSHQiE0NDQYbVmwYEHcndVjjz0WdVudhCUTtKp0ZDPzVD5OnIouOQX1Zh0JWDuyk9q6dSsARE1OrliDBzdBeTK8ErC+8sorUbe//vrruNtIvB7W4uLimMDB7jPsbMD69ddf2y5/++23AaSnh1Wl/quiXkVFRR0KWM0pwdYTLE3ToqoEOzFPewJEiu6sXbsWuq4bwenLL7+MjRs3Auh4wKppGn7+858DAP7yl7+kLD3O6cKA+XvV3NyM5cuXA3AXsJqDH03TMHToUBxyyCGYNWsWjj32WPTu3dv2pMYasKpt3WkbuP32241UXLuANVXzsAL2Aatd0SUgMub5jDPOAJA4JThRwHrRRRfhL3/5i3FbVc+36kjACkSnPjodJ2677TZomoZAIICXX345qYuD5mI9VtbhDar6spXTBRpd1zFs2DDHMf75WnTJ2hOtLgAcffTRRtEvs4ULF0IIgX/84x9RVXA7GrBqmoYlS5Zg1qxZmDVrFpYsWYL+/ftHPV6lg3bmO6eyvIqLixEIBFBQUJD2gNV6UV0V1xs8eHDU7AuhUAjvv/8+nnrqKZx44om2xTQ//fRT7N+/H7qu52zAWlJSElWsC3DuYVUp5/3790fv3r1t908MWMlw2GGHxSwzXzmVUnoyJdh8NfChhx7CRx99hHnz5mHz5s22Pax2J+rWgLWhoQHl5eUxB0qVgmYN0hRrwPr+++9j27ZtCIVCjr0s5hMP68H3/vvvxwcffADAfmelqm1aJVPmW50c9e7dG+Xl5QCAG264ocNjWK09rPEuFqjP5Qc/+IFjBeSOBqy6rmPJkiUAgF//+tcxJ0iaphlTXgCR9W/thUwFrwSsTgd7NS+alVOPgvmKr1mqe1hfffVV4yKRdds59thjAUR/z+IVXerIGNampia0tLQYB87S0lLHgNVciVdZvny5435R13W8+OKLEELgwgsvjDlBsyooKICu61i7dq0xVlN9Xk8++SR+9KMfAYhcRLNu34mKLh111FEAgMMPPzxuGzrCKSXYHCAEAgFMmjQJQMdTgoHIBb++fftixowZqKqqwvbt2/GXv/wl5v3bBfELFy6Me9FCjXEzX4hdsWIFtmzZktKpY8zfIbuUYPP2Xlpaajx2+vTpMftHu2Darm2hUCim4uZ7771n2z7zfMdqW37uuecSFjNsbm6Gpmk48cQTUVZWZgxpAYAjjzwSuq5j3759ePXVV5Oai9pcad3KOrzBemEYiJzb2PUoqzRm69hh8/HTKSV43rx5qKqqwtChQ3NyHsgHH3zQdp/89ttvxxSZBCKF0vbv34+NGzcaQybM82y7DViByDF4wYIFWLBgATRNi+l1VRfKOxOwWoObkpKSjAesZWVlACIXHn/0ox85jp+fN29e1Dak6zpeeOEF7N69GzU1NcYFSrft90rAGq+Hdfv27di9e7exbzD3Jse7UKyeN9cxYO2k2bNnxxwU1FVJa3qn3YlZKBRCVVUVunXr1qnU1I5yqrj59ddfGztB8wHbrnfJGrB+9dVXKC8vj6lqV1BQgF69ernqYV2wYAHeeOMN7Nu3DzNnzsS7776Lu+++2zjJKC4uxowZM6JOPKwHXymlcXCwC1hTWeZbHaQefPBB4wROFdqJx67oktsxrGruss2bN2PevHk4+eSTYx6jAj+7lEA75tQ0p97TI488MqpXwu6A4Wa8VDxeCFgXLFjgWFL/zTfftD1xdDrYmcfUmNn1sG7evBl79uyBruuuA9Y5c+agR48eGD9+PJ555hkAkSq4Rx55pPEYVdwiUUrw73//e4wcOdI48XQTsKpCQCpgLSkpcbyi3djYiGAwGLX+TjnlFGNdm0+wdF3HiSeeiI8//hhSSjz00EOYNm2acb+6OGRupxAiajtuamoyitiosfpAJMPCGgDEK7oERJ9EpYqbnmwppfH+OpoS/Morr2DHjh148803UV1dbYyLuvfeezF+/Pio76a1hxWI7A/N24A5Lb64uNjI0lGFqXbt2oU33ngDzz77rPHeUt3DqgJrVRkYiD6elJSUGFlPn3/+ecy0ZnYpwXZts7t46bRfN2dRvfnmmwCAZ555JmobsxYhUstUm0ePHm1UZgYiwba5XkNTUxOuu+46DB061PU0bZqmYfr06SgqKsKgQYNQXFyMYDBoWyFUpY8LIYyg/7TTTrO98Go3vh+IPn6aL+Bt27YNX3/9NcaOHYs5c+Zgw4YN+Oijj5LOasoWXddx7733un787NmzjbmBFbXNdXQMqx3V66q2y29/+9tRRRVTEbCm8xjsFLCq/czf//534/vk5L777kMoFMKIESMwdepU4/jW2NiIjz76KOp1Esl2wGruZFDrXx1v1MXY5557Dl9++SVqamqwdevWqIA13nFXPSbXMWDtJE3T8Morr2DatGkoKirCwIEDjauS1jE+1oBVzX23YcMGNDQ0OKamqi9kZWVlp6v3vfLKKzjuuONsU1kBGAc1AEbQp1gP4sXFxbY9rJqmIRwOG0UI2tracPXVVxsBXbyA1VqVceHChaitrcWECRPQr18/LF68GJqmRfWw1tbWRk3Vop4TcN/DesUVVyRVOU1d1SorK3N9UqvrOn75y18COFDhsiNjWBcvXhx1+4UXXojZZpx69pxUV1ejuLjYmKvVLg3MbryVmobBmioVb7xUPDt37sT69euh6zqKi4vR2tqa8QPHI488EnXbXIVPpaRbOaXAmSucmll7WHVdx+LFi7F9+3bU1NRgzZo1xvM6+elPf4p58+bFFBF67733jOqCQOKiS3/+858BRK7evv/++7jjjjsAJE4JDgQCMQFrvB5WFXiY09aampqwZMmSmGDr3nvvjdnWVq5cafz9t7/9DVdeeSUA4LrrrgMQORk09zAEg0GjaI459VgFAOaLMnv27MGHH34IXddte1jV+3N6b8lwkxLc2tpqFN9R69ptSvDzzz8PIPJ+m5uboy6UtrW14YorroCu65gzZw7OPPNMAJGpFaZOnWoENebhAW1tbejfvz9GjhyJ+vp6VFVVAThQmEq9Vltbm3GSlMqAVdd1Y+qQP/3pT8Yx0Frsz5rOb57WzO0YVuvFy9LSUnzyyScJCyuqaY+s25hdSrD67u/duxdlZWUx3wtzGwFg6dKlRiZUr169XO1Xu3btigEDBmD9+vU477zz0L9/f9vjnKZpqKiowLHHHov6+np0797d2N6s1Fhws+OPP954XiklWltbEQgEoOs6Fi5ciKamJiO13SyZrKZsiZdibTV79mzMnTs3Zjty2gbsJApYgcjnpvZxKnD1QsCqLl5XVlaioqLCtnhXoh5WVXshnqamJsycORNr1qyJ2l7b2trQs2fPqNdJJNuFwhL1sJovFDU1NWHHjh2ujrvq/SfalnIBA9YU0DQNTz75JI444giMHj3auCrp1MN6xx13IBQKxQRninknroLaNWvWYPPmzZ2q3qeCihUrVtimWVRUVKC4uNjYsK07W+vtYDAYtTPbsmULvvjiC6NdKs1IVfhVlRDjBawTJkywfc2qqipjgDkQndoFRMb8qB7F4uJio+qleWeldqL/+Mc/AACXXXYZvvnNbwKAcfLbUSo4NQesN998s20Po67rmDRpEsaNG2d8xjfccIPRo+Z2WhtV/tzMeuDvaMCqaVrUXK12V9bNxWeUNWvWYM6cOY5FO+za5kTXdWzYsAGrV69GTU0NNm/eDCDz8xBa37tKB43H6WDn9DlYx42aT4aampqwatUqAPEDVrUdWxUUFET1htlNa2NOCXb6fJLpYXWTEmx3ccQ6LMDuJMP8OZx//vlR43fU+9M0DTU1NaioqEB9fT1OPPFEAMBVV11lpLQLIaIuyui6ji+++AKrVq2K2u7Uc5rfXyoD1ngpwWpMcDAYxOTJkxEIBBL2sLa2tuL+++839j1qTHpBQQGKiopiMoHa2towZ84czJs3z+i5fO6553D22Wcbwcfq1auNx6vPr2/fvjEXZM0FngoKCox9YSoDVvMJm5qzEYjdV1qLj5mnMTIXhFK9tHaBVG1tLQKBAKqqqnDhhRdi37592LZtm+0FOBWcAUBNTQ2A2G3MKSUYiGxTZWVlMd+LGTNmYMSIETj00EONk29l586dri4GfvXVV+jatSuASM9VvIupTU1NGD9+PDRNQ9euXR3HxJt7t5Ubb7zR+Fvts4qKihIGeclkNWWLdXiS+vvUU081erHVHJeqcFBtbS1+8pOfAIgElOp7kUxKsBN1AcFaKyWZNPxUBKzmi9ebN2/Grl27sHTpUkycODHqnDVRD6ubGQ7iXVRV23o6e1hTmSFpF7Cae1jN519tbW1oaGhw3cPakWw7L2PAmkLdu3eP6u2wBqyq2I/qeVIHEivzTtzpZDKZOaqcKhIq1dXVUTvJ2tpa1NXVRV1xNzOnBOu6jvXr1xvBxoMPPhj1WlJK46TPeoKhpnQBYIzXOv7446Nes2vXrlFX0L788kts3LjR2AFqmobFixfj5ptvxuLFi40eV/UlNu9EP/vsM+M1rr32WgD2Y7jcMAesKhVt+/btMT2M6vWXLl0a9f+qx64jPaxz587F1KlTo5aNHj066rZTz1485rlane5funRpTPn+22+/Hb169XI9XsqJNZ1TTRWU6YBVpcsPGTIEdXV1uO2226JSt+3K5DvNw5poDKt5Wih1QAkGg0bhiXgHTbuJw4HICYw5YLXrYTUHS06fT6Ie1p07dxoBnHqPiXpYg8Gg7cURczEJ4MCJPxA5+Z89e3bUGFbz9qG+u2r9DRkyBIFAAJqmGff99Kc/RW1tLbp27YoTTjgh6qKMud5AU1OTMfYJOHDyl8mUYLv1EwwG4wasoVAITU1N2Llzp7HvUSdPF1xwAcLhMBYsWBD1HQ0Gg/jwww9jnst8zFHjn9Xju3fvjjVr1kDX9aiAVVWqHDRoEKZMmZIwYJ0zZw769OmDXr16YcSIEY4neiqVW13oMB871Fhc6/Fk7ty5xvy9Z555ZtS0ZqqHVdd1Y2jFGWecEZNm29zcjJaWFnzve9+LSetUWSWKuYdV0zQMHDgQQ4YMwSWXXIJFixZh7NixeOmll4x9uzUddO/evSgtLbX93AcMGIDevXtj7Nixtusn0cVAa8DqFIRKKaMeaz3emqmqzAUFBcb3Xu0zly1bhl/84hcADkxL4nTx9eKLL8aOHTuSyhZTF3979uyZsaFUmqbh1FNPRWlpKWbNmmUEoo2NjTj44ION8x/redKMGTMA2KeFP/nkk7bvv7W1NWo4QDxqeITaBjtTmTsVAavTxeuWlpaoc9ZEPazqgptKVQ8EApg9e7ZxvLr55psdi/IVFRUZx9DOjGGNd758zz33OGZIJjOnsV3A+sYbbwAA/vjHPwI4cFyUUqKhocHoBCotLU0YsOYDBqwplChgVSlaypYtWwBEeghUMHfttddG7fCcTiaTmV7B6fFVVVUoKCjAsGHDYq7q1dbW4vnnn7dNIzIHrNZgA4gOTAsKCoyTR+sBbM+ePfjkk09w+eWXG1e7//KXv0S9Znl5uXHCpus63nvvPXz88cdGBWIgOuCyplRcd911MTvRO++807g6aTc3oxvmgNXp5GHhwoVxeyCByDbS0tJizKW2YsWKuK/7/PPP45prrjFu33XXXVE7xM8//xx79+5NuJPs6MmCpmm4+eabY5bv2LED3/3udwEAgwYNMk585s+f7zrVWgUQqndCnRilKmC1jrE97LDDbNPv1Tgl9Vlomoaf/vSnACInAT/60Y8wadKkqIOReTqojoxhVUGLpmmorKzEqFGjUF9fjzFjxkTdb2fKlCkAIhU+zQHqvHnzotLGE/WwqgtTquiLOtmPd7JkTs8EYAR5LS0tRkBjZT5wWi+OWANWNe/grFmz8Oqrr2Lu3Ln41re+ZdwfDAaNgF3tF9T7NO8r1Pdafc8rKiowbNiwqIsy1u3OXFgpFT2sTicv8YpbWddPooA1XuBy2WWXQdM01NbW4pVXXkFpaSmGDx+OxYsX2x4TzMcctY7Ly8tx5513YvXq1di8eTNqampi5n08+OCDUV5eHnXxyi5gvfzyyzFv3jxs374dO3fuxJo1axx7C9U6Utk1l112mXFCrk6AzccTtd3ddNNNAA7M9ajua2pqwqZNmxA2TdPV1tYWMx5fretu3brFHIPXrFmDXr16Gb0qq1atirrA2KNHD3z88ce45557MG/ePCxfvhyfffaZkX3klBIMxH7u3bp1Q0NDg/Fdt7K2zbqtLV++3PjOd+nSBfv27bMNZPbv3w8pZVRw6xSwHnTQQQCA73//+3jyyScBAL/97W9RVVWF8ePH49ZbbwUA1NXVAYARwAKR4Tgq++lvf/sbrr/+ekyYMKFDw5zU+PalS5di9+7dUVMtOa2LZGsqqOc544wzcPDBB+P5559HW1sbjj76aOO7Yf4u21EVmLds2WKcI6mpqv75z3/aFtRyyr6wo/Zx//nPf6DruhHgJROwWos1JhOwOk2nZZ1X1SlgVcdGdXFFSokzzzwTS5cuxdy5c/Hb3/4WANC3b1/U1taiqKgIFRUV6N+/P6qqqow5XdXFNvU6amhdr1690K9fv5jtxTzu2tyT6cRalE257777oqaTcpsVaVclWB1jV6xYgUmTJsUUfvvkk0+MisjqO2z3vAxYO0EI8S0hxAdCiI+EENdlow3p0NTUhE8//TRqShvgQMBqPbioL9Tzzz9vjFMaP3581GOsX8jCwkIcdNBBxjhZ85XGysrKqB2/9Qu6aNEiDBw4EL1790aPHj1QVVWFuro6rFu3DmVlZbjnnnvQ2NjoWA3RyhywqqtZ6qRvxowZmD9/ftRVP9W7aD3BWLZsGXbs2IF77rkHv/rVrwBEjxsEIld8m5qa0NTUhPvvv9/4YjY2NtqOKSwoKEAwGMT+/fsxZ86cmJ5NIHLi8cILLwCInNQ5HdDipX2oE9jS0lLHiwtnn322Y8XGwsJCY7LsnTt3GuMJTzvttIQHcHNPp3m8lAom1HhI6/OYbydTfbK2thZXXXWVcVv1fnTt2hXdu3fH+vXrMW/ePADR6XiJDBkyBAAwbdo01NfXY/jw4QAin3FnU2/sxth++OGHMSfK6iRLUYGA2mZVL9zSpUujDkatra1GKqkawyqlxJYtW7B169aYdWztYQUiB1aVkuem6NKKFStQUFCAf/3rXzjhhBOi7lP7EyB+D6s6OaitrTUuRKiALV4Pq7Xwipp6Y/Xq1fj4449tt6t4B06VEqz2WRdccAGAyMmxOnlX6b0AUF9fHxOwqpOk8vJy7Nu3Dy0tLdizZw8KCwuNgKBbt24x2RSHHnoogAPbnbnyu3pONwGr3bitUCiE8ePHx5y8TJgwwSgK4uak1Dz8wm4dxstiMO9LNU1Dz549sX37drz77rvG2NWePXsaxwPzBSbzfNg7duyIGkNlndame/fu2LNnT1TarV3Aqoo/WVmD7lAoZGSOPPzww9B1HTNmzEBJSUlUOrka7w0c2J+pFFpVyVzXddTU1KC5uRmPPvoodu/eHbM/vvLKK9GrVy+MHDnS2A9069YNtbW1UXO9ApHsAtWrsnjx4pjig07mzZsX891WKcF2ysvLsWfPHrz11lsoLCzE7NmzjYs5t9xyi/FZ6bqOI444AuPGjYva1nbt2oUVK1YgFAoZr2G3Das2qwtfLS0txphuK9WbetVVVxkB7rvvvosNGzZEnTCvW7cOkyZNipoy5+67746ptN3a2opFixZh3LhxrvbtTplit99+u9HeVNVUUHPZPv300/jss8/Q1NSExsbGqOfZu3cvPvvsM8fnVd9zILLd6LpuzBlvN54ecB+w6rpuDC1btWqVcQHfegHQrVT0sGqahokTJ6K8vBz9+/c3CvstXbo06kKh00wGdgUP9+7da/yv2p527txpzG977bXXYtOmTVi3bp0xp6t5Whvz0LqdO3di69atMQXZOlqlX53zWpWUlNimwdtlRarzmoqKCtx2223G+rDbxzc3NxvnSEpjY6NRgEndtsqngNVIhcrUD4BCAB8DGAIgCGAVgBHx/ufYY4+VXrds2TIZCAQkAAlAlpaWyp49e0oA8qijjpLLli2TUkp50UUXSQCyrKxMlpWVSQBy7ty5csOGDRKArKyslBUVFbK8vFxWVFTI/v37SwByxIgRctmyZfLwww+XPXr0kD169JDl5eXG61l/zG2x/gwZMsRoj5RS1tXVxTxm9uzZCd/zxRdfLAHI/v37G+9lzJgxUc/9xz/+Mea5p0yZYtx/yy232LbxrrvuinqtH//4xxKAPPjgg2UwGIx67KxZs2zbV1xcLHv27CkLCgoc18XQoUNjlql1X15ebrwv609ZWVnU/X/4wx+MdTl8+HBZUlIiARifYUVFhSwsLJRCCOMzVZ/TsmXL5LBhw6I+s4KCAnnLLbck3OaEEFHtLi8vl6WlpXGf55ZbbpGFhYUSgCwsLEz4Onba2tpkIBCQJSUlxnssLi6WgUBA1tXVyX/84x8SgOzZs2fUOjBv19bbans+66yzpJRS3nTTTRKA7N69e9zPwM3zd+3a1XEbKCwsjHp9809dXZ2xrp3+X/107dpVLlu2TH7/+983vhfqvuLi4qjvxfvvvy8ByN69exttBCCHDRsmly1bJteuXRtzv/k9mdtaXFwsZ8+eHdWW//u//zP+Pv744+WyZcvklClTZGlpqezRo4exjdx9991GmxYuXGjsuwDI3/zmN3G3PbUNqXU4a9Ysx++Ren+HH3541HpQiouLHb9r6jOQUhrLli1bJl999VUJQHbp0kUCkJdddpmUUsqrrrpKApCHHHKILCsrkwUFBcZzHHnkkbJ79+6yR48exjpV29e0adOklFL+/Oc/N17nd7/7nZRSyt27d0sAsm/fvrbbmVPb4/2o9Wf+DJz06NHD+D+1r7FS+x71+ak23XzzzVGPMbehuLg46n1avf766xKAHDBggKyrq5NFRUVR+y5ze8455xwZCARkWVmZDAaDsq6uTq5bt87YD6p1Zn4O808wGDTWqd36LCoqksuWLZPLli2Tt9xyi7EdXXvttTH7u7a2NglA9urVS/bv3z9qn6ie68ILL0z4GZ155pm2681pO3Wzn7jxxhujvh8A5KGHHmr7vTjnnHOivmfFxcXyt7/9rbF/se4LnH4KCgrkd77zHQlEjqFquy8rK5M9evSQvXv3lgDkMcccI+vq6qJes7y8PGrfYz5vcTp+m3/OP//8qM/42GOPTfg/1n2H077PaRuKt78PBAK2xwu7Zdbtxvxj/k4Ckf2sHes6mjZtWsx2otZxt27dZGlpqfEejzzySNvtwum5hRDylltukQUFBbJXr14Jj7lOx+Bzzz1XSinlkCFDZFlZmeP6cbpdVFQke/fuLZctW2acJw4aNCjq8Wo7Mu/fpZQxxxHrY9ra2mRBQYHs2bOnsd2OGjUqZj198MEHEogcQ53OAQsKCow2mb+HV155pW2bze9RHXfU90j9bT0/Nf9UVFQkPLe8+uqrjf2XdZ+1bNmymGN9YWGhHDdunPHdrqioMLahiooKWVxcLIuKimLWs5cBWCHt4ke7hen8AaABeN50+2cAfhbvf3IhYE2041Yb29lnn217/3nnnZdwJ24+iHT2R7VHSimnTp1q+0WOt6NctmyZ407A/MX4zW9+E/cx1hNfp8c4vVZhYaFtO92cYACRCwGpWqdu2qvWrbq/sLBQTps2LeF6dPoMOtIu8/+VlpbKwsJCWVpaGvdzdpJo/bo5KYn3c+GFF6Z0e0/mZ+LEiR3entRFCbv7zBdWnL4XQOS7aXfQjvcza9YsWVdXJ6dOnSrr6upinj/eulTbhzqhdbsNjhw5Muqxo0ePdtVW877HzbqdOnVqzPZeWloqL730Utvtxum7Zz3Qu93u6urq5Pz589O6rcVbz3brx+nxTvse9Xi7fX2857znnnui1vmUKVMc163d6zod79xsl3Y/dhfXzG1U7yPRNqUC21NOOSXha6qLt+eee27Cxzrty80/AwYMsF1u/V44fZZuv2fWH6f9kt26cfuciYL+oqIiecYZZ0QtmzhxYlLt99qP9bukLj67+f662Rc5bRfW77s5QLK7eJmq95fMT2FhoavtybzvsR77zMdhp/Vpt55uu+22tLbZ/OPm/L0jP9bvlTkgt77/jrQ3V4JWOASs2UgJHgjgU9Ptz9qXRRFC1AohVgghVliLHnhRvEm6gQPpAE5jE1988cWEr+G2pLob5vQEp3SyeEWdnOZiA6JTu+xScc2P0TQtqrCH3WPivdaxxx5rWyTIaUxXjx49MHv2bKOQlHn6j85y014gkh5XWFhopLV98cUXto+zm8zdzG3RLevzuKkInEiiYh/m6qLJePbZZ1O6vSfDnAbottKxKpaRSH19veN9zc3NRqp6R5jHm5vHl6p2OVHvzS4VK977tqarbd++3VU7ralRidat2j+Fw2EjRdcujQ6IbDdO3z3z9CZO7La7hQsXRs2RmQ7x1oHdfU6Pd9r3qMfHSx22e84dO3ZErfN169bZ/u8TTzxh+7rWKbis7KZIceJUt2Hnzp3G3wUFBdixY0fCbaqwsBDV1dWu0h3VdqPSi+P54osv4lZ4B5zHpVu/F06fpap90REFBQWuq8Z2JJX09ddfdzzvmThxYtQ8ocqIESOMcay5pry83KgEbN0WneYvtzuOu9kXKfEKbKopBGfNmoVZs2Zh8eLFePvtt10/dzwvv/xyp5+jtbXV1fZk/r7OmDEjasYHlSpr91gz63qyHgOVRNVy3bbZzOn8PdlU3GeffTbqdr9+/YzzNOv7r6ysdN3eXJpGypZdFJvOHwDnAPiz6fbFAP4U739yoYdVShn3ypZTdz4crqjY/SRz5Ue9tlN7lLq6Ojlo0CAphJAFBQUJe96sKdDmH/NVHKerYR15jNvXMnPzum4+N+v6j3e/m/YCMNJmVVqbXVvjXVV18xl05HmS4aZXrKPbqfX7YPfeUtXrmqh91p57p6vk1u9tYWGhbRvdPJ/5M+vIVXK7LIOOXIVV263da3ak52/27NkJt0e7bdJpXVRVVUW9vjUzwK69TtuNal+i7cfu/9302Ln9nJy2u1T2sNq9f/PjnY41ds/pZp3H++wTHdfcHPfKy8uNNEqn92zNGIn3eZlTxK2PsztWqh5W62Pt2q7SgqdNmyaHDx8up02bJuvq6uS0adPk8ccfL+vq6hzXoV0Pq3WdFhYWJtw3qN6Yuro6efzxxxttcPPdVO1wu/+ePXu2se4DgYDxnq3vo7i4WAohooZGqPZNnDgx6V5jp/2t9ScVvYXWHlS73k27bdTuc3SzL3LaLhJJxb4qVevM7edjlwVmTvt38/7cHlcS7XPcttnNcya7Dq3PF+982e1x1249exWYEpwZKvBT+eNVVVUxO/DZs2fL3r17y4qKCjlixIiog+fw4cNjcubNz7Fs2TI5ceJEYwyW9b5p06YZYxHMJ3zque3aYxZvR2H3WKfXs66TqVOnygsvvNBIWbR7zPDhw2X//v2j1on1tQYNGuT4mI4+Z7znN38GiT4jN+2tqKiQPXv2lBMnTnTcCbv5fOK129ymjj5PMszrV/2Y14V5O3c7/qVv377GCaL5vbn5niS67aZ9bj4j6+dtPjE0fw8HDRoU93NItK+w3m99T4k+Y7t2mfcddtutWidO32W71zB/p+N9jxKti2T2T2odOW031s/cug7ibXcqwLC20Wk769+/v6ttwGn/n2g92217TuvI7ntj93xu941269y6z4/3fbVux4nut34midgdt8zvMd5327oN221T8R7r9nMxM28D8bZ5a/DrtG9ws7+P9920nmdY2xjvmOjmnMHtY+K1z2lfYj0P6cj+PtEY1kTHhGXLlslZs2bJWbNmuXpv5n2K074oFcfwZI+R1u+d9Rjv9vmc9oXWx3f0e2N9f3bbrfVxdvsq676hI212c27odh2q/7fbPqz7Guv7cjruJjrvyQVOAauQLtNEUkUIEQDwIYAaAJ8DeAPABVJKxxzCMWPGyETTfBAREREREVFuEkK8KaUcY10ef7BFGkgpW4QQPwTwPCIVg++PF6wSERERERGRP2U8YAUAKeUzAJ7JxmsTERERERFRbshGlWAiIiIiIiKihBiwEhERERERkScxYCUiIiIiIiJPYsBKREREREREnsSAlYiIiIiIiDyJASsRERERERF5EgNWIiIiIiIi8iQhpcx2GxISQmwDsCHb7chxvQFsz3YjiMBtkbyB2yF5BbdF8gpui5Rtg6SUfawLcyJgpc4TQqyQUo7JdjuIuC2SF3A7JK/gtkhewW2RvIopwURERERERORJDFiJiIiIiIjIkxiw+kco2w0gasdtkbyA2yF5BbdF8gpui+RJHMNKREREREREnsQeViIiIiIiIvIkBqw5TAhxsBBisRDifSHEaiHEj9uXVwghXhRCrG3/3bN9+eFCCF0I0SiE+F/Lc/2k/TneE0I8IoQoycZ7otyT4u3wx+3b4GohxNVZeDuUo5LYDi8UQrwjhHhXCLFMCDHK9FzfEkJ8IIT4SAhxXbbeE+WmFG+L9wshtgoh3svW+6Hclapt0el5iDKFKcE5TAhRCaBSSrlSCFEO4E0A0wB8F8BOKeVt7SdbPaWUc4QQfQEMan/MLinl7e3PMxDAKwBGSCn3CSEeA/CMlPKvmX5PlHtSuB0eAeAfAI4H0ATgOQCzpJQfZfgtUQ5KYjscB2CNlHKXEOIUADdJKccKIQoBfAjgJACfAXgDwPlSyvez8LYoB6VqW2x/rokAvgLwoJTyiGy8H8pdKdwv2j4P94uUKexhzWFSyk1SypXtfzcAWANgIIAzATzQ/rAHENk5QUq5VUr5BoBmm6cLACgVQgQAlAH4Ir2tp3yRwu1wOIDXpZR7pZQtAJYAOCv974DyQRLb4TIp5a725a8BOKj97+MBfCSl/ERK2YTIRZQzM/ImKC+kcFuElHIpgJ2ZaTnlm1Rti3GehygjGLDmCSFEFYCjAbwOoJ+UclP7XZsB9Iv3v1LKzwHcDmAjgE0AvpRSvpC+1lK+6sx2COA9ABOEEL2EEGUATgVwcLraSvkrie3wMgDPtv89EMCnpvs+A0/MKEmd3BaJUiZV26LleYgyIpDtBlDnCSG6AlgI4Gop5R4hhHGflFIKIeLmfbePXTgTwGAAuwE8LoS4SEr59/S1mvJNZ7dDKeUaIcRcAC8A+BrA2wBa09diykcd3Q6FEJMROTEbn9GGUt7jtkhekapt0fo8aW84UTv2sOY4IUQRIjuPh6SUT7Qv3tI+3kCNX9ia4Gm+CWCdlHKblLIZwBMAxqWrzZR/UrQdQkp5n5TyWCnlRAC7EBlLSORKR7dDIcRRAP4M4Ewp5Y72xZ8jumf/oPZlRK6laFsk6rRUbYsOz0OUEQxYc5iIXCK7D5EB8r8z3fUvAJe0/30JgKcSPNVGACcIIcran7MGkfEJRAmlcDtEe0EmCCEOQWT86sOpbS3lq45uh+3b2BMALpZSmi+MvAFgqBBisBAiCOA77c9B5EoKt0WiTknVthjneYgyglWCc5gQYjyAlwG8C6CtffH1iIwreAzAIQA2ADhXSrlTCNEfwAoA3dof/xUilYH3CCF+CeA8AC0A3gLwfSllYybfD+WmFG+HLwPohUhBpmuklPUZfTOUs5LYDv8M4Oz2ZQDQIqUc0/5cpwK4E0AhgPullDdn6n1Q7kvxtvgIgGoAvQFsAfALKeV9GXorlONStS06PY+U8pnMvBPyOwasRERERERE5ElMCSYiIiIiIiJPYsBKREREREREnsSAlYiIiIiIiDyJASsRERERERF5EgNWIiIiIiIi8iQGrERERBkghGgVQrwthFgthFglhLhWCBH3OCyEqBJCXJCpNhIREXkNA1YiIqLM2CelHC2lHAngJACnAPhFgv+pAsCAlYiIfIvzsBIREWWAEOIrKWVX0+0hAN4A0BvAIAB/A9Cl/e4fSimXCSFeAzAcwDoADwD4I4DbAFQDKAYwX0pZl7E3QURElGEMWImIiDLAGrC2L9sN4DAADQDapJT7hRBDATwipRwjhKgG8L9SytPbH18LoK+U8jdCiGIArwL4Hynlugy+FSIioowJZLsBREREhCIAfxJCjAbQCmCYw+OmAjhKCHFO++3uAIYi0gNLRESUdxiwEhERZUF7SnArgK2IjGXdAmAUIvUl9jv9G4AfSSmfz0gjiYiIsoxFl4iIiDJMCNEHwD0A/iQjY3O6A9gkpWwDcDGAwvaHNgAoN/3r8wAuF0IUtT/PMCFEFxAREeUp9rASERFlRqkQ4m1E0n9bECmy9Lv2++4GsFAIMQPAcwC+bl/+DoBWIcQqAH8F8AdEKgevFEIIANsATMtM84mIiDKPRZeIiIiIiIjIk5gSTERERERERJ7EgJWIiIiIiIg8iQErEREREREReRIDViIiIiIiIvIkBqxERERERETkSQxYiYiIiIiIyJMYsBIREREREZEnMWAlIiIiIiIiT/r/CBsIJBHRiogAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# LEAVE AS-IS\n", "\n", "# Sample last 5 years\n", "weather_smoothed_sample = weather_smoothed.tail(5*365)\n", "\n", "# Plot smoothed temperature\n", "plot_min_avg_max(weather_smoothed_sample, ylabel='Daily temperature, smoothed [C]')\n", "\n", "# Plot smoothed precipitation\n", "plot(weather_smoothed_sample, \"rainfall\", ylabel=\"Daily precipitation, smoothed [mm]\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary indicating what are the key difficulties when implementing a function for \"moving_average\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, test what happens if you repeat the moving average process many times.\n", "\n", "For this, remember to create a copy of the original dataset, so you don't modify your original dataset:\n", "\n", "```python\n", "test = weather.copy()\n", "```\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with code that creates a separate ``test`` dataset, and smooths this ``test`` dataset 25 times. **Do not modify your original dataset**, this is just a test. Plot the smoothed daily temperature and smoothed daily precipitation in the ``test`` dataset." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary on what you see in the repeatedly smoothed dataset. Why does this happen?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2. Smooth the series by binning per floating weeks" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note: Pandas have powerful methods for [re-sampling a series](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.resample.html) that we will **not** use. Instead, we want to understand every step of the resampling process.\n", "\n", "First, we build a list of `weeks` that starts with the first day of the studied period and then adds one week until passing over the last day of the studied period.\n", "\n", "You can use the following template:\n", "\n", "```python\n", "def list_of_floating_week_starts(first, last):\n", " weeks = []\n", " \n", " # YOUR CODE HERE\n", " \n", " return(weeks)\n", "```\n", "\n", "In the list that should be generated:\n", "\n", "* The first element should be *first*\n", "* The next elements should be *first + 1 week*, *first + 2 weeks*, ...\n", "* The last element should be in the week after *last*\n", "\n", "To add one week to date *D*, use `D + datetime.timedelta(weeks=1)`.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code for \"list_of_floating_week_starts\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There should be **327** week starts in your dataset, if you have just 326, you need to add one more in the end, it will make your life easier. Note these weeks *float* because they do not start in the calendar start of the week such as Monday.\n", " \n", " (Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 327 week starts\n", "First week starts 2016-07-01, last week starts 2022-09-30\n" ] } ], "source": [ "# LEAVE AS-IS\n", "\n", "first_day = np.min(weather.index)\n", "last_day = np.max(weather.index)\n", "weeks = list_of_floating_week_starts(first_day, last_day)\n", "\n", "print(\"There are %d week starts\" % len(weeks))\n", "print(\"First week starts %s, last week starts %s\" % (weeks[0].strftime(\"%Y-%m-%d\"), weeks[-1].strftime(\"%Y-%m-%d\")))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we find the week that corresponds to every element in the time_series.\n", "\n", " (Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
temp_avgrainfalltemp_mintemp_maxwindspeed_dirwindspeed_avgwindspeed_gustssunpressure_maxpressure_minweek_start
date
2016-07-0124.10.021.926.399.03.15.8NaNNaNNaN2016-07-01
2016-07-0224.60.022.327.013.03.67.5NaNNaNNaN2016-07-01
2016-07-0323.40.021.924.920.04.28.9NaNNaNNaN2016-07-01
2016-07-0423.80.021.825.925.03.36.7NaNNaNNaN2016-07-01
2016-07-0525.30.023.227.435.03.16.4NaNNaNNaN2016-07-01
2016-07-0625.80.023.128.520.05.011.7NaNNaNNaN2016-07-01
2016-07-0725.40.023.727.199.03.910.3NaNNaNNaN2016-07-01
2016-07-0826.20.124.028.423.02.510.6NaNNaNNaN2016-07-08
2016-07-0926.60.024.828.518.03.16.7NaNNaNNaN2016-07-08
2016-07-1026.80.024.928.619.04.79.2NaNNaNNaN2016-07-08
\n", "
" ], "text/plain": [ " temp_avg rainfall temp_min temp_max windspeed_dir \\\n", "date \n", "2016-07-01 24.1 0.0 21.9 26.3 99.0 \n", "2016-07-02 24.6 0.0 22.3 27.0 13.0 \n", "2016-07-03 23.4 0.0 21.9 24.9 20.0 \n", "2016-07-04 23.8 0.0 21.8 25.9 25.0 \n", "2016-07-05 25.3 0.0 23.2 27.4 35.0 \n", "2016-07-06 25.8 0.0 23.1 28.5 20.0 \n", "2016-07-07 25.4 0.0 23.7 27.1 99.0 \n", "2016-07-08 26.2 0.1 24.0 28.4 23.0 \n", "2016-07-09 26.6 0.0 24.8 28.5 18.0 \n", "2016-07-10 26.8 0.0 24.9 28.6 19.0 \n", "\n", " windspeed_avg windspeed_gusts sun pressure_max pressure_min \\\n", "date \n", "2016-07-01 3.1 5.8 NaN NaN NaN \n", "2016-07-02 3.6 7.5 NaN NaN NaN \n", "2016-07-03 4.2 8.9 NaN NaN NaN \n", "2016-07-04 3.3 6.7 NaN NaN NaN \n", "2016-07-05 3.1 6.4 NaN NaN NaN \n", "2016-07-06 5.0 11.7 NaN NaN NaN \n", "2016-07-07 3.9 10.3 NaN NaN NaN \n", "2016-07-08 2.5 10.6 NaN NaN NaN \n", "2016-07-09 3.1 6.7 NaN NaN NaN \n", "2016-07-10 4.7 9.2 NaN NaN NaN \n", "\n", " week_start \n", "date \n", "2016-07-01 2016-07-01 \n", "2016-07-02 2016-07-01 \n", "2016-07-03 2016-07-01 \n", "2016-07-04 2016-07-01 \n", "2016-07-05 2016-07-01 \n", "2016-07-06 2016-07-01 \n", "2016-07-07 2016-07-01 \n", "2016-07-08 2016-07-08 \n", "2016-07-09 2016-07-08 \n", "2016-07-10 2016-07-08 " ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# LEAVE AS-IS\n", "\n", "# Create a map from dates to week starts\n", "date_to_week_start= {}\n", "week_num = 0\n", "for date, row in weather.iterrows():\n", " while not (date >= weeks[week_num] and date < weeks[week_num+1]):\n", " week_num += 1\n", " date_to_week_start[date] = weeks[week_num]\n", " \n", "# Create a new dataframe with an extra column\n", "weather_with_week_start = weather\n", "weather_with_week_start['week_start'] = [date_to_week_start[date] for date in weather.index]\n", "weather_with_week_start.head(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Third, we create a new dataframe with the average temperature (min, avg, max), and the total rainfall per floating week.\n", "\n", "You can solve this by creating a matrix and then converting into a dataframe.\n", "\n", "You can also use Panda's [groupby](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html) function together with the [aggregate](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.aggregate.html) function. There are many different ways of passing parameters to `aggregate`, check the one in which you pass a dictionary in which the keys are column names and the values are functions (in this case, you should use `np.mean` for `temp_*` and `np.sum` for `rainfall`).\n", "\n", " (Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code to generate the \"weather_per_floating_week\" dataframe" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# LEAVE AS-IS\n", "\n", "# Retrieve the past 5 years\n", "weather_sample = weather_per_floating_week.tail(5*52)\n", "\n", "# Plot temperature\n", "plot_min_avg_max(weather_sample, ylabel=\"Weekly average of temperature [C]\")\n", "\n", "# Plot precipitation\n", "plot(weather_sample, \"rainfall\", ylabel=\"Weekly precipitation [mm]\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary of what you observe on these plots." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.3. Smooth the series by binning per month" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we repeat the process for months instead of weeks. Now, however, we want to align with the **beginning of a calendar month**.\n", "\n", "Create the function `list_of_month_starts(first, last)`. It should return an array containing entries of the form *Year-Month-01*, that is the first of every month. It should start with the first of the month of the first observation, and end with the first of the month following the last observation.\n", "\n", "* Given date D, to obtain the first of the month use `D1 = D.replace(day=1)`\n", "* Given date D, to obtain the same date in the next month:\n", " * If *D.month < 12*, use `D2 = D.replace(month=D.month+1)`\n", " * If *D.month == 12*, use `D2 = D.replace(year=D.year+1, month=1)`\n", "\n", " (Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You should obtain **76** month starts. The first month should start on *2016-07-01* and the last month start on *2022-10-01*. Note that the last month may start after the end of the series. \n", "\n", " (Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 76 month starts\n", "First month starts 2016-07-01, last month starts 2022-10-01\n" ] } ], "source": [ "# LEAVE AS-IS\n", "\n", "first_day = np.min(weather.index)\n", "last_day = np.max(weather.index)\n", "months = list_of_month_starts(first_day, last_day)\n", "\n", "print(\"There are %d month starts\" % len(months))\n", "print(\"First month starts %s, last month starts %s\" % (months[0].strftime(\"%Y-%m-%d\"), months[-1].strftime(\"%Y-%m-%d\")))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As before, we create a dataframe with the month start.\n", "\n", " (Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
temp_avgrainfalltemp_mintemp_maxwindspeed_dirwindspeed_avgwindspeed_gustssunpressure_maxpressure_minweek_startmonth_start
date
2016-07-0124.10.021.926.399.03.15.8NaNNaNNaN2016-07-012016-07-01
2016-07-0224.60.022.327.013.03.67.5NaNNaNNaN2016-07-012016-07-01
2016-07-0323.40.021.924.920.04.28.9NaNNaNNaN2016-07-012016-07-01
2016-07-0423.80.021.825.925.03.36.7NaNNaNNaN2016-07-012016-07-01
2016-07-0525.30.023.227.435.03.16.4NaNNaNNaN2016-07-012016-07-01
.......................................
2022-09-2520.00.016.423.71.04.28.95.91013.31011.52022-09-232022-09-01
2022-09-2620.30.015.025.625.05.613.39.71012.71009.72022-09-232022-09-01
2022-09-2720.00.015.324.735.03.38.98.21011.51008.82022-09-232022-09-01
2022-09-2821.90.016.827.030.05.012.53.51010.81003.62022-09-232022-09-01
2022-09-2920.40.016.324.68.04.216.13.81005.01000.42022-09-232022-09-01
\n", "

2280 rows × 12 columns

\n", "
" ], "text/plain": [ " temp_avg rainfall temp_min temp_max windspeed_dir \\\n", "date \n", "2016-07-01 24.1 0.0 21.9 26.3 99.0 \n", "2016-07-02 24.6 0.0 22.3 27.0 13.0 \n", "2016-07-03 23.4 0.0 21.9 24.9 20.0 \n", "2016-07-04 23.8 0.0 21.8 25.9 25.0 \n", "2016-07-05 25.3 0.0 23.2 27.4 35.0 \n", "... ... ... ... ... ... \n", "2022-09-25 20.0 0.0 16.4 23.7 1.0 \n", "2022-09-26 20.3 0.0 15.0 25.6 25.0 \n", "2022-09-27 20.0 0.0 15.3 24.7 35.0 \n", "2022-09-28 21.9 0.0 16.8 27.0 30.0 \n", "2022-09-29 20.4 0.0 16.3 24.6 8.0 \n", "\n", " windspeed_avg windspeed_gusts sun pressure_max pressure_min \\\n", "date \n", "2016-07-01 3.1 5.8 NaN NaN NaN \n", "2016-07-02 3.6 7.5 NaN NaN NaN \n", "2016-07-03 4.2 8.9 NaN NaN NaN \n", "2016-07-04 3.3 6.7 NaN NaN NaN \n", "2016-07-05 3.1 6.4 NaN NaN NaN \n", "... ... ... ... ... ... \n", "2022-09-25 4.2 8.9 5.9 1013.3 1011.5 \n", "2022-09-26 5.6 13.3 9.7 1012.7 1009.7 \n", "2022-09-27 3.3 8.9 8.2 1011.5 1008.8 \n", "2022-09-28 5.0 12.5 3.5 1010.8 1003.6 \n", "2022-09-29 4.2 16.1 3.8 1005.0 1000.4 \n", "\n", " week_start month_start \n", "date \n", "2016-07-01 2016-07-01 2016-07-01 \n", "2016-07-02 2016-07-01 2016-07-01 \n", "2016-07-03 2016-07-01 2016-07-01 \n", "2016-07-04 2016-07-01 2016-07-01 \n", "2016-07-05 2016-07-01 2016-07-01 \n", "... ... ... \n", "2022-09-25 2022-09-23 2022-09-01 \n", "2022-09-26 2022-09-23 2022-09-01 \n", "2022-09-27 2022-09-23 2022-09-01 \n", "2022-09-28 2022-09-23 2022-09-01 \n", "2022-09-29 2022-09-23 2022-09-01 \n", "\n", "[2280 rows x 12 columns]" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# LEAVE AS-IS\n", "\n", "# Create a map from dates to week starts\n", "date_to_month_start= {}\n", "month_num = 0\n", "for date, row in weather.iterrows():\n", " while not (date >= months[month_num] and date < months[month_num+1]):\n", " month_num += 1\n", " date_to_month_start[date] = months[month_num]\n", " \n", "# Create a new dataframe with an extra column\n", "weather_with_month_start = weather\n", "weather_with_month_start['month_start'] = [date_to_month_start[date] for date in weather.index]\n", "weather_with_month_start" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As before, aggregate per month to create a dataframe with averages of `temp_min`, `temp_avg`, and `temp_max` per month, and sum of `rainfall`.\n", "\n", " (Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code to generate the \"weather_per_month\" dataframe" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# LEAVE AS-IS\n", "\n", "# Retrieve the last 7 years\n", "weather_sample = weather_per_month.tail(7*12)\n", "\n", "# Plot temperature\n", "plot_min_avg_max(weather_sample, ylabel=\"Monthly average temperature [mm]\")\n", "\n", "# Plot precipitation\n", "plot(weather_sample, \"rainfall\", ylabel=\"Monthly precitation [mm]\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary of what you observe on these plots." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 2. Perform forecasting" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will next perform a simple auto-regressive forecasting.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.1. Compute auto-correlation plots" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will start by computing auto-correlation plots, which show to what extent a series is correlated with itself if we consider a certain `lag`, or time difference.\n", "\n", "The function `lagged_series` returns the original series trimmed so it is the same length of the lagged series, and the lagged series computed by looking at *lag* periods in the past. \n", "\n", "You can use the following template:\n", "\n", "```python\n", "def lagged_series(series, lag):\n", " original_trimmed = []\n", " lagged = []\n", " for i in range(len(series)):\n", " j = i - lag\n", " # YOUR CODE HERE\n", " # You have to append series[i] to original and series[j] to lagged\n", " # but only if j is in [0, len(series)-1]\n", " return original_trimmed, lagged\n", "```\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code for \"lagged_series\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Test your function with the following code.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "assert ([44, 55, 66, 77, 88], [11, 22, 33, 44, 55]) == lagged_series([11,22,33,44,55,66,77,88], 3)\n", "\n", "assert ([33, 44, 55, 66, 77, 88], [11, 22, 33, 44, 55, 66]) == lagged_series([11,22,33,44,55,66,77,88], 2)\n", "\n", "assert ([22, 33, 44, 55, 66, 77, 88], [11, 22, 33, 44, 55, 66, 77]) == lagged_series([11,22,33,44,55,66,77,88], 1)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The function `autocorrelation`, which you can leave as-is, simply computes Pearson's correlation between a series and the series lagged *lag* periods.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "# Computes the correlation between two vectors, considering\n", "# only the positions in which both vectors are not NaN\n", "def correlation_without_nan(x,y):\n", " positions_to_remove = ~np.logical_or(np.isnan(x), np.isnan(y))\n", "\n", " x_without_nan = np.compress(positions_to_remove, x)\n", " y_without_nan = np.compress(positions_to_remove, y)\n", " return stats.pearsonr(x_without_nan,y_without_nan)[0] \n", "\n", "# Compute autocorrelation\n", "def autocorrelation(series, lag):\n", " x,y = lagged_series(series, lag)\n", " \n", " return correlation_without_nan(x,y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we will create auto-correlation plots. Create a function `compute_autocorrelations(series, max_periods)` that returns all the auto-correlations of a series from period `0` to `max_periods-1`.\n", "\n", "Use this function to create an array `auto_correlation_temp` containing the correlations of `weather['temp_avg']`, `auto_correlation_temp_max` containing the correlations of `weather['temp_max']`, and an array `auto_correlation_rainfall` containing the correlations of `weather['rainfall']`.\n", "\n", "Use `max_periods=2*365`.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code to compute \"auto_correlations_temp\" and \"auto_correlations_rainfall\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we plot these.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "def plot_auto_correlations(correlations, xlabel=\"Lag (days)\", ylabel=\"Autocorrelation\"):\n", " # Figure\n", " plt.figure(figsize=(15,4))\n", "\n", " # Plot correlation\n", " plt.plot(range(len(correlations)), correlations, '-o')\n", "\n", " # Add xticks every 10 periods\n", " plt.xticks(np.arange(0, len(correlations), 10), rotation=90)\n", "\n", " # Add a horizontal line at zero\n", " plt.hlines(0, xmin=0, xmax=len(correlations))\n", "\n", " # Add labels\n", " plt.xlabel(xlabel)\n", " plt.ylabel(ylabel)\n", "\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# LEAVE AS-IS\n", "\n", "# Plot max temperature auto-correlation\n", "plot_auto_correlations(auto_correlations_temp_max, ylabel=\"Autocorrelation (temperature max)\")\n", "\n", "# Plot avg temperature auto-correlation\n", "plot_auto_correlations(auto_correlations_temp, ylabel=\"Autocorrelation (temperature avg)\")\n", "\n", "# Plot precipitation auto-correlation\n", "plot_auto_correlations(auto_correlations_rainfall, ylabel=\"Autocorrelation (precipitation)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary on what you see on these plots. Do you think these correlations reflect something real about the underlying data, or are spurious?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It might be the case that aggregating by week we obtain a stronger auto-correlation of the precipitation time series. Let us try it.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 114, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# LEAVE AS-IS\n", "\n", "auto_correlations_rainfall_week = compute_autocorrelations(weather_per_floating_week['rainfall'], 200)\n", "\n", "plot_auto_correlations(auto_correlations_rainfall_week, xlabel='Lag (weeks)', ylabel=\"Autocorrelation (precipitation)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary on what you see on this plot. Do you think the correlations you observe in the weekly time series of precipitation (aside from the one at lag=1) come from a real dependency, or are spurious?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.2. Prepare a system of equations to learn an auto-regressive model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will now learn an auto-regressive model, which computes the current value from a series of values in the past, at different *lags*.\n", "\n", "**Example:** In the explanation we will assume there are two lags (2, 3) only. This means that the value will be predicted on the basis of the value observed 2 and 3 periods ago. The equation is then *y[i] = y[i-2] x alpha + y[i-3] x beta*, with *alpha* and *beta* being two unknown coefficients that we must determine. Suppose the series is: [11, 19, 32, 38, 51, 58, 68, 81]. From this series, we create the following system of equations.\n", "\n", "* 19 x alpha + 11 x beta = 38\n", "* 32 x alpha + 19 x beta = 51\n", "* ...\n", "* 58 x alpha + 51 x beta = 81\n", "\n", "Unless the data is generated by a very specific process, we will seldom satisfy this system of equations, but we can approximately satisfy it. We will use SciKit's [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) to obtain *alpha* and *beta*. To use this function, we need to prepare to matrices: *X*, which will contain the numbers in the left side of the equations, and *y* which will be a vector containing the numbers in the right side of the equations.\n", "\n", "Create a function `prepare_matrices`. You can use the following template:\n", "\n", "```python\n", "def prepare_matrices(series, lags):\n", " y = []\n", " X = []\n", " \n", " for lag in lags:\n", " assert(lag > 0)\n", " assert(lag < len(series))\n", " \n", " for i in range(np.max(lags), len(series)):\n", " # YOUR CODE HERE\n", " \n", " X.append(row)\n", " y.append(series[i])\n", " \n", " return X, y\n", "```\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your code for \"prepare_matrices\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Test your code. Given the series `[11, 19, 32, 38, 51, 58, 69, 81]` and lags `[2, 3]`, you should obtain:\n", "\n", "```\n", "X=[[19, 11], [32, 19], [38, 32], [51, 38], [58, 51]]\n", "y=[38, 51, 58, 69, 81]\n", "```\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X=[[19, 11], [32, 19], [38, 32], [51, 38], [58, 51]]\n", "y=[38, 51, 58, 69, 81]\n" ] } ], "source": [ "# LEAVE AS-IS\n", "\n", "X, y = prepare_matrices([11, 19, 32, 38, 51, 58, 69, 81], [2, 3])\n", "print(\"X=%s\" % X)\n", "print(\"y=%s\" % y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that your code must handle well missing values. If any of the equations contains a NaN in the left or right side, you should discard it. In other words, X cannot contains vectors that have NaN values, and y cannot contain NaN values.\n", "\n", "For instance, given the series `[11, 19, 32, np.nan, 51, 58, 69, 81]` and lags `[2, 3]`, you should obtain:\n", "\n", "```\n", "X=[[32, 19], [58, 51]]\n", "y=[51, 81]\n", "```\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X=[[32, 19], [58, 51]]\n", "y=[51, 81]\n" ] } ], "source": [ "# LEAVE AS-IS\n", "\n", "X, y = prepare_matrices([11, 19, 32, np.nan, 51, 58, 69, 81], [2, 3])\n", "print(\"X=%s\" % X)\n", "print(\"y=%s\" % y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.3. Perform forecasts" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We first define a couple of functions to perform and plot the forecast, which you can leave as-is.\n", "\n", "Function `perform_forecast` simply uses your `prepare_matrices` function to prepare a system of equations, and then calls [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) in SciKit-Learn to try to find a solution.\n", "\n", "We measured the error as RMSE (Root Mean Squared Error) divided by the difference between the maximum and minimum value we want to predict. See [NRMSD](https://en.wikipedia.org/wiki/Root-mean-square_deviation#Normalized_root-mean-square_deviation).\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "def perform_forecast(series, lags):\n", "\n", " # Prepare matrices for linear regression\n", " X, y = prepare_matrices(series, lags)\n", "\n", " # Perform forecast\n", " linear_regressor = LinearRegression()\n", " linear_regressor.fit(X,y)\n", " y_pred = linear_regressor.predict(X)\n", "\n", " # Compute forecasting error\n", " # Root mean squared error, normalized\n", " rmse = math.sqrt(mean_squared_error(y, y_pred))/(np.max(y)-np.min(y))\n", " \n", " # Return: observed, predicted, error\n", " return (y, y_pred, rmse)\n", "\n", "def plot_forecast(y, y_pred, xlabel=\"Period\", ylabel=\"\", nrmsd=-1):\n", "\n", " plt.figure(figsize=(15,4))\n", " \n", " plt.plot(y, '.-', linewidth=4, color='gray', label='Observed')\n", " plt.plot(y_pred, '--', linewidth=2, color='magenta', label=('Model (NRMSD=%.2f)' % nrmsd if nrmsd > 0 else 'Model'))\n", " \n", " plt.xlabel(xlabel)\n", " plt.ylabel(ylabel)\n", "\n", " plt.legend()\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, predict the monthly temperature. Set `lags_monthly_temperature = [...]` to be an array of up to 4 lags. Use the auto-correlation plots you draw before as a guideline.\n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with your choice for \"lags_monthly_temperature\"" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# LEAVE AS-IS\n", "\n", "(y, y_pred, nrmsd) = perform_forecast(weather_per_month['temp_avg'], lags_monthly_temperature)\n", "plot_forecast(y, y_pred, xlabel=\"Period [months]\", ylabel=\"Monthly temperature [C]\", nrmsd=nrmsd)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with code and plots predicting: (1) weekly temperature, (2) daily temperature. Always use up to 4 lags, and try to find the lags leading to the smaller error." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary on what you observe when predicting temperature." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with code and plots predicting: (1) monthly rainfall, (2) weekly rainfall, (3) daily rainfall. Always use up to 4 lags, and try to find the lags leading to the smaller error." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Replace this cell with a brief commentary on what you observe when trying to predict rainfall." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# DELIVER (individually)\n", "\n", "Remember to read the section on \"delivering your code\" in the [course evaluation guidelines](https://github.com/chatox/data-mining-course/blob/master/upf/upf-evaluation.md).\n", "\n", "Deliver a zip file containing:\n", "\n", "* This notebook\n", "\n", "## Extra points available\n", "\n", "For more learning and extra points, create a model for temperature that uses cross-correlations. This means, you can use the variables *temp_min*, *temp_avg*, *temp_max*, *rainfall*, *windspeed_avg*, and *windspeed_gusts* up to the previous day to predict *temp_avg* on the current day. You only need to be careful not to include any `lag=0` measure, otherwise you would not be predicting the future. Include plots and a brief commentary indicating whether you obtained any improvements.\n", "\n", "**Note:** if you go for the extra points, add ``Additional results: cross correlations`` at the top of your notebook. \n", "\n", "(Remove this cell when delivering.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I hereby declare that, except for the code provided by the course instructors, all of my code, report, and figures were produced by myself." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.0" } }, "nbformat": 4, "nbformat_minor": 2 }