From 35aa4d653eb9aa8b33ba47bc3c84c8aff6891dff Mon Sep 17 00:00:00 2001 From: Ryan Johnson <33735397+whitelightning450@users.noreply.github.com> Date: Thu, 20 May 2021 14:17:16 -0600 Subject: [PATCH] Add files via upload --- ASCE_CSD_WDM.ipynb | 2499 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2499 insertions(+) create mode 100644 ASCE_CSD_WDM.ipynb diff --git a/ASCE_CSD_WDM.ipynb b/ASCE_CSD_WDM.ipynb new file mode 100644 index 0000000..ed78398 --- /dev/null +++ b/ASCE_CSD_WDM.ipynb @@ -0,0 +1,2499 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn import linear_model\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.metrics import mean_absolute_error\n", + "from sklearn. metrics import accuracy_score\n", + "from sklearn import metrics\n", + "from sklearn.metrics import r2_score\n", + "from sklearn.metrics import classification_report\n", + "from sklearn.metrics import mean_absolute_percentage_error\n", + "from sklearn import metrics\n", + "from sklearn.metrics import mean_squared_error\n", + "from sklearn.utils import resample\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.model_selection import LeaveOneOut\n", + "from sklearn import preprocessing\n", + "import matplotlib.dates as mdates\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "from sklearn.pipeline import make_pipeline\n", + "import seaborn as sns; sns.set()\n", + "import joblib\n", + "from sklearn.linear_model import LassoCV\n", + "from sklearn.datasets import make_regression\n", + "from pathlib import Path\n", + "import copy\n", + "\n", + "#Trying out recusive feature elimination to compare with step wise regression\n", + "from sklearn.feature_selection import RFE\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.model_selection import KFold\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.pipeline import make_pipeline\n", + "import sklearn\n", + "\n", + "from progressbar import ProgressBar\n", + "\n", + "\n", + "\n", + "import datetime\n", + "import calendar\n", + "\n", + "\n", + "%matplotlib inline\n", + "\n", + "#custom functions\n", + "def NSC(y_pred,y_true):\n", + " \"\"\"\n", + " Nash-Sutcliffe Coefficient\n", + " \"\"\"\n", + " return 1 - sum((y_pred-y_true)**2)/sum((y_true-np.mean(y_true))**2)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "#This is the final dataset to make predictions on\n", + "p = Path('C:/Users/Ryan/Box/Dissertation/Paper1/Data/Processed_Training_Data')\n", + "#dir_data = 'C:/Users/Ryan/Box/Dissertation/Paper1/Data/Model_Input_Data/Monthly/Input/FinalVars'\n", + "\n", + "slc = {i.stem[0:3] : pd.read_excel(i) for i in p.glob('**/*.xlsx')}\n", + "\n", + "#rename the gpcd column\n", + "for i in slc:\n", + " slc[i].rename(columns={i+'_gpcd': 'Obs_gpcd'}, inplace=True)\n", + " slc[i]=slc[i].set_index('Year')\n", + "snow=pd.read_excel('C:/Users/Ryan/Box/Dissertation/Paper1/Data/Alta_LCC_snow.xlsx')\n", + "snow=snow.set_index('Year')\n", + "#need to remove certain features\n", + "'''\n", + "lots of colinearity between mountain and valley, since we are focused on the valley we will use valley conditions.\n", + "meantemp and maxtemps days > are good predictors, however, they will be difficult to predict into the future.\n", + "Mill creek and city creek show high colinarity. Since city creek is a source we will remove mill creek.\n", + "Removing red butte and emigration creeks as they are not supply streams and show co-linearity\n", + "!!! removing the aggregated Seven canyons streamflow. There appears to be a unique climate signial that very well helps\n", + "demand forecasting by including the supply streamflows!!!!\n", + "Precipitation days is removed as they will be difficult to predict with certainity in the future.\n", + "Days above max, mean is removed as its colinear with mean temp and is difficult to predict into future.\n", + "Percent are selected, sqmi is basicaly the same\n", + "Removed reshousingdensity at it is highly coorelated wiht respopulationdensity\n", + "removed Urban_Area_Perc as it has high colinearity with res pop dens\n", + "Residential_Area_Perc removed as colinear wiht res pop dens)\n", + "'''\n", + "colrem= ['Dem_AF', 'seven', 'meantemp_days', 'maxtemp_days', 'mean_max', 'mill', 'precip_days', \n", + " 'Days_abovemax','Days_abovemean', 'red' , 'emig', 'sqmi','max_Days_WO',\n", + " 'mtn','ResHouseDensity', 'Urban_Area_Perc','Residential_Area_Perc', 'IrrPopulationDensity',\n", + " 'Irrigated_Area_Perc','CityCrk_AcFt_WR_Mar', 'LitCotCrk_AcFt_WR_Jun']#, 'AcFt', 'WO', 'days', 'days', 'above' , 'Perc']\n", + "\n", + "\n", + "for i in slc:\n", + " for j in colrem:\n", + " slc[i]=slc[i].loc[:,~slc[i].columns.str.contains(j , case=False)] \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Create training and testing data, use most recent low, average, and high water years\n", + "slc_train=copy.deepcopy(slc)\n", + "slc_test=copy.deepcopy(slc)\n", + "\n", + "#2008 is a high year\n", + "#2011 and 2017 are average years\n", + "#2014 and 2016 are below average years\n", + "#2015 is a very low year\n", + "\n", + "IN_WY_Months = ['Jan' , 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug','Sep', 'Oct']\n", + "Prior_YR_WY_Months = ['Nov', 'Dec']\n", + "testWYyrs = [2008,2015,2017]\n", + "#testPrioWYyrs = [2007,2014,2016]\n", + "\n", + "\n", + "for i in slc:\n", + " #Select the training/testing dataframes\n", + " slc_train[i]=slc_train[i][~slc_train[i].index.isin(testWYyrs)]\n", + " slc_test[i]=slc_test[i][slc_test[i].index.isin(testWYyrs)]\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + " \n", + "\n", + "#Determine the indoor mean to subtract from outdoor\n", + "I_mean_train=(slc_train['Jan']['Obs_gpcd']+\n", + " slc_train['Feb']['Obs_gpcd']+\n", + " slc_train['Mar']['Obs_gpcd']+\n", + " slc_train['Nov']['Obs_gpcd']+\n", + " slc_train['Dec']['Obs_gpcd'])/5\n", + "I_mean_test=(slc_test['Jan']['Obs_gpcd']+\n", + " slc_test['Feb']['Obs_gpcd']+\n", + " slc_test['Mar']['Obs_gpcd']+\n", + " slc_test['Nov']['Obs_gpcd']+\n", + " slc_test['Dec']['Obs_gpcd'])/5\n", + "#This uses total demand for irrigation seasons\n", + "#I_mean_train=np.zeros(23)\n", + "#I_mean_test=np.zeros(10)\n", + "\n", + "for i in slc_train:\n", + " slc_train[i]['Iave']=I_mean_train\n", + " #for now include testing years\n", + " slc_test[i]['Iave']=I_mean_test\n", + "\n", + "IrrSeason= ['Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct']\n", + "Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec']\n", + "colrem=['Iave', 'Obs_gpcd']\n", + "#set the target gpcd to indoor for indoor and total-indoor for outdoor\n", + "#change to indoor to separate outdoor demands from total\n", + "for i in Indoor:\n", + " slc_train[i]['Target_gpcd']=slc_train[i]['Obs_gpcd']\n", + " slc_train[i]= slc_train[i].drop(columns=colrem)\n", + " #for now include testing years\n", + " slc_test[i]['Target_gpcd']=slc_test[i]['Obs_gpcd']\n", + " slc_test[i]= slc_test[i].drop(columns=colrem)\n", + " \n", + "\n", + "#Establish outdoor conservation thresholds\n", + "O_cons = 0.25\n", + "time = 20\n", + "\n", + "\n", + "for i in IrrSeason:\n", + " slc_train[i]['Target_gpcd']=slc_train[i]['Obs_gpcd']-slc_train[i]['Iave']\n", + " slc_train[i].loc[slc_train[i]['Target_gpcd'] < 0, 'Target_gpcd'] = 0\n", + " \n", + " #add in snow info\n", + " slc_train[i]=pd.concat([slc_train[i], snow], axis=1, join=\"inner\")\n", + " \n", + " slc_train[i]= slc_train[i].drop(columns=colrem)\n", + " #for now include testing years\n", + " slc_test[i]=pd.concat([slc_test[i], snow], axis=1, join=\"inner\")\n", + " slc_test[i]['Target_gpcd']=slc_test[i]['Obs_gpcd']-slc_test[i]['Iave']\n", + " slc_test[i].loc[slc_test[i]['Target_gpcd'] < 0, 'Target_gpcd'] = 0\n", + " \n", + " #create monthly historical mean and conservation trends\n", + " Out_mean = np.mean(slc_train[i]['Target_gpcd'].loc[2000:])\n", + " goal = (1-O_cons)*Out_mean\n", + " O_cons_rate = (Out_mean -goal)/time\n", + " \n", + "\n", + "\n", + " slc_train[i]['cons_goal'] = Out_mean- ((slc_train[i].index-2000)*O_cons_rate)\n", + " slc_train[i].loc[ slc_train[i].index <2000, ['cons_goal']] = Out_mean\n", + " \n", + " t=slc_train[i]['Target_gpcd'].copy()\n", + " c=slc_train[i]['cons_goal'].copy()\n", + " slc_train[i] = slc_train[i].drop(columns=['Target_gpcd', 'cons_goal'])\n", + " slc_train[i]['Target_gpcd'] = t\n", + " slc_train[i]['cons_goal'] = c\n", + " \n", + " slc_test[i]['cons_goal'] = Out_mean - ((slc_test[i].index-2000)*O_cons_rate) \n", + " \n", + " \n", + " \n", + " \n", + " slc_test[i]= slc_test[i].drop(columns=colrem)\n", + "\n", + " \n", + "#Determine the historical indoor mean to apply conservation strategies too\n", + "Indmean = np.mean(slc_train['Jan']['Target_gpcd'].loc[2000:]+\n", + " slc_train['Feb']['Target_gpcd'].loc[2000:]+\n", + " slc_train['Mar']['Target_gpcd'].loc[2000:]+\n", + " slc_train['Nov']['Target_gpcd'].loc[2000:]+\n", + " slc_train['Dec']['Target_gpcd'].loc[2000:])/5\n", + "'''Per UDWR 2001, Utah's Water Resources: Planning for the future, the govenor ordered a\n", + "25% reduction in water use by 2025\n", + "'''\n", + "cons = 0.28\n", + "\n", + "goal = (1-cons)*Indmean\n", + "\n", + "time = 20\n", + "\n", + "cons_rate = (Indmean -goal)/time\n", + "\n", + "#print(cons_rate , goal)\n", + "\n", + "#create feature called cons_goal!\n", + "for i in Indoor:\n", + " slc_test[i]['cons_goal'] = Indmean-((slc_test[i].index-2000)*cons_rate) \n", + " slc_train[i]['cons_goal'] = Indmean-((slc_train[i].index-2000)*cons_rate) \n", + " \n", + " slc_train[i].loc[ slc_train[i].index <2000, ['cons_goal']] = Indmean\n", + " \n", + " \n", + "Cons_mean_test=(slc_test['Jan']['cons_goal']+\n", + " slc_test['Feb']['cons_goal']+\n", + " slc_test['Mar']['cons_goal']+\n", + " slc_test['Nov']['cons_goal']+\n", + " slc_test['Dec']['cons_goal'])/5\n", + "\n", + "#split training and testing data into features and targets\n", + "slc_train_target=copy.deepcopy(slc_train)\n", + "slc_train_features=copy.deepcopy(slc_train)\n", + "\n", + "slc_test_target=copy.deepcopy(slc_test)\n", + "slc_test_features=copy.deepcopy(slc_test)\n", + "\n", + "\n", + "target=['Target_gpcd','Housing']\n", + "for i in slc_train_target:\n", + " slc_train_target[i]=slc_train_target[i]['Target_gpcd']\n", + " #for now include testing years\n", + " slc_test_target[i]=slc_test_target[i]['Target_gpcd']\n", + "\n", + "\n", + " slc_train_features[i]= slc_train_features[i].drop(columns=target)\n", + " #for now include testing years\n", + " slc_test_features[i]= slc_test_features[i].drop(columns=target)\n", + " \n", + "#need to remove year from the list to run plots below\n", + "for i in slc_train:\n", + " slc_train[i]=slc_train[i].drop(columns=['Housing', 'Population', 'PopulationDensity'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "We want to see the trends for the training data,# and will want to have them modeled into the future based\n", + "on consevation goals\n", + "\n", + "From plots, There appears to be very little trends in training data. The last 10 years do show decreasing trends\n", + "likely due to conservation goals estabished in 2005\n", + "\n", + "\n", + "Thinking of a stepwise process:\n", + "1) identify any trends (training and testing): check, no trends in training. however in 2000, Utah established a \n", + " conservation goal. To reduce the gpcd water use by 25% by 2025. Evaluating water use from 2005-2017 shows a decline\n", + " in water use.\n", + "2) Determine conservation goals (annual reduction /yr, slope), over 25yrs a 75 gpcd reduction is requested (3gpcd/yr), check\n", + "3) Separately model indoor and outdoor demands per year. check \n", + "4) Training Outdoor demand (Apr-Oct) will be that month's total demand minus that years Jan-Mar mean indoor demand\n", + "5) Final model = modeled indoor demand - conservation reduction + Outdoor demand (if Apr-Oct).\n", + "'''\n", + "\n", + "def Outdoor_Demand_Model(TrainDF, month, X_train_features, y_train_target, X_test_features, y_test_target,\n", + " snowfeatures, conservation, cor_threshold, colinearity_thresh, cv_splits,\n", + " model_type, scoring ):\n", + " \n", + "\n", + "#subset these features out of main DF and put into cute heatmap plot\n", + " \n", + " DFcor = copy.deepcopy(TrainDF[month])\n", + " \n", + " #if snowfeatures is True:\n", + " # print('LCC Snowfeatures are being used')\n", + " Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec']\n", + " if snowfeatures is False:\n", + " if month in Indoor:\n", + " DFcor=DFcor\n", + " else:\n", + " snow=['Nov_snow_in','Dec_snow_in', 'Jan_snow_in','Feb_snow_in', \n", + " 'Mar_snow_in','Apr_snow_in', 'Total_snow_in', 'Snow_shortage']\n", + " DFcor=DFcor.drop(columns=snow)\n", + "\n", + " \n", + " cor=DFcor.copy()\n", + " if conservation is False:\n", + " del cor['cons_goal']\n", + " cor = cor.corr()\n", + " cor =cor.iloc[:,-1:]\n", + " if conservation is True:\n", + " cor = cor.corr()\n", + " cor =cor.iloc[:,-2:]\n", + " del cor['cons_goal']\n", + " \n", + " cor['Target_gpcd']=np.abs(cor['Target_gpcd'])\n", + " cor=cor.sort_values(by=['Target_gpcd'], ascending=False)\n", + " cor=cor.dropna()\n", + "\n", + "#Selecting highly correlated features\n", + " relevant_features = cor[cor['Target_gpcd']>cor_threshold]\n", + " CorFeat = list(relevant_features.index)\n", + "\n", + " CorDF= DFcor[CorFeat]\n", + " cor = np.abs(CorDF.corr())\n", + " cor = cor.mask(np.tril(np.ones(cor.shape)).astype(np.bool))\n", + " #remove colinearity\n", + " cor = cor[cor.columns[cor.max() < colinearity_thresh]]\n", + " CorFeat=cor.columns\n", + " cor = cor.T\n", + " cor = cor[CorFeat]\n", + " \n", + " #print('Remaining features are', CorFeat)\n", + "\n", + " \n", + " #Set up training and testing data \n", + " X_train = X_train_features[month][CorFeat].copy()\n", + "#X_train = slc_train_features['Jul'][JulF]\n", + " y_train = y_train_target[month].copy()\n", + "\n", + " X_test = X_test_features[month][CorFeat].copy()\n", + "#X_test = slc_test_features['Jul'][JulF]\n", + " y_test = y_test_target[month].copy()\n", + "\n", + " # step-1: create a cross-validation scheme\n", + " folds = KFold(n_splits = cv_splits, shuffle = True, random_state = 42)\n", + "\n", + "# step-2: specify range of hyperparameters to tune\n", + " if len(CorFeat) > 1 :\n", + " hyper_params = [{'n_features_to_select': list(range(1, len(CorFeat)))}]\n", + " \n", + "\n", + "# step-3: perform grid search\n", + "# 3.1 specify model, key to set intercept to false\n", + " trainmodel = model_type\n", + " trainmodel.fit(X_train, y_train)\n", + " rfe = RFE(trainmodel) \n", + "\n", + "# 3.2 call GridSearchCV()\n", + " model_cv = GridSearchCV(estimator = rfe, \n", + " param_grid = hyper_params, \n", + " scoring= scoring, \n", + " cv = folds, \n", + " verbose = 0,\n", + " return_train_score=True) \n", + "\n", + "# fit the model\n", + " model_cv.fit(X_train, y_train)\n", + "\n", + "# create a KFold object with 5 splits \n", + " folds = KFold(n_splits = cv_splits, shuffle = True, random_state = 42)\n", + " scores = cross_val_score(trainmodel, X_train, y_train, scoring=scoring, cv=folds)\n", + " # print('CV scores = ', scores) \n", + "\n", + "# cv results\n", + " cv_results = pd.DataFrame(model_cv.cv_results_)\n", + "\n", + " \n", + " #code to select features for final model, tell how many features\n", + " N_feat=cv_results.loc[cv_results['mean_test_score'].idxmax()]\n", + " N_feat=N_feat['param_n_features_to_select']\n", + " #print('Number of features to select is ', N_feat)\n", + " # intermediate model\n", + " n_features_optimal = N_feat\n", + "\n", + " Int_model = model_type\n", + " Int_model.fit(X_train, y_train)\n", + "\n", + " rfe = RFE(Int_model, n_features_to_select=n_features_optimal) \n", + " rfe = rfe.fit(X_train, y_train)\n", + "\n", + "#make the final model with rfe features\n", + "\n", + "# tuples of (feature name, whether selected, ranking)\n", + "# note that the 'rank' is > 1 for non-selected features\n", + "\n", + " Features =list(zip(X_train.columns,rfe.support_,rfe.ranking_))\n", + " FeaturesDF=pd.DataFrame(Features, columns=['Feature', 'Important', 'Score'])\n", + " FeaturesDF = FeaturesDF[FeaturesDF.Score<=1]\n", + " RFE_features = list(FeaturesDF['Feature'])\n", + " # print('The final features are ', RFE_features)\n", + " \n", + " #select only RFE features for model training/validation\n", + " X_train = X_train[RFE_features]\n", + " X_test = X_test[RFE_features]\n", + "\n", + " \n", + " #plot of selected features to make sure not colinear\n", + " CorDF= X_train.copy()\n", + " CorDF['Target_gpcd']=slc_train[month]['Target_gpcd']\n", + "\n", + " Final_model = model_type\n", + " Final_model.fit(X_train, y_train)\n", + " \n", + " \n", + " \n", + " else:\n", + " \n", + " #Set up training and testing data to have a random non-correlated feature then\n", + " X_train = X_train_features[month]['HousingDensity'].copy()\n", + " X_test = X_test_features[month]['HousingDensity'].copy()\n", + " cv_results = 0\n", + " cor = 0\n", + " \n", + " len1 = len(X_train)\n", + " len2 = len(X_test)\n", + " \n", + " X_train = np.array(X_train).reshape(len1, 1)\n", + " X_test = np.array(X_test).reshape(len2, 1)\n", + " \n", + " Final_model = model_type\n", + " Final_model.fit(X_train, y_train)\n", + " \n", + " # Get training data model performance to tune hyperparameters\n", + " yt_pred = Final_model.predict(X_train)\n", + " \n", + " yt_pred = [0 if x < 0 else x for x in yt_pred]\n", + " O_r2_train = sklearn.metrics.r2_score(y_train, yt_pred)\n", + " O_rmse_train = sklearn.metrics.mean_squared_error(y_train, yt_pred, squared = False)\n", + " \n", + "# predict X_test\n", + " y_pred = Final_model.predict(X_test)\n", + " \n", + " y_pred = [0 if x < 0 else x for x in y_pred]\n", + " O_r2_test = sklearn.metrics.r2_score(y_test, y_pred)\n", + " O_rmse_test = sklearn.metrics.mean_squared_error(y_test, y_pred, squared = False)\n", + " \n", + " \n", + "\n", + "#plot the predictions\n", + " PerfDF=pd.DataFrame(list(zip(y_pred, y_test)), columns=['y_pred', 'y_test'])\n", + "\n", + "#Add indoor demands\n", + " Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec']\n", + " if month in Indoor:\n", + " PerfDF['y_test_tot']=PerfDF['y_test']\n", + " PerfDF['y_pred_tot']=PerfDF['y_pred']\n", + " else:\n", + " PerfDF['y_test_tot']=PerfDF['y_test']+list(I_mean_test)\n", + " PerfDF['y_pred_tot']=PerfDF['y_pred']+list(Cons_mean_test)\n", + "\n", + " T_r2 = sklearn.metrics.r2_score(PerfDF['y_test_tot'], PerfDF['y_pred_tot'])\n", + " T_rmse= sklearn.metrics.mean_squared_error(PerfDF['y_test_tot'], PerfDF['y_pred_tot'], \n", + " squared = False)\n", + "\n", + " #print('Total R2 is ', T_r2)\n", + " #print('Total rmse is ', T_rmse)\n", + " \n", + "\n", + " PerfDF['Year'] = list(slc_test['Jul'].index)\n", + " PerfDF=PerfDF.set_index('Year')\n", + " \n", + "\n", + " datetime_object = datetime.datetime.strptime(month, \"%b\")\n", + " PerfDF['month'] = datetime_object.month\n", + " PerfDF['Year']=PerfDF.index\n", + " \n", + " \n", + " #set up dates so all months can be combined and sorted\n", + " day=[]\n", + " for index, row in PerfDF.iterrows():\n", + " day.append(calendar.monthrange(int(row['Year']), int(row['month']))[1])\n", + " \n", + " PerfDF['Day']=day\n", + " \n", + " PerfDF['Date'] = pd.to_datetime(PerfDF[['Year', 'month', 'Day']])\n", + " \n", + " #PerfDF=PerfDF.set_index('Date')\n", + " PerfDF=PerfDF.drop(columns=['Year', 'month', 'Day'])\n", + " PerfDF=PerfDF.reset_index()\n", + " \n", + " params = [snowfeatures, conservation, cor_threshold, colinearity_thresh]\n", + " \n", + " return X_test, PerfDF, O_rmse_train, O_r2_train ,O_rmse_test, O_r2_test , params, cv_results, cor , Final_model.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def Indoor_Demand_Model(df, month):\n", + " #Make matching indoor demand model\n", + " datetime_object = datetime.datetime.strptime(month, \"%b\")\n", + " df[month]['month'] = datetime_object.month\n", + " \n", + " df[month]['Year']=df[month].index\n", + " \n", + " #set up dates so all months can be combined and sorted\n", + " day=[]\n", + " for index, row in df[month].iterrows():\n", + " day.append(calendar.monthrange(int(row['Year']), int(row['month']))[1])\n", + " \n", + " df[month]['Day']=day\n", + " \n", + " \n", + " df[month]['Date'] = pd.to_datetime(df[month][['Year', 'month', 'Day']])\n", + " \n", + " #PerfDF=PerfDF.set_index('Date')\n", + " df[month]=df[month].drop(columns=['month', 'Day'])\n", + " df[month]=df[month].reset_index(drop=True)\n", + " \n", + " \n", + " colrem = slc_test[i].columns\n", + " df[month]['y_pred'] = df[month]['cons_goal']\n", + " df[month]['y_test'] = df[month]['Target_gpcd']\n", + " df[month]['y_pred_tot'] = df[month]['cons_goal']\n", + " df[month]['y_test_tot'] = df[month]['Target_gpcd']\n", + " \n", + " df[month] = df[month].set_index('Date')\n", + " \n", + " df[month] = df[month].drop(columns=colrem)\n", + " \n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "plt.rcParams[\"axes.grid\"] = False\n", + "plt.rcParams[\"axes.facecolor\"] ='white'\n", + "#plt.rcParams[\"axes.edgecolor\"]['bottom'] = 'black'\n", + "\n", + "def gradientbars_sliced(bars):\n", + " ax = bars[0].axes\n", + " xmin, xmax = ax.get_xlim()\n", + " ymin, ymax = ax.get_ylim()\n", + " for bar in bars:\n", + " bar.set_zorder(1)\n", + " bar.set_facecolor(\"none\")\n", + " x, y = bar.get_xy()\n", + " w, h = bar.get_width(), bar.get_height()\n", + " grad = np.linspace(y, y + h, 256).reshape(256, 1)\n", + " ax.imshow(grad, extent=[x, x + w, y, y + h], aspect=\"auto\", zorder=0, origin='lower',\n", + " vmin= - max(np.abs(ymin), ymax), vmax=max(np.abs(ymin), ymax), cmap='Spectral')\n", + " ax.axis([xmin, xmax, ymin, ymax])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def model_plots(PerfDF, cv_results,cor, X_test_RFE, coef, scoring, month):\n", + " \n", + " plotmin = PerfDF[['y_pred', 'y_test']].min().min()\n", + " plotmax = PerfDF[['y_pred', 'y_test']].max().max()\n", + " \n", + " plotmin_tot = PerfDF[['y_pred_tot', 'y_test_tot']].min().min()\n", + " plotmax_tot = PerfDF[['y_pred_tot', 'y_test_tot']].max().max()\n", + " \n", + " # plotting cv results\n", + " plt.figure(figsize=(12,10))\n", + " sns.heatmap(cor, annot=True, cmap=plt.cm.Reds)\n", + " plt.savefig('C:/Users/Ryan/Box/Dissertation/Paper1/Figs/' + month + '_corMatrix.pdf')\n", + " plt.show()\n", + " \n", + " fig, ax = plt.subplots(3,3, constrained_layout=True)\n", + " fig.set_size_inches(9,10)\n", + "\n", + "\n", + " ax[0,0].plot(cv_results[\"param_n_features_to_select\"], cv_results[\"mean_test_score\"])\n", + " ax[0,0].plot(cv_results[\"param_n_features_to_select\"], cv_results[\"mean_train_score\"])\n", + " ax[0,0].set_xlabel('number of features')\n", + " ax[0,0].set_ylabel(scoring)\n", + " ax[0,0].set_title(\"Optimal Number of Features\")\n", + " ax[0,0].legend(['test score', 'train score'], loc='upper left')\n", + " ax[0,0].spines['bottom'].set_color('black')\n", + " ax[0,0].spines['left'].set_color('black')\n", + "\n", + " ax[0,1].scatter(PerfDF['y_test'], PerfDF['y_pred'],color='blue', alpha=0.5)\n", + " ax[0,1].set_ylabel('Predicted')\n", + " ax[0,1].set_xlabel('Observed')\n", + " ax[0,1].set_ylim(plotmin-5,plotmax+5)\n", + " ax[0,1].set_xlim(plotmin-5,plotmax+5)\n", + " ax[0,1].set_title('Outdoor Model Performance')\n", + " ax[0,1].plot([plotmin,plotmax],[plotmin,plotmax], color='red', linestyle='--' )\n", + " ax[0,1].spines['bottom'].set_color('black')\n", + " ax[0,1].spines['left'].set_color('black')\n", + " \n", + " ax[0,2].scatter(PerfDF['y_test_tot'], PerfDF['y_pred_tot'],color='blue', alpha=0.5)\n", + " ax[0,2].set_ylabel('Predicted')\n", + " ax[0,2].set_xlabel('Observed')\n", + " ax[0,2].set_ylim(plotmin_tot-5,plotmax_tot+5)\n", + " ax[0,2].set_xlim(plotmin_tot-5,plotmax_tot+5)\n", + " ax[0,2].set_title('Indoor and Outdoor \\n Model Performance')\n", + " ax[0,2].plot([plotmin_tot,plotmax_tot],[plotmin_tot,plotmax_tot], color='red', linestyle='--' )\n", + " ax[0,2].spines['bottom'].set_color('black')\n", + " ax[0,2].spines['left'].set_color('black')\n", + "\n", + " \n", + " \n", + " \n", + " gs = ax[1, 1].get_gridspec()\n", + " # remove the underlying axes\n", + " ax[1,0].remove()\n", + " ax[1,1].remove()\n", + " ax[1,2].remove()\n", + "\n", + " PerfDF['Error'] = (PerfDF['y_pred']-PerfDF['y_test'])\n", + " axbig1 = fig.add_subplot(gs[1, :])\n", + " axbig1.set_title(month+' Outdoor demand Timeline Evaluation')\n", + " axbig1.axhline(y = 0 , color = 'black')\n", + " #axbig1.bar(PerfDF.index, PerfDF['y_pred'], color='orange', label='Predicted')\n", + " Error1 = axbig1.bar(PerfDF.index, PerfDF['Error'],color='blue', label='Prediction Error')\n", + " axbig1.set_xlabel('Year')\n", + " axbig1.set_ylabel('Error (GPCD)')\n", + " axbig1.spines['bottom'].set_color('black')\n", + " axbig1.spines['left'].set_color('black')\n", + " gradientbars_sliced(Error1)\n", + " \n", + " \n", + " gs2 = ax[2, 1].get_gridspec()\n", + " # remove the underlying axes\n", + " ax[2,0].remove()\n", + " ax[2,1].remove()\n", + " ax[2,2].remove()\n", + "\n", + " #create error value\n", + " PerfDF['Error_tot'] = (PerfDF['y_pred_tot']-PerfDF['y_test_tot'])\n", + " \n", + " axbig2 = fig.add_subplot(gs2[2, :])\n", + " axbig2.set_title(month+' Total Demand Error Timeline Evaluation')\n", + " Error2 = axbig2.bar(PerfDF.index, PerfDF['Error_tot'], color='blue', label='Predicted')\n", + " axbig2.axhline(y = 0 , color = 'black')\n", + " #axbig2.bar(PerfDF.index, PerfDF['y_test_tot'],color='blue', label='Observed')\n", + " axbig2.set_xlabel('Year')\n", + " axbig2.set_ylabel('Error (GPCD)')\n", + " axbig2.spines['bottom'].set_color('black')\n", + " axbig2.spines['left'].set_color('black')\n", + " gradientbars_sliced(Error2)\n", + " \n", + " fig.suptitle(month+ ' Evaluation', size = 16)\n", + " fig.savefig('C:/Users/Ryan/Box/Dissertation/Paper1/Figs/' + month + '_demand.pdf') \n", + " \n", + " O_r2 = sklearn.metrics.r2_score(PerfDF['y_test'],PerfDF['y_pred'])\n", + " O_rmse= sklearn.metrics.mean_squared_error(PerfDF['y_test'],PerfDF['y_pred'], squared = False)\n", + " O_mae= sklearn.metrics.mean_absolute_error(PerfDF['y_test'],PerfDF['y_pred'])\n", + " O_mape= sklearn.metrics.mean_absolute_percentage_error(PerfDF['y_test'],PerfDF['y_pred'])\n", + " \n", + " T_r2 = sklearn.metrics.r2_score(PerfDF['y_test_tot'],PerfDF['y_pred_tot'])\n", + " T_rmse= sklearn.metrics.mean_squared_error(PerfDF['y_test_tot'],PerfDF['y_pred_tot'], squared = False)\n", + " T_mae= sklearn.metrics.mean_absolute_error(PerfDF['y_test_tot'],PerfDF['y_pred_tot'])\n", + " T_mape= sklearn.metrics.mean_absolute_percentage_error(PerfDF['y_test_tot'],PerfDF['y_pred_tot'])\n", + " \n", + " print('The outdoor Demand prediction RMSE is ', O_rmse)\n", + " print('The outdoor Demand prediction R2 is ', O_r2)\n", + " \n", + " print('The Total Demand prediction RMSE is ', T_rmse)\n", + " print('The Total Demand prediction R2 is ', T_r2)\n", + " print('The Total Demand prediction MAE is ', T_mae)\n", + " print('The Total Demand prediction MAPE is ', T_mape, '%') \n", + " \n", + " print('The final set of features for ' + month + ' are', list(X_test_RFE.columns))\n", + " print('The coefficients for each feature are', coef)\n", + " #set DF up so that all months can be easily combined, basically year-month index" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#make an optimization function\n", + "#put in your parameter dictionary, month of interest, and scoring method (RMSE or R2)\n", + "def Demand_Optimization(Param_dict, month, scoring):\n", + " print('The automated algorithm automatically optimizes the respective model by looping over input parameters within')\n", + " print('the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with')\n", + " print('less correlation to the target.')\n", + " param_list = []\n", + " performance_list=[]\n", + " for i in Param_dict['snowfeatures']:\n", + " # print('Snowfeatures is ' + str(i))\n", + " for j in Param_dict['conservation']:\n", + " # print('Conservation is ' + str(j))\n", + " for k in Param_dict['cor_threshold']:\n", + " # print('Correlation threshold: ', k)\n", + " #pbar = ProgressBar()\n", + " for l in Param_dict['colinearity_thresh']:\n", + " # print('Colinearity threshold: ', l)\n", + " X_test_RFE, PerfDF, O_rmse_train,O_r2_train, O_rmse_test, O_r2_test, params, cv_results, cor, coef = Outdoor_Demand_Model(slc_train, month, \n", + " slc_train_features, slc_train_target, slc_test_features,slc_test_target, \n", + " snowfeatures= i, conservation = j, cor_threshold = k, colinearity_thresh = l, cv_splits = 5,\n", + " model_type = linear_model.Ridge(fit_intercept = False, alpha=1), \n", + " scoring = 'neg_root_mean_squared_error')\n", + " param_list.append(params)\n", + " if scoring =='R2':\n", + " performance_list.append(O_r2_test)\n", + " if scoring =='RMSE':\n", + " performance_list.append(O_rmse_test)\n", + " \n", + " \n", + " \n", + " #take model performances and put into DF so they can be joined and sorted \n", + " ParamDF = pd.DataFrame(param_list, columns =list(Param_dict.keys()))\n", + " PerfDF = pd.DataFrame(performance_list, columns =[scoring]) \n", + " ParamEval = pd.concat([ParamDF, PerfDF], axis=1) \n", + " \n", + " if scoring =='R2':\n", + " ParamEval = ParamEval.sort_values(by=[scoring], ascending = False)\n", + " else:\n", + " ParamEval = ParamEval.sort_values(by=[scoring])\n", + " \n", + " #select the first row of parameters as this is the one that shows the greatest performance\n", + " ParamEval=ParamEval.head(1)\n", + " \n", + " X_test_RFE, PerfDF, O_rmse_train,O_r2_train,O_rmse_test, O_r2_test, params, cv_results, cor, coef = Outdoor_Demand_Model(slc_train, month, \n", + " slc_train_features, slc_train_target, slc_test_features,slc_test_target, \n", + " snowfeatures= list(ParamEval['snowfeatures'])[0] , \n", + " conservation = list(ParamEval['conservation'])[0],\n", + " cor_threshold = list(ParamEval['cor_threshold'])[0],\n", + " colinearity_thresh = list(ParamEval['colinearity_thresh'])[0],\n", + " cv_splits = 5, model_type = linear_model.Ridge(fit_intercept = False, alpha=1), \n", + " scoring = 'neg_root_mean_squared_error')\n", + " # model_plots(PerfDF, cv_results, cor, X_test_RFE, coef, scoring, month)\n", + " print('The best training parameters are below with their scoring method: ', scoring)\n", + " print(ParamEval)\n", + " return PerfDF, cv_results, cor, X_test_RFE, coef" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "#Make a function to put all of the predictions together\n", + "def Demand_Forecast(prediction_dictionary, pdict, df, pred, test, units, plotname, model, predcol, obscol):\n", + " FinalDF=pd.DataFrame()\n", + " if pdict is True:\n", + " print('yes')\n", + " for i in prediction_dictionary:\n", + " FinalDF=FinalDF.append(prediction_dictionary[i])\n", + "\n", + " FinalDF=FinalDF.sort_index()\n", + " else:\n", + " print('pdict is not used')\n", + " FinalDF = df\n", + " \n", + " # months = np.arange(1,6,1)\n", + " # Low = list()\n", + " # Ave=list()\n", + " # High = list()\n", + " # for i in months:\n", + " # Low.append('Low'+str(i))\n", + " # Ave.append('Ave'+str(i))\n", + " # High.append('High'+str(i))\n", + " \n", + " # Low.append('Drought')\n", + " # Ave.append('Average')\n", + " # High.append('Surplus')\n", + " \n", + " # months2 = np.arange(7,13,1)\n", + " # for i in months2:\n", + " # Low.append('Low'+str(i))\n", + " # Ave.append('Ave'+str(i))\n", + " # High.append('High'+str(i))\n", + " \n", + " # Conditions = High+Low+Ave\n", + " # print(Conditions)\n", + "\n", + " #adjust date range to improve figure\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n", + " #FinalDF['Date'] = Conditions\n", + " \n", + " FinalDF.index = FinalDF['Date']\n", + " del FinalDF['Date']\n", + " \n", + "\n", + "\n", + " plotmin_tot = FinalDF[[pred, test]].min().min()\n", + " plotmax_tot = FinalDF[[pred, test]].max().max()\n", + " \n", + " Xplotmin = FinalDF.index[0]-np.timedelta64(20, 'D')\n", + " Xplotmax = FinalDF.index[-1]+np.timedelta64(33, 'D')\n", + " \n", + " plt.rc_context({ 'xtick.color':'black'})\n", + " fig, ax = plt.subplots(1,5, constrained_layout=True)\n", + " fig.set_size_inches(9,3.5)\n", + "\n", + " gs2 = ax[0].get_gridspec()\n", + " # remove the underlying axes\n", + " ax[0].remove()\n", + " ax[1].remove()\n", + " ax[2].remove()\n", + " axbig = fig.add_subplot(gs2[:3])\n", + " #axbig.set_title('Total demand Timeline Evaluation')\n", + " # axbig.plot(FinalDF[pred], color='orange', label= model)\n", + " #axbig.plot(FinalDF[test],color='blue', label='Observed')\n", + " axbig.bar(FinalDF.index-np.timedelta64(7, 'D'), FinalDF[pred], color=predcol, label= model ,width = 15, align=\"center\")\n", + " axbig.bar(FinalDF.index+np.timedelta64(8, 'D'), FinalDF[test], color=obscol, label= 'Observed',width = 15, align=\"center\")\n", + " axbig.set_xlabel('Surplus Drought Average \\n \\n Supply Scenario')\n", + " axbig.set_ylim(plotmin_tot-.9,plotmax_tot*1.3)\n", + " axbig.set_xlim(Xplotmin, Xplotmax)\n", + " axbig.set_ylabel('Demand ('+ units+')')\n", + " axbig.legend(loc = 'upper left', facecolor = 'white')\n", + " axbig.set_facecolor(\"white\")\n", + " axbig.spines['bottom'].set_color('black')\n", + " axbig.spines['left'].set_color('black')\n", + " axbig.tick_params(axis='both', which='both', length=5, color='red')\n", + " axbig.xaxis.set_major_locator(mdates.MonthLocator())\n", + " # Get only the month to show in the x-axis:\n", + " axbig.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n", + "\n", + " axbig.annotate('A.', (FinalDF.index[-1], plotmax_tot*1.2), size = 14)\n", + " xticks = axbig.xaxis.get_major_ticks()\n", + " months = [0,5,10,12,17,22,24,29,34]\n", + " \n", + " xticks = axbig.xaxis.get_major_ticks()\n", + " for i,tick in enumerate(xticks):\n", + " #if i%5.5 != 0:\n", + " if i not in months:\n", + " tick.label1.set_visible(False)\n", + " \n", + "\n", + " ax[3].remove()\n", + " ax[4].remove()\n", + "\n", + "\n", + " axbig2 = fig.add_subplot(gs2[3:])\n", + " axbig2.scatter(FinalDF[test], FinalDF[pred],color=predcol, alpha=0.5)\n", + " axbig2.set_ylabel('Predicted (' + units+')' )\n", + " axbig2.set_xlabel('Observed (' + units+')')\n", + " axbig2.set_ylim(plotmin_tot*.95,plotmax_tot*1.2)\n", + " axbig2.set_xlim(plotmin_tot*.95,plotmax_tot*1.2)\n", + " # axbig2.set_title('Indoor and Outdoor \\n Model Performance')\n", + " axbig2.plot([plotmin_tot,plotmax_tot],[plotmin_tot,plotmax_tot], color='black', linestyle='--' )\n", + " #axbig2.set_xticks(np.arange(plotmin_tot, plotmax_tot, 100).round())\n", + " #axbig2.set_yticks(np.arange(plotmin_tot, plotmax_tot, 100).round())\n", + " axbig2.set_facecolor(\"white\")\n", + " axbig2.spines['bottom'].set_color('black')\n", + " axbig2.spines['left'].set_color('black')\n", + " axbig2.annotate('B.', (2050,plotmax_tot*1.1), size = 14)\n", + " axbig2.set_xticks(np.arange(300, 2301, 500))\n", + " axbig2.set_yticks(np.arange(300, 2301, 500))\n", + "\n", + " fig.savefig('C:/Users/Ryan/Box/Dissertation/Paper1/Figs/' +str(plotname)+'bar.pdf')\n", + " r2 = sklearn.metrics.r2_score(FinalDF[test], FinalDF[pred])\n", + " MAE= sklearn.metrics.mean_absolute_error(FinalDF[test], FinalDF[pred])\n", + " RMSE= sklearn.metrics.mean_squared_error(FinalDF[test], FinalDF[pred], squared = False)\n", + " MAPE=np.mean(np.abs((FinalDF[test]- FinalDF[pred])/FinalDF[test])*100)\n", + "\n", + " print('Total R2 is ', r2)\n", + " print('Total MAE is ', MAE)\n", + " print('Total RMSE is ', RMSE)\n", + " print('Total MAPE is ', MAPE)\n", + " \n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M')\n", + " FinalDF.index = FinalDF['Date']\n", + " del FinalDF['Date']\n", + " return FinalDF" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0% | |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The model is automatically selecting features and calibrating the Jan outdoor demand model.\n", + "The automated algorithm automatically optimizes the respective model by looping over input parameters within\n", + "the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with\n", + "less correlation to the target.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8% |###### |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "281 False False 0.2 0.9 11.464743\n", + "The model is automatically selecting features and calibrating the Feb outdoor demand model.\n", + "The automated algorithm automatically optimizes the respective model by looping over input parameters within\n", + "the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with\n", + "less correlation to the target.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 16% |############ |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "197 False True 0.2 0.9 11.742053\n", + "The model is automatically selecting features and calibrating the Mar outdoor demand model.\n", + "The automated algorithm automatically optimizes the respective model by looping over input parameters within\n", + "the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with\n", + "less correlation to the target.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25% |################## |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "221 False True 0.4 0.9 21.166047\n", + "The model is automatically selecting features and calibrating the Apr outdoor demand model.\n", + "The automated algorithm automatically optimizes the respective model by looping over input parameters within\n", + "the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with\n", + "less correlation to the target.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 33% |######################## |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "285 False False 0.25 0.8 10.091413\n", + "The model is automatically selecting features and calibrating the May outdoor demand model.\n", + "The automated algorithm automatically optimizes the respective model by looping over input parameters within\n", + "the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with\n", + "less correlation to the target.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 41% |############################## |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "143 True False 0.45 0.9 26.5945\n", + "The model is automatically selecting features and calibrating the Jun outdoor demand model.\n", + "The automated algorithm automatically optimizes the respective model by looping over input parameters within\n", + "the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with\n", + "less correlation to the target.\n" + ] + } + ], + "source": [ + "#Create the list of parameters to search through to optimize model performance\n", + "p_space = {\n", + " 'snowfeatures': [True, False],\n", + " 'conservation': [True, False],\n", + " 'cor_threshold': np.arange(0,0.7, 0.05),\n", + " 'colinearity_thresh': [0.65, 0.7, 0.75, 0.80, 0.85, 0.90]\n", + "}\n", + "\n", + "#Outdoor_Months=['Apr', 'May' , 'Jun', 'Jul', 'Aug', 'Sep', 'Oct']\n", + "#IndoorMonths = ['Jan', 'Feb', 'Mar', 'Nov', 'Dec']\n", + "Outdoor_Months=['Jan', 'Feb', 'Mar','Apr', 'May' , 'Jun', \n", + " 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']\n", + "\n", + "\n", + "slc_val=copy.deepcopy(slc_test)\n", + "# calibrate and predict with the outdoor model\n", + "pbar = ProgressBar()\n", + "for i in pbar(Outdoor_Months):\n", + " print('The model is automatically selecting features and calibrating the ', i, 'outdoor demand model.' )\n", + " #put the month, use conservation_goal (-1: no, -2: yes) correlation threshold, colineariy threshold, CV, aplpha, model type, tuning method\n", + " #put in the params, month, scoring method (R2, or RMSE for now)\n", + " PerfDF, cv_results, cor, X_test_RFE, coef = Demand_Optimization(p_space, i, 'RMSE')\n", + " \n", + " colrem = slc_test[i].columns\n", + " slc_val[i] = slc_val[i].reset_index(drop=True)\n", + " slc_val[i] = pd.concat([slc_val[i], PerfDF], axis=1, join=\"inner\")\n", + " slc_val[i] = slc_val[i].set_index('Date')\n", + " slc_val[i] = slc_val[i].drop(columns=colrem)\n", + "\n", + "#Calibrate and predict with the indoor model\n", + "#for i in IndoorMonths:\n", + " # slc_val = Indoor_Demand_Model(slc_val, i)\n", + "\n", + "\n", + "#Put it all together and display the results\n", + "#Demand_Forecast(slc_val)\n", + "df = pd.DataFrame()\n", + "Pred_Obs = Demand_Forecast(slc_val, True, df, 'y_pred_tot', 'y_test_tot', 'GPCD', 'MLR_Seasonal_term_pred_gpcd','SLC-WDM ',\n", + " 'blue', 'orange')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "slc_val = np.load('ModelOutput/Slc_Pred_Low_Ave_High_WY.npy', allow_pickle =True).item()\n", + "\n", + "#Need to make figures in liter per capita day\n", + "for i in slc_val:\n", + " slc_val[i]['y_pred']=slc_val[i]['y_pred']*3.785\n", + " slc_val[i]['y_test']=slc_val[i]['y_test']*3.785\n", + " slc_val[i]['y_pred_tot']=slc_val[i]['y_pred_tot']*3.785\n", + " slc_val[i]['y_test_tot']=slc_val[i]['y_test_tot']*3.785" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "yes\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":37: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total R2 is 0.9766188032681973\n", + "Total MAE is 62.997048498508256\n", + "Total RMSE is 73.98582450398375\n", + "Total MAPE is 8.419832806068381\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":122: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.DataFrame()\n", + "Pred_Obs = Demand_Forecast(slc_val, True, df, 'y_pred_tot', 'y_test_tot', 'lpcd', 'MLR_Seasonal_term_pred_lpcd','SLC-WDM ',\n", + " 'blue', 'orange')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from pandas.tseries.offsets import MonthEnd\n", + "cols = ['y_test_tot', 'y_pred_tot']\n", + "monthorder = ['Jan', 'Feb' , 'Mar', 'Apr', 'May', 'Jun' , 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']\n", + "Pred_Obs = Pred_Obs[cols]\n", + "\n", + "#input population into DF to calculate total water demands.\n", + "Population = []\n", + "UR_gpcd = []\n", + "\n", + "slc_pred = copy.deepcopy(slc)\n", + "\n", + "for i in monthorder:\n", + " slc_train[i] = copy.deepcopy(slc[i].loc[:2010])\n", + " slc_pred[i] = slc_pred[i].loc[2015:]\n", + " slc_pred[i]['UR_gpcd'] = np.mean(slc_train[i]['Obs_gpcd'])\n", + " Population.append(np.round(slc_pred[i]['Population'],0))\n", + " \n", + "UR=pd.DataFrame()\n", + "for i in slc_pred:\n", + " slc_pred[i]= pd.DataFrame(slc_pred[i]['UR_gpcd'])\n", + " slc_pred[i]=slc_pred[i].reset_index()\n", + " slc_pred[i]['M'] = datetime.datetime.strptime(i, \"%b\").month\n", + " slc_pred[i]['D'] = 1\n", + " slc_pred[i]['Date'] = pd.to_datetime(slc_pred[i].Year*10000+slc_pred[i].M*100+slc_pred[i].D,format='%Y%m%d')+MonthEnd(1)\n", + " slc_pred[i].index = slc_pred[i].Date\n", + " slc_pred[i]=slc_pred[i].drop(columns = ['M', 'D', 'Date', 'Year'])\n", + " UR = UR.append(slc_pred[i])\n", + "\n", + "UR=UR.sort_index()\n", + "Population = np.sort(np.array(Population).reshape(36,))\n", + "\n", + "#place in to prediction df\n", + "Pred_Obs['Population'] = Population\n", + "#add 3.785 to make metric\n", + "Pred_Obs['UR_gpcd'] = UR['UR_gpcd']*3.785\n", + "\n", + "\n", + "\n", + "#Now we can form some acre-feet predictions.\n", + "#volume_conversion = 3.0689e-6 #gallons to acre-feet\n", + "volume_conversion = 0.001 #L to m3\n", + "daysinmonth = 30\n", + "\n", + "gpcd=['y_test_tot','y_pred_tot','UR_gpcd']\n", + "for i in gpcd:\n", + " Pred_Obs[i+str('_AF')] = Pred_Obs[i]*Pred_Obs['Population']*volume_conversion*daysinmonth\n", + "\n", + " \n", + "remcol=['y_test_tot','y_pred_tot','UR_gpcd', 'Population']\n", + "Ann_Eval = Pred_Obs.drop(columns = remcol).copy()\n", + "Ann_Eval = Ann_Eval.resample('Y').sum()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pdict is not used\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":37: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total R2 is 0.9765992771958528\n", + "Total MAE is 653661.2436470602\n", + "Total RMSE is 767224.8079815292\n", + "Total MAPE is 8.41983280606838\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":122: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Pred_AF = Demand_Forecast(slc_val, False, Pred_Obs, \n", + " 'y_pred_tot_AF', 'y_test_tot_AF', 'm3', 'MLR_Seasonal_term_pred_AF', 'CSD-WDM', 'blue', 'orange')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pdict is not used\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":37: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total R2 is 0.6283371213177069\n", + "Total MAE is 238.5911791239317\n", + "Total RMSE is 294.97807905990385\n", + "Total MAPE is 30.78863740465362\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":122: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Pred_UR_GPCD = Demand_Forecast(slc_val, False, Pred_Obs, 'UR_gpcd',\n", + " 'y_test_tot', 'lpcd', 'Stationary_Demand_Forecast_lpcd', 'Per-Capita Stationarity','red', 'orange')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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", + "
y_test_tot_AFy_pred_tot_AFStationaryErrorSLCWDMErrorStationaryErrorAFSLCWDMErrorAFS_PerrorSLCWDM_Perror
Date
2015-12-311.223144e+081.149160e+08139.858017-112.8897661.484940e+07-7.398335e+0612.140357-6.048623
2016-12-319.931921e+079.912215e+07512.5222364.6030963.944983e+07-1.970593e+0539.720245-0.198410
2017-12-311.052296e+081.017418e+08455.384862-48.8589693.514516e+07-3.487753e+0633.398563-3.314424
\n", + "
" + ], + "text/plain": [ + " y_test_tot_AF y_pred_tot_AF StationaryError SLCWDMError \\\n", + "Date \n", + "2015-12-31 1.223144e+08 1.149160e+08 139.858017 -112.889766 \n", + "2016-12-31 9.931921e+07 9.912215e+07 512.522236 4.603096 \n", + "2017-12-31 1.052296e+08 1.017418e+08 455.384862 -48.858969 \n", + "\n", + " StationaryErrorAF SLCWDMErrorAF S_Perror SLCWDM_Perror \n", + "Date \n", + "2015-12-31 1.484940e+07 -7.398335e+06 12.140357 -6.048623 \n", + "2016-12-31 3.944983e+07 -1.970593e+05 39.720245 -0.198410 \n", + "2017-12-31 3.514516e+07 -3.487753e+06 33.398563 -3.314424 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Pred_UR_GPCD['StationaryError'] = ((Pred_UR_GPCD['UR_gpcd']-Pred_UR_GPCD['y_test_tot'])/Pred_UR_GPCD['y_test_tot'])*100\n", + "Pred_UR_GPCD['SLCWDMError'] = ((Pred_UR_GPCD['y_pred_tot']-Pred_UR_GPCD['y_test_tot'])/Pred_UR_GPCD['y_test_tot'])*100\n", + "Pred_UR_GPCD['StationaryErrorAF'] = Pred_UR_GPCD['UR_gpcd_AF']-Pred_UR_GPCD['y_test_tot_AF']\n", + "Pred_UR_GPCD['SLCWDMErrorAF'] = Pred_UR_GPCD['y_pred_tot_AF']-Pred_UR_GPCD['y_test_tot_AF']\n", + "Evalcol = ['y_test_tot_AF', 'y_pred_tot_AF', 'StationaryError','SLCWDMError', 'StationaryErrorAF', 'SLCWDMErrorAF']\n", + "Eval = Pred_UR_GPCD[Evalcol]\n", + "\n", + "Annual = Eval.resample('Y').sum()\n", + "Annual['S_Perror'] = Annual['StationaryErrorAF']/Annual['y_test_tot_AF']*100\n", + "Annual['SLCWDM_Perror'] = Annual['SLCWDMErrorAF']/Annual['y_test_tot_AF']*100\n", + "Annual" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "April Unit Rate Performance Metrics.\n", + "The Total Demand prediction RMSE is 234.91850229709772\n", + "The Total Demand prediction R2 is -13.681824813630096\n", + "The Total Demand prediction MAE is 226.77711038461538\n", + "The Total Demand prediction MAPE is 44.703907893410765 %\n", + "May Unit Rate Performance Metrics.\n", + "The Total Demand prediction RMSE is 364.68138183793025\n", + "The Total Demand prediction R2 is -3.7219675866079367\n", + "The Total Demand prediction MAE is 323.7713262820511\n", + "The Total Demand prediction MAPE is 45.51889792211568 %\n", + "June Unit Rate Performance Metrics.\n", + "The Total Demand prediction RMSE is 272.6448447309825\n", + "The Total Demand prediction R2 is -5.179017266006832\n", + "The Total Demand prediction MAE is 249.6095891025643\n", + "The Total Demand prediction MAPE is 17.22121622514535 %\n", + "July Unit Rate Performance Metrics.\n", + "The Total Demand prediction RMSE is 434.639220557867\n", + "The Total Demand prediction R2 is -4.936276355154155\n", + "The Total Demand prediction MAE is 396.3433634615385\n", + "The Total Demand prediction MAPE is 23.52375253778731 %\n", + "August Unit Rate Performance Metrics.\n", + "The Total Demand prediction RMSE is 577.2817651472257\n", + "The Total Demand prediction R2 is -5.899025532475611\n", + "The Total Demand prediction MAE is 533.8067993589748\n", + "The Total Demand prediction MAPE is 38.3716373444204 %\n", + "September Unit Rate Performance Metrics.\n", + "The Total Demand prediction RMSE is 325.897395288007\n", + "The Total Demand prediction R2 is -4.712212915477304\n", + "The Total Demand prediction MAE is 295.99961666666667\n", + "The Total Demand prediction MAPE is 26.186610164335676 %\n", + "October Unit Rate Performance Metrics.\n", + "The Total Demand prediction RMSE is 219.860347338743\n", + "The Total Demand prediction R2 is -5.848827970390566\n", + "The Total Demand prediction MAE is 203.17637371794856\n", + "The Total Demand prediction MAPE is 30.40882998900284 %\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " Pred_UR_GPCD['Month'] = Pred_UR_GPCD.index.month\n" + ] + } + ], + "source": [ + "#Get monthly stats for UR\n", + "URcol = ['y_test_tot', 'UR_gpcd']\n", + "Pred_UR_GPCD = Pred_UR_GPCD[URcol]\n", + "Pred_UR_GPCD['Month'] = Pred_UR_GPCD.index.month\n", + "UR = {}\n", + "\n", + "Irrmon = np.arange(4,11,1)\n", + "month = ['Apr', 'May', 'Jun' , 'Jul', 'Aug', 'Sep', 'Oct']\n", + "for i in Irrmon:\n", + " UR[i]=Pred_UR_GPCD.loc[Pred_UR_GPCD['Month']==i]\n", + " \n", + "for i in UR:\n", + " \n", + " print( calendar.month_name[i], 'Unit Rate Performance Metrics.')\n", + " T_r2 = sklearn.metrics.r2_score(UR[i]['y_test_tot'],UR[i]['UR_gpcd'])\n", + " T_rmse= sklearn.metrics.mean_squared_error(UR[i]['y_test_tot'],UR[i]['UR_gpcd'], squared = False)\n", + " T_mae= sklearn.metrics.mean_absolute_error(UR[i]['y_test_tot'],UR[i]['UR_gpcd'])\n", + " T_mape= sklearn.metrics.mean_absolute_percentage_error(UR[i]['y_test_tot'],UR[i]['UR_gpcd'])*100\n", + " \n", + " print('The Total Demand prediction RMSE is ', T_rmse)\n", + " print('The Total Demand prediction R2 is ', T_r2)\n", + " print('The Total Demand prediction MAE is ', T_mae)\n", + " print('The Total Demand prediction MAPE is ', T_mape, '%') \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pdict is not used\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":37: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total R2 is 0.6235333383547133\n", + "Total MAE is 2485687.106818947\n", + "Total RMSE is 3077310.1021666485\n", + "Total MAPE is 30.788637404653628\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":122: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Pred_UR_AF = Demand_Forecast(slc_val, False, Pred_Obs, 'UR_gpcd_AF', \n", + " 'y_test_tot_AF', 'm3', 'Seasonal_term_pred_UR_AF', 'Per-Capita Stationarity', 'red', 'orange')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "'''I am putting a hard code on the limits here to make both figure have same color scale'''\n", + "\n", + "plt.rcParams[\"axes.grid\"] = False\n", + "plt.rcParams[\"axes.facecolor\"] ='white'\n", + "#plt.rcParams[\"axes.edgecolor\"]['bottom'] = 'black'\n", + "\n", + "def gradientbars_sliced(bars, ymin, ymax):\n", + " ax = bars[0].axes\n", + " xmin, xmax = ax.get_xlim()\n", + " # ymin, ymax = ax.get_ylim()\n", + " for bar in bars:\n", + " bar.set_zorder(1)\n", + " bar.set_facecolor(\"none\")\n", + " x, y = bar.get_xy()\n", + " w, h = bar.get_width(), bar.get_height()\n", + " grad = np.linspace(y, y + h, 256).reshape(256, 1)\n", + " ax.imshow(grad, extent=[x, x + w, y, y + h], aspect=\"auto\", zorder=0, origin='lower',\n", + " vmin= - max(np.abs(ymin), ymax), vmax=max(np.abs(ymin), ymax), cmap='Spectral_r')\n", + " ax.axis([xmin, xmax, ymin, ymax])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Reduce width to increase space between bars\n", + "width = .9\n", + "widthM = 1\n", + "titlesize = 14\n", + "\n", + "Ann_Eval['Supply'] = ['Surplus', 'Drought', 'Average']\n", + "Ann_Eval.index = Ann_Eval['Supply']\n", + "\n", + "DayDF = Ann_Eval\n", + "\n", + "fig, ax = plt.subplots(3,1, constrained_layout=True)\n", + "fig.set_size_inches(9,11)\n", + "DayDF['Error_SLC_WDM'] = DayDF.y_pred_tot_AF-DayDF.y_test_tot_AF\n", + "DayDF['Error_UR'] = DayDF.UR_gpcd_AF-DayDF.y_test_tot_AF\n", + "\n", + "\n", + "#Annual Figure\n", + "\n", + "ax[0].bar(DayDF.Supply, DayDF.UR_gpcd_AF, width=width, \n", + " color='red', label='Base')\n", + "ax[0].bar(DayDF.Supply, DayDF.y_pred_tot_AF, width=width, \n", + " color='orange', label='MLR')\n", + "ax[0].bar(DayDF.Supply, DayDF.y_test_tot_AF, width=width, \n", + " color='blue', label='Observed')\n", + "ax[0].set_ylim(0,max(max(Ann_Eval.y_test_tot_AF), max(Ann_Eval.y_pred_tot_AF),max(Ann_Eval.UR_gpcd_AF))*1.2)\n", + "#ax.annotate('Max Extra DC use: '+str(np.round(np.max(DayDF.ExtraDC),1))+'MGD', \n", + " # xy=(DayDF.index[269], 150))\n", + "#ax.annotate('Max Daily DC use: '+str(np.round(np.max(DayDF.SLCDPU_DC_Water_Use),1))+'MGD', \n", + " # xy=(DayDF.index[269], 130))\n", + "ax[0].legend(loc = 'upper left')\n", + "ax[0].set_ylabel('Acre-Feet')\n", + "ax[0].set_title(' Comparison of Seasonal Forecasts vs Observed', size = titlesize)\n", + "ax[0].spines['bottom'].set_color('black')\n", + "ax[0].spines['left'].set_color('black')\n", + "\n", + "\n", + "Error_UR = ax[1].bar(DayDF.index, DayDF.Error_UR, width=width, \n", + " color='red', label='Base')\n", + "ax[1].set_ylabel('Acre-Feet')\n", + "ax[1].set_title('Base: Difference From The Observed', size = titlesize)\n", + "gradientbars_sliced(Error_UR, min(min(DayDF.Error_UR), min(DayDF.Error_SLC_WDM)),\n", + " max(max(DayDF.Error_UR), max(DayDF.Error_SLC_WDM)))\n", + "ax[1].spines['bottom'].set_color('black')\n", + "ax[1].spines['left'].set_color('black')\n", + "\n", + "\n", + "\n", + "Error_SLC_WDM = ax[2].bar(DayDF.Supply, DayDF.Error_SLC_WDM, width=width, \n", + " color='red', label='Unit-Rate')\n", + "ax[2].set_ylabel('Acre-Feet')\n", + "ax[2].set_title('MLR: Difference From The Observed', size = titlesize)\n", + "gradientbars_sliced(Error_SLC_WDM, min(min(DayDF.Error_UR), min(DayDF.Error_SLC_WDM)),\n", + " max(max(DayDF.Error_UR), max(DayDF.Error_SLC_WDM)))\n", + "ax[2].spines['bottom'].set_color('black')\n", + "ax[2].spines['left'].set_color('black')\n", + "\n", + "fig.savefig('C:/Users/Ryan/Box/Dissertation/Paper1/Figs/SLC_WDMvsUR.pdf')" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Apr': Year y_pred y_test y_test_tot y_pred_tot Error \\\n", + " Date \n", + " 2015-04-30 2008 12.647772 9.222 160.030 138.438436 3.425772 \n", + " 2016-04-30 2015 33.293892 26.980 139.970 145.202253 6.313892 \n", + " 2017-04-30 2017 10.059749 0.000 120.354 118.001738 10.059749 \n", + " \n", + " Error_tot MLP \n", + " Date \n", + " 2015-04-30 -21.591564 138.438436 \n", + " 2016-04-30 5.232253 145.202253 \n", + " 2017-04-30 -2.352262 118.001738 ,\n", + " 'Aug': Year y_pred y_test y_test_tot y_pred_tot Error \\\n", + " Date \n", + " 2015-08-31 2008 302.248810 324.702 475.51 428.039474 -22.453190 \n", + " 2016-08-31 2015 220.620071 262.590 375.58 332.528433 -41.969929 \n", + " 2017-08-31 2017 265.660614 217.536 337.89 373.602603 48.124614 \n", + " \n", + " Error_tot MLP \n", + " Date \n", + " 2015-08-31 -47.470526 428.039474 \n", + " 2016-08-31 -43.051567 332.528433 \n", + " 2017-08-31 35.712603 373.602603 ,\n", + " 'Dec': Year y_pred y_test y_pred_tot y_test_tot MLP\n", + " Date \n", + " 2015-12-31 2008 125.790665 147.32 125.790665 147.32 125.790665\n", + " 2016-12-31 2015 111.908362 110.26 111.908362 110.26 111.908362\n", + " 2017-12-31 2017 107.941989 118.13 107.941989 118.13 107.941989,\n", + " 'Feb': Year y_pred y_test y_pred_tot y_test_tot MLP\n", + " Date \n", + " 2015-02-28 2008 125.790665 152.96 125.790665 152.96 125.790665\n", + " 2016-02-29 2015 111.908362 109.65 111.908362 109.65 111.908362\n", + " 2017-02-28 2017 107.941989 123.80 107.941989 123.80 107.941989,\n", + " 'Jan': Year y_pred y_test y_pred_tot y_test_tot MLP\n", + " Date \n", + " 2015-01-31 2008 125.790665 147.35 125.790665 147.35 125.790665\n", + " 2016-01-31 2015 111.908362 115.90 111.908362 115.90 111.908362\n", + " 2017-01-31 2017 107.941989 131.46 107.941989 131.46 107.941989,\n", + " 'Jul': Year y_pred y_test y_test_tot y_pred_tot Error \\\n", + " Date \n", + " 2015-07-31 2008 345.596436 361.692 512.50 471.387100 -16.095564 \n", + " 2016-07-31 2015 331.499939 292.590 405.58 443.408301 38.909939 \n", + " 2017-07-31 2017 333.081238 376.396 496.75 441.023227 -43.314762 \n", + " \n", + " Error_tot MLP \n", + " Date \n", + " 2015-07-31 -41.112900 471.387100 \n", + " 2016-07-31 37.828301 443.408301 \n", + " 2017-07-31 -55.726773 441.023227 ,\n", + " 'Jun': Year y_pred y_test y_test_tot y_pred_tot Error \\\n", + " Date \n", + " 2015-06-30 2008 250.611420 252.512 403.32 376.402084 -1.900580 \n", + " 2016-06-30 2015 229.515717 246.680 359.67 341.424078 -17.164283 \n", + " 2017-06-30 2017 289.165100 309.616 429.97 397.107089 -20.450900 \n", + " \n", + " Error_tot MLP \n", + " Date \n", + " 2015-06-30 -26.917916 376.402084 \n", + " 2016-06-30 -18.245922 341.424078 \n", + " 2017-06-30 -32.862911 397.107089 ,\n", + " 'Mar': Year y_pred y_test y_pred_tot y_test_tot MLP\n", + " Date \n", + " 2015-03-31 2008 125.790665 140.60 125.790665 140.60 125.790665\n", + " 2016-03-31 2015 111.908362 100.26 111.908362 100.26 111.908362\n", + " 2017-03-31 2017 107.941989 108.35 107.941989 108.35 107.941989,\n", + " 'May': Year y_pred y_test y_test_tot y_pred_tot Error \\\n", + " Date \n", + " 2015-05-31 2008 103.540779 117.772 268.58 229.331444 -14.231221 \n", + " 2016-05-31 2015 48.452835 47.920 160.91 160.361197 0.532835 \n", + " 2017-05-31 2017 135.121429 106.726 227.08 243.063419 28.395429 \n", + " \n", + " Error_tot MLP \n", + " Date \n", + " 2015-05-31 -39.248556 229.331444 \n", + " 2016-05-31 -0.548803 160.361197 \n", + " 2017-05-31 15.983419 243.063419 ,\n", + " 'Nov': Year y_pred y_test y_pred_tot y_test_tot MLP\n", + " Date \n", + " 2015-11-30 2008 125.790665 165.81 125.790665 165.81 125.790665\n", + " 2016-11-30 2015 111.908362 128.88 111.908362 128.88 111.908362\n", + " 2017-11-30 2017 107.941989 120.03 107.941989 120.03 107.941989,\n", + " 'Oct': Year y_pred y_test y_test_tot y_pred_tot Error \\\n", + " Date \n", + " 2015-10-31 2008 70.003418 61.472 212.28 195.794083 8.531418 \n", + " 2016-10-31 2015 58.438091 80.870 193.86 170.346453 -22.431909 \n", + " 2017-10-31 2017 55.001297 38.416 158.77 162.943286 16.585297 \n", + " \n", + " Error_tot MLP \n", + " Date \n", + " 2015-10-31 -16.485917 195.794083 \n", + " 2016-10-31 -23.513547 170.346453 \n", + " 2017-10-31 4.173286 162.943286 ,\n", + " 'Sep': Year y_pred y_test y_test_tot y_pred_tot Error \\\n", + " Date \n", + " 2015-09-30 2008 187.024292 209.082 359.89 312.814957 -22.057708 \n", + " 2016-09-30 2015 210.461639 211.610 324.60 322.370001 -1.148361 \n", + " 2017-09-30 2017 159.301178 151.846 272.20 267.243167 7.455178 \n", + " \n", + " Error_tot MLP \n", + " Date \n", + " 2015-09-30 -47.075043 312.814957 \n", + " 2016-09-30 -2.229999 322.370001 \n", + " 2017-09-30 -4.956833 267.243167 }" + ] + }, + "execution_count": 209, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MLP" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#Make similar figure to one above, but include RFR and MLP.\n", + "#Make bars side by side rather than stacked\n", + "#need to convert MLP and RFR to metric too\n", + "acreft_m3 = 1233.48\n", + "MLP = pd.read_excel('MLP_Models/MLP_Ann_Comp.xlsx')\n", + "RFR = pd.read_excel('RFR_Models/RFR_Ann_Comp.xlsx')\n", + "colrem = ['Supply', 'Supply.1', 'UR_gpcd_AF' ,'Error_UR', 'y_test_tot_AF']\n", + "MLP.index = MLP['Supply']\n", + "RFR.index = RFR['Supply']\n", + "MLP =MLP.drop(columns = colrem)\n", + "RFR = RFR.drop(columns = colrem)\n", + "\n", + "\n", + "MLP_col = ['MLP_pred_tot_AF', 'Error_MLP']\n", + "RFR_col = ['RFR_pred_tot_AF', 'Error_RFR']\n", + "\n", + "MLP.columns = MLP_col\n", + "RFR.columns = RFR_col\n", + "\n", + "#add mlp and RFR predictions to MLR/Ur\n", + "DayDF['RFR_pred'] =RFR['RFR_pred_tot_AF']*acreft_m3\n", + "DayDF['RFR_Err'] =RFR['Error_RFR']*acreft_m3\n", + "\n", + "DayDF['MLP_pred'] =MLP['MLP_pred_tot_AF']*acreft_m3\n", + "DayDF['MLP_Err'] =MLP['Error_MLP']*acreft_m3\n", + "\n", + "Preds = ['y_test_tot_AF' ,'y_pred_tot_AF', 'MLP_pred', 'RFR_pred', 'UR_gpcd_AF' ]\n", + "Err = ['Error_SLC_WDM', 'MLP_Err', 'RFR_Err', 'Error_UR' ]\n", + "labels = ['Observed','SLC-WDM' , 'MLP' , 'RFR', 'Stationary']\n", + "label2 = ['SLC-WDM' , 'MLP' , 'RFR', 'Stationary']\n", + "\n", + "\n", + "Preds = DayDF[Preds].copy()\n", + "Preds.columns = labels\n", + "Err = DayDF[Err].copy()\n", + "Err.columns =label2\n", + "ErrPerc = Err.copy()\n", + "\n", + "ErrPerc['Stationary'] = round(((Preds['Stationary']-Preds['Observed'])/Preds['Observed'])*100,1)\n", + "ErrPerc['SLC-WDM'] = round(((Preds['SLC-WDM']-Preds['Observed'])/Preds['Observed'])*100,1)\n", + "ErrPerc['MLP'] = round(((Preds['MLP']-Preds['Observed'])/Preds['Observed'])*100,1)\n", + "ErrPerc['RFR'] = round(((Preds['RFR']-Preds['Observed'])/Preds['Observed'])*100,1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Reduce width to increase space between bars\n", + "width = .8\n", + "widthM = 1\n", + "titlesize = 14\n", + "\n", + "colorA = ['orange', 'red', 'blue' ,'green' , 'purple']\n", + "colorB = ['red','blue' ,'green' , 'purple']\n", + "\n", + "colorder = ['Observed', 'Stationary', 'SLC-WDM', 'MLP', 'RFR']\n", + "colorder2 = [ 'Stationary', 'SLC-WDM', 'MLP', 'RFR']\n", + "\n", + "Preds = Preds[colorder]\n", + "Preds=Preds.rename(columns={\"Stationary\": \"Per-Capita Stationarity\", 'SLC-WDM':'CSD-WDM'})\n", + "\n", + "Err = Err[colorder2]\n", + "Err=Err.rename(columns={\"Stationary\": \"Per-Capita Stationarity\", 'SLC-WDM':'CSD-WDM'})\n", + "\n", + "#del Preds['MLP'], Preds['RFR'], Err['MLP'], Err['RFR']\n", + "\n", + "#colorA = ['orange', 'red' , 'blue']\n", + "#colorB = ['red' ,'blue']\n", + "\n", + "fig, ax = plt.subplots(2,1, constrained_layout=True)\n", + "fig.set_size_inches(9,9)\n", + "\n", + "#Annual Figure\n", + "\n", + "Preds.plot(ax=ax[0], kind='bar', grid=True, width=width, color = colorA)\n", + "ax[0].legend(labels)\n", + "#ax[0].set_ylim(0,max(max(Ann_Eval.y_test_tot_AF), max(Ann_Eval.y_pred_tot_AF),max(Ann_Eval.UR_gpcd_AF))*1.2)\n", + "#ax.annotate('Max Extra DC use: '+str(np.round(np.max(DayDF.ExtraDC),1))+'MGD', \n", + " # xy=(DayDF.index[269], 150))\n", + "#ax.annotate('Max Daily DC use: '+str(np.round(np.max(DayDF.SLCDPU_DC_Water_Use),1))+'MGD', \n", + " # xy=(DayDF.index[269], 130))\n", + "ax[0].legend(loc = 'upper left')\n", + "ax[0].set_ylabel('Seasonal Forecast (m3)', size = 14)\n", + "ax[0].set_ylim(0,np.max(Preds['Per-Capita Stationarity'])*1.6)\n", + "#ax[0].set_title(' Comparison of Seasonal Forecasts vs Observed', size = titlesize)\n", + "ax[0].spines['bottom'].set_color('black')\n", + "ax[0].spines['left'].set_color('black')\n", + "ax[0].tick_params(labelrotation=0, labelsize = 13)\n", + "ax[0].xaxis.label.set_visible(False)\n", + "ax[0].text(2.3, np.max(Preds['Per-Capita Stationarity'])*1.5, \"A.\", size = 16)\n", + "\n", + "\n", + "Err.plot(ax=ax[1], kind='bar', grid=True, width =width, color=colorB, legend=False)\n", + "ax[1].set_ylabel('Seasonal Forecast Error (m3)', size = 14)\n", + "#ax[1].set_title('Error', size = titlesize)\n", + "ax[1].spines['bottom'].set_color('black')\n", + "ax[1].spines['left'].set_color('black')\n", + "ax[1].tick_params(labelrotation=0, labelsize = 13)\n", + "ax[1].axhline(y=0, color='black', linestyle='-')\n", + "#ax[1].xaxis.label.set_visible(False)\n", + "ax[1].set_xlabel('Supply Scenario', size = 14)\n", + "ax[1].text(2.3,38000000, 'B.', size = 16)\n", + "\n", + "ax2 = ax[1].twinx()\n", + "ax2.spines['right'].set_position(('axes', 1))\n", + "ax2.set_ylim(-16.8,42)\n", + "ax2.set_ylabel('Seasonal Forecast Error (%)', size = 14)\n", + "ax2.plot(ax=ax2)\n", + "ax2.spines['bottom'].set_color('black')\n", + "ax2.spines['left'].set_color('black')\n", + "ax2.spines['right'].set_color('black')\n", + "\n", + "\n", + "\n", + "rects = ax[1].patches\n", + "\n", + "# Make some labels.\n", + "labels = list(ErrPerc['Stationary'])+list(ErrPerc['SLC-WDM'])+list(ErrPerc['MLP'])+ list(ErrPerc['RFR'])\n", + "#labels = list(ErrPerc['Stationary'])+list(ErrPerc['SLC-WDM'])\n", + "\n", + "for rect, label in zip(rects, labels):\n", + " height = rect.get_height()\n", + " if label > 0:\n", + " # [str(i)+ '%' for i in labels]\n", + " ax[1].text(rect.get_x() + rect.get_width() / 2, height + 5, str(label)+'%',\n", + " ha='center', va='bottom', size = 12)\n", + " else:\n", + " ax[1].text(rect.get_x() + rect.get_width() / 2, height - 2000, str(label)+'%',\n", + " ha='center', va='bottom', size = 12)\n", + "\n", + "\n", + "\n", + "\n", + "fig.savefig('C:/Users/Ryan/Box/Dissertation/Paper1/Figs/UR_SLCWDM_Demand_compare.pdf')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "#Make a function to put all of the predictions together\n", + "def Demand_Forecastgpcd_AF(gpcd, pdict, df, pred1, test1,pred2, test2, units1, units2, plotname, model):\n", + " FinalDF=pd.DataFrame()\n", + " if pdict is True:\n", + " print('yes')\n", + " for i in gpcd:\n", + " FinalDF=FinalDF.append(gpcd[i])\n", + "\n", + " FinalDF=FinalDF.sort_index()\n", + " else:\n", + " print('no')\n", + " FinalDF = df\n", + " \n", + " # months = np.arange(1,6,1)\n", + " # Low = list()\n", + " #Ave=list()\n", + " #High = list()\n", + " #for i in months:\n", + " # Low.append('Low'+str(i))\n", + " # Ave.append('Ave'+str(i))\n", + " # High.append('High'+str(i))\n", + " \n", + " #Low.append('Drought')\n", + " #Ave.append('Average')\n", + " #High.append('Surplus')\n", + " \n", + " #months2 = np.arange(7,13,1)\n", + " #for i in months2:\n", + " # Low.append('Low'+str(i))\n", + " # Ave.append('Ave'+str(i))\n", + " # High.append('High'+str(i))\n", + " \n", + " # Conditions = High+Low+Ave\n", + "\n", + " #adjust date range to improve figure\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n", + " #FinalDF['Date'] = Conditions\n", + " \n", + " FinalDF.index = FinalDF['Date']\n", + " del FinalDF['Date']\n", + "\n", + " \n", + "\n", + "\n", + " plotmin_tot1 = FinalDF[[pred1, test1]].min().min()\n", + " plotmax_tot1 = FinalDF[[pred1, test1]].max().max()\n", + " \n", + " plotmin_tot2 = FinalDF[[pred2, test2]].min().min()\n", + " plotmax_tot2 = FinalDF[[pred2, test2]].max().max()\n", + " \n", + " Xplotmin = FinalDF.index[0]-np.timedelta64(20, 'D')\n", + " Xplotmax = FinalDF.index[-1]+np.timedelta64(33, 'D')\n", + "\n", + " fig, ax = plt.subplots(2,6, constrained_layout=True)\n", + " fig.set_size_inches(10,5)\n", + "\n", + " gs1 = ax[0,0].get_gridspec()\n", + " # remove the underlying axes\n", + " ax[0,0].remove()\n", + " ax[0,1].remove()\n", + " ax[0,2].remove()\n", + " axbig = fig.add_subplot(gs1[0,:3])\n", + " #axbig.set_title('Total demand Timeline Evaluation')\n", + " #axbig.plot(FinalDF[pred1], color='orange', label= model)\n", + " #axbig.plot(FinalDF[test1],color='blue', label='Observed')\n", + " axbig.bar(FinalDF.index-np.timedelta64(7, 'D'), FinalDF[pred1], color='orange', label= 'CSD-WDM',width = 15, align=\"center\")\n", + " axbig.bar(FinalDF.index+np.timedelta64(8, 'D'), FinalDF[test1], color='blue', label= 'Observed',width = 15, align=\"center\")\n", + " axbig.set_xlabel('Supply Conditions')\n", + " axbig.set_ylim(plotmin_tot1-.9,plotmax_tot1*1.4)\n", + " axbig.set_xlim(Xplotmin, Xplotmax)\n", + " axbig.set_ylabel('Demand ('+ units1+')')\n", + " axbig.legend(loc = 'upper left', facecolor = 'white')\n", + " axbig.set_facecolor(\"white\")\n", + " axbig.spines['bottom'].set_color('black')\n", + " axbig.spines['left'].set_color('black')\n", + " axbig.tick_params(axis='both', which='both', length=5, color='red')\n", + " axbig.xaxis.set_major_locator(mdates.MonthLocator())\n", + " # Get only the month to show in the x-axis:\n", + " axbig.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n", + " axbig.annotate('A.', (FinalDF.index[-1], 600), size = 14)\n", + " xticks = axbig.xaxis.get_major_ticks()\n", + " months = [0,5,10,12,17,22,24,29,34]\n", + " \n", + " xticks = axbig.xaxis.get_major_ticks()\n", + " for i,tick in enumerate(xticks):\n", + " #if i%5.5 != 0:\n", + " if i not in months:\n", + " tick.label1.set_visible(False)\n", + " \n", + " \n", + " # xticks = axbig.xaxis.get_major_ticks()\n", + " #for i,tick in enumerate(xticks):\n", + " # if i%12 != 5:\n", + " # tick.label1.set_visible(False)\n", + "\n", + " ax[0,3].remove()\n", + " ax[0,4].remove()\n", + " ax[0,5].remove()\n", + "\n", + "\n", + " axbig2 = fig.add_subplot(gs1[0:,3:])\n", + " axbig2.scatter(FinalDF[test1], FinalDF[pred1],color='blue', alpha=0.5)\n", + " axbig2.set_ylabel('Predicted (' + units1+')' )\n", + " axbig2.set_xlabel('Observed (' + units1+')')\n", + " axbig2.set_ylim(plotmin_tot1*.95,plotmax_tot1*1.2)\n", + " axbig2.set_xlim(plotmin_tot1*.95,plotmax_tot1*1.2)\n", + " # axbig2.set_title('Indoor and Outdoor \\n Model Performance')\n", + " axbig2.plot([plotmin_tot1,plotmax_tot1],[plotmin_tot1,plotmax_tot1], color='red', linestyle='--' )\n", + " #axbig2.set_xticks(np.arange(plotmin_tot, plotmax_tot, 100).round())\n", + " #axbig2.set_yticks(np.arange(plotmin_tot, plotmax_tot, 100).round())\n", + " axbig2.set_facecolor(\"white\")\n", + " axbig2.spines['bottom'].set_color('black')\n", + " axbig2.spines['left'].set_color('black')\n", + " axbig2.text(550,600, 'C.', size = 16)\n", + " #ax[2].set_aspect('equal', adjustable='box')\n", + " \n", + " \n", + " \n", + " \n", + " gs2 = ax[1,0].get_gridspec()\n", + " # remove the underlying axes\n", + " ax[1,0].remove()\n", + " ax[1,1].remove()\n", + " ax[1,2].remove()\n", + " ax[1,3].remove()\n", + " ax[1,4].remove()\n", + " ax[1,5].remove()\n", + " axbig = fig.add_subplot(gs2[1,:3])\n", + " #axbig.set_title('Total demand Timeline Evaluation')\n", + " #axbig.plot(FinalDF[pred2], color='orange', label= 'Predicted')\n", + " axbig.bar(FinalDF.index-np.timedelta64(7, 'D'), FinalDF[pred2], color='orange', label= 'SLC-WDM',width = 15, align=\"center\")\n", + " #axbig.plot(FinalDF[test2],color='blue', label='Observed')\n", + " axbig.bar(FinalDF.index+np.timedelta64(8, 'D'), FinalDF[test2], color='blue', label= 'Observed',width = 15, align=\"center\") \n", + " axbig.set_xlabel('Supply Conditions')\n", + " axbig.set_ylim(plotmin_tot2-.9,plotmax_tot2*1.2)\n", + " axbig.set_xlim(Xplotmin, Xplotmax)\n", + " axbig.set_ylabel('Demand ('+ units2+')')\n", + " #axbig.legend(loc = 'upper left')\n", + " axbig.set_facecolor(\"white\")\n", + " axbig.spines['bottom'].set_color('black')\n", + " axbig.spines['left'].set_color('black')\n", + " axbig.tick_params(axis='both', which='both', length=5, color='red')\n", + " axbig.xaxis.set_major_locator(mdates.MonthLocator())\n", + " # Get only the month to show in the x-axis:\n", + " axbig.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n", + "\n", + " axbig.annotate('B.', (FinalDF.index[-1], 17000), size = 14)\n", + " xticks = axbig.xaxis.get_major_ticks()\n", + " months = [0,5,10,12,17,22,24,29,34]\n", + " \n", + " xticks = axbig.xaxis.get_major_ticks()\n", + " for i,tick in enumerate(xticks):\n", + " #if i%5.5 != 0:\n", + " if i not in months:\n", + " tick.label1.set_visible(False)\n", + " \n", + " \n", + " #axbig.text(35,17000, 'B.', size = 16)\n", + " #axbig.get_legend().remove()\n", + " \n", + " #xticks = axbig.xaxis.get_major_ticks()\n", + " #for i,tick in enumerate(xticks):\n", + " # if i%12 != 5:\n", + " # tick.label1.set_visible(False)\n", + " fig.savefig('C:/Users/Ryan/Box/Dissertation/Paper1/Figs/MLR_Seasonal_gpcd_AFbar.pdf')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":36: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Demand_Forecastgpcd_AF(slc_val, False, Pred_Obs, \n", + " 'y_pred_tot', 'y_test_tot','y_pred_tot_AF', 'y_test_tot_AF', 'gpcd', 'Acre-Feet', 'MLR_Performance', 'CSD-WDM ')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "#Make a function to put all of the predictions together\n", + "def MultiModelDemand_Forecast(prediction_dictionary, Error, pdict, df, units, plotname):\n", + " FinalDF=pd.DataFrame()\n", + " if pdict is True:\n", + " print('yes')\n", + " for i in prediction_dictionary:\n", + " FinalDF=FinalDF.append(prediction_dictionary[i])\n", + "\n", + " FinalDF=FinalDF.sort_index()\n", + " else:\n", + " print('pdict is not used')\n", + " FinalDF = df\n", + " \n", + " # months = np.arange(1,6,1)\n", + " # Low = list()\n", + " # Ave=list()\n", + " # High = list()\n", + " # for i in months:\n", + " # Low.append('Low'+str(i))\n", + " # Ave.append('Ave'+str(i))\n", + " # High.append('High'+str(i))\n", + " \n", + " # Low.append('Drought')\n", + " # Ave.append('Average')\n", + " # High.append('Surplus')\n", + " \n", + " # months2 = np.arange(7,13,1)\n", + " # for i in months2:\n", + " # Low.append('Low'+str(i))\n", + " # Ave.append('Ave'+str(i))\n", + " # High.append('High'+str(i))\n", + " \n", + " # Conditions = High+Low+Ave\n", + " # print(Conditions)\n", + "\n", + " #adjust date range to improve figure\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n", + " #FinalDF['Date'] = FinalDF['Date']-np.timedelta64(14, 'D')\n", + " #FinalDF['Date'] = Conditions\n", + " \n", + " FinalDF.index = FinalDF['Date']\n", + " del FinalDF['Date']\n", + " \n", + " #Error or no error\n", + " if Error ==False:\n", + " Observed = FinalDF['Observed']\n", + " SLCWDM = FinalDF['SLCWDM']\n", + " MLP = FinalDF['MLP']\n", + " RFR = FinalDF['RFR']\n", + " Stationary = FinalDF['Per-Capita Stationarity']\n", + " if Error == True:\n", + " SLCWDM = FinalDF['SLCWDM_Error']\n", + " MLP = FinalDF['MLP_Error']\n", + " RFR = FinalDF['RFR_Error']\n", + " Stationary = FinalDF['Stationary_Error']\n", + " \n", + " SLCWDM_MAPE = FinalDF['SLCWDM_Error_MAPE']\n", + " MLP_MAPE = FinalDF['MLP_Error_MAPE']\n", + " RFR_MAPE = FinalDF['RFR_Error_MAPE']\n", + " Stationary_MAPE = FinalDF['Stationary_Error_MAPE']\n", + "\n", + " \n", + " plotmin_tot = MLP.min()-5\n", + " plotmax_tot = Stationary.max()\n", + " \n", + " plotmin_Perc = MLP_MAPE.min()-5\n", + " plotmax_Perc = Stationary_MAPE.max()\n", + " \n", + " Xplotmin = FinalDF.index[0]-np.timedelta64(20, 'D')\n", + " Xplotmax = FinalDF.index[-1]+np.timedelta64(33, 'D')\n", + " \n", + " plt.rc_context({ 'xtick.color':'black'})\n", + " fig, ax = plt.subplots(2,3, constrained_layout=True)\n", + " fig.set_size_inches(12,9)\n", + "\n", + " gs = ax[0,2].get_gridspec()\n", + " # remove the underlying axes\n", + " ax[0,0].remove()\n", + " ax[0,1].remove()\n", + " ax[0,2].remove()\n", + " axbig = fig.add_subplot(gs[0,:3])\n", + " axbig.set_facecolor(\"white\")\n", + " #axbig.set_title('Total demand Timeline Evaluation')\n", + " #axbig.bar(FinalDF.index,FinalDF['Observed'], color='blue', width= 15, label='Observed', zorder=1)\n", + " #if Error ==False:\n", + " # axbig.plot(FinalDF.index,Observed, color='blue', label='Observed', zorder=1)\n", + " axbig.bar(FinalDF.index-np.timedelta64(11, 'D'), SLCWDM, color='blue', label= 'CSD-WDM',width = 7, zorder=3, align=\"center\")\n", + " axbig.bar(FinalDF.index-np.timedelta64(4, 'D'),MLP, color='green', label= 'MLP', width = 7, zorder=2,align=\"center\")\n", + " axbig.bar(FinalDF.index+np.timedelta64(3, 'D'),RFR, color='purple', label= 'RFR',width = 7, zorder=2,align=\"center\")\n", + " axbig.bar(FinalDF.index+np.timedelta64(10, 'D'),Stationary, color='red', label= 'Per-Capita Stationarity', width = 7, zorder=1,align=\"center\")\n", + " axbig.axhline( y = 0, color= 'black')\n", + " \n", + " #axbig.set_xlabel('Surplus Drought Average \\n \\n Supply Scenario', size = 16)\n", + " axbig.set_ylim(plotmin_tot*1.2,plotmax_tot*1.2)\n", + " axbig.set_xlim(Xplotmin, Xplotmax)\n", + " axbig.set_ylabel('Prediction Error ('+ units+')', size = 16)\n", + " axbig.legend(loc = 'upper left', facecolor = 'white', fontsize=13)\n", + " axbig.spines['bottom'].set_color('black')\n", + " axbig.spines['left'].set_color('black')\n", + " axbig.tick_params(axis='both', which='both', length=5, color='black')\n", + " axbig.xaxis.set_major_locator(mdates.MonthLocator())\n", + " # Get only the month to show in the x-axis:\n", + " axbig.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n", + " axbig.tick_params(axis = 'both', labelsize = 14)\n", + " axbig.annotate('A.', (FinalDF.index[-1], plotmax_tot*1.2), size = 16)\n", + "\n", + "\n", + " \n", + "\n", + " #axbig.annotate('A.', (FinalDF.index[-1], 600), size = 14)\n", + " #make a list of desired months\n", + " months = [0,5,10,12,17,22,24,29,34]\n", + " \n", + " xticks = axbig.xaxis.get_major_ticks()\n", + " for i,tick in enumerate(xticks):\n", + " #if i%5.5 != 0:\n", + " if i not in months:\n", + " tick.label1.set_visible(False)\n", + " \n", + " #gs2 = ax[1,2].get_gridspec()\n", + " # remove the underlying axes\n", + " ax[1,0].remove()\n", + " ax[1,1].remove()\n", + " ax[1,2].remove()\n", + " axbig2 = fig.add_subplot(gs[1,:3])\n", + " axbig2.set_facecolor(\"white\")\n", + " #axbig.set_title('Total demand Timeline Evaluation')\n", + " #axbig.bar(FinalDF.index,FinalDF['Observed'], color='blue', width= 15, label='Observed', zorder=1)\n", + " #if Error ==False:\n", + " # axbig.plot(FinalDF.index,Observed, color='blue', label='Observed', zorder=1)\n", + " axbig2.bar(FinalDF.index-np.timedelta64(11, 'D'), SLCWDM_MAPE, color='blue', label= 'SLC-WDM',width = 7, zorder=3, align=\"center\")\n", + " axbig2.bar(FinalDF.index-np.timedelta64(4, 'D'),MLP_MAPE, color='green', label= 'MLP', width = 7, zorder=2,align=\"center\")\n", + " axbig2.bar(FinalDF.index+np.timedelta64(3, 'D'),RFR_MAPE, color='purple', label= 'RFR',width = 7, zorder=2,align=\"center\")\n", + " axbig2.bar(FinalDF.index+np.timedelta64(10, 'D'),Stationary_MAPE, color='red', label= 'Per-Capita Stationarity', width = 7, zorder=1,align=\"center\")\n", + " axbig2.axhline( y = 0, color= 'black')\n", + " \n", + " axbig2.set_xlabel('Surplus Drought Average \\n \\n Supply Scenario', size = 16)\n", + " axbig2.set_ylim(plotmin_Perc*.9,plotmax_Perc*1.2)\n", + " axbig2.set_xlim(Xplotmin, Xplotmax)\n", + " axbig2.set_ylabel('Prediction Error (%)', size = 16)\n", + " #axbig2.legend(loc = 'upper left')\n", + " axbig2.spines['bottom'].set_color('black')\n", + " axbig2.spines['left'].set_color('black')\n", + " axbig2.tick_params(axis='both', which='both', length=5, color='black')\n", + " axbig2.xaxis.set_major_locator(mdates.MonthLocator())\n", + " # Get only the month to show in the x-axis:\n", + " axbig2.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n", + " axbig2.tick_params(axis = 'both', labelsize = 14)\n", + " axbig2.annotate('B.', (FinalDF.index[-1], 100), size = 16)\n", + "\n", + "\n", + " \n", + "\n", + " #axbig.annotate('A.', (FinalDF.index[-1], 600), size = 14)\n", + " #make a list of desired months\n", + " months = [0,5,10,12,17,22,24,29,34]\n", + " \n", + " xticks = axbig2.xaxis.get_major_ticks()\n", + " for i,tick in enumerate(xticks):\n", + " #if i%5.5 != 0:\n", + " if i not in months:\n", + " tick.label1.set_visible(False)\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " fig.savefig('C:/Users/Ryan/Box/Dissertation/Paper1/Figs/' +str(plotname)+'.pdf')\n", + " # r2 = sklearn.metrics.r2_score(FinalDF[test], FinalDF[pred])\n", + " #MAE= sklearn.metrics.mean_absolute_error(FinalDF[test], FinalDF[pred])\n", + " #RMSE= sklearn.metrics.mean_squared_error(FinalDF[test], FinalDF[pred], squared = False)\n", + " #MAPE=np.mean(np.abs((FinalDF[test]- FinalDF[pred])/FinalDF[test])*100)\n", + "\n", + " # print('Total R2 is ', r2)\n", + " # print('Total MAE is ', MAE)\n", + " # print('Total RMSE is ', RMSE)\n", + " # print('Total MAPE is ', MAPE)\n", + " \n", + " \n", + " return FinalDF" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "#load mlp and rfr df's to make a predition version to evaluate all model performance\n", + "#save predictions\n", + "RFR = np.load('RFR_Models/Slc_Pred.npy', allow_pickle = True).item()\n", + "#save predictions\n", + "MLP = np.load('MLP_Models/Slc_Pred.npy', allow_pickle = True).item()\n", + "\n", + "Model_Comp = copy.deepcopy(slc_pred)\n", + "\n", + "gal_to_m3 = 0.00378541\n", + "l_to_m3 = 0.001\n", + "#make unique labels for each model\n", + "for i in RFR:\n", + " RFR[i]['RFR'] = RFR[i]['y_pred_tot']\n", + " MLP[i]['MLP'] = MLP[i]['y_pred_tot']\n", + " slc_val[i]['SLCWDM'] = slc_val[i]['y_pred_tot']\n", + " slc_val[i]['Observed'] = slc_val[i]['y_test_tot']\n", + " slc_pred[i]['Per-Capita Stationarity'] = slc_pred[i]['UR_gpcd']\n", + " \n", + " \n", + " #align the index on them all, slc-pred already has the updated dates\n", + " RFR[i].index = slc_pred[i].index\n", + " MLP[i].index = slc_pred[i].index\n", + " slc_val[i].index = slc_pred[i].index\n", + " \n", + " #put all into their own dictionaries\n", + " #Observed and SLCWDM already in liters, convert to m3\n", + " Model_Comp[i]['Observed'] = slc_val[i]['Observed']*350000*l_to_m3*30\n", + " Model_Comp[i]['SLCWDM'] = slc_val[i]['SLCWDM']*350000*l_to_m3*30\n", + " Model_Comp[i]['MLP'] = MLP[i]['MLP']*350000*gal_to_m3*30\n", + " Model_Comp[i]['RFR'] = RFR[i]['RFR']*350000*gal_to_m3*30\n", + " Model_Comp[i]['Per-Capita Stationarity'] = slc_pred[i]['Per-Capita Stationarity']*350000*gal_to_m3*30\n", + " \n", + " #Create ML error values\n", + " Model_Comp[i]['SLCWDM_Error'] = Model_Comp[i]['SLCWDM']-Model_Comp[i]['Observed']\n", + " Model_Comp[i]['MLP_Error'] = Model_Comp[i]['MLP']-Model_Comp[i]['Observed']\n", + " Model_Comp[i]['RFR_Error'] = Model_Comp[i]['RFR']-Model_Comp[i]['Observed']\n", + " Model_Comp[i]['Stationary_Error'] = Model_Comp[i]['Per-Capita Stationarity']-Model_Comp[i]['Observed']\n", + " \n", + " Model_Comp[i]['SLCWDM_Error_MAPE'] = (Model_Comp[i]['SLCWDM_Error']/Model_Comp[i]['Observed'])*100\n", + " Model_Comp[i]['MLP_Error_MAPE'] = (Model_Comp[i]['MLP_Error']/Model_Comp[i]['Observed'])*100\n", + " Model_Comp[i]['RFR_Error_MAPE'] = (Model_Comp[i]['RFR_Error']/Model_Comp[i]['Observed'])*100\n", + " Model_Comp[i]['Stationary_Error_MAPE'] = (Model_Comp[i]['Stationary_Error']/Model_Comp[i]['Observed'])*100\n", + " \n", + " \n", + " del Model_Comp[i]['UR_gpcd']\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "yes\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":37: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n", + " FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Model_Comparision = MultiModelDemand_Forecast(Model_Comp, True, True, Pred_Obs, 'm3', 'Model_Comparison')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}