From fa4ca6ebc293330d5e7a63382527a5a96ad9fc9c Mon Sep 17 00:00:00 2001 From: Ryan Johnson <33735397+whitelightning450@users.noreply.github.com> Date: Tue, 14 Jun 2022 17:09:07 -0600 Subject: [PATCH] Loading interactive files --- CSD_WDM_OOP.py | 1586 +++++++++++++++++++++++++++++++++++++ CSD_WDM_interactive.ipynb | 918 +++++++++++++++++++++ 2 files changed, 2504 insertions(+) create mode 100644 CSD_WDM_OOP.py create mode 100644 CSD_WDM_interactive.ipynb diff --git a/CSD_WDM_OOP.py b/CSD_WDM_OOP.py new file mode 100644 index 0000000..a0b1aeb --- /dev/null +++ b/CSD_WDM_OOP.py @@ -0,0 +1,1586 @@ +#Author: Ryan C. Johnson PhD +#Date: 6/10/2022 + + +''' +We want to see the trends for the training data,# and will want to have them modeled into the future based +on consevation goals + +From plots, There appears to be very little trends in training data. The last 10 years do show decreasing trends +likely due to conservation goals estabished in 2005 + + +Thinking of a stepwise process: +1) identify any trends (training and testing): check, no trends in training. however in 2000, Utah established a + conservation goal. To reduce the gpcd water use by 25% by 2025. Evaluating water use from 2005-2017 shows a decline + in water use. +2) Determine conservation goals (annual reduction /yr, slope), over 25yrs a 75 gpcd reduction is requested (3gpcd/yr), check +3) Separately model indoor and outdoor demands per year. check +4) Training Outdoor demand (Apr-Oct) will be that month's total demand minus that years Jan-Mar mean indoor demand +5) Final model = modeled indoor demand - conservation reduction + Outdoor demand (if Apr-Oct). +''' + + + +import numpy as np +import pandas as pd +from sklearn.model_selection import train_test_split +from sklearn.linear_model import LinearRegression +from sklearn import linear_model +from sklearn.model_selection import GridSearchCV +from sklearn.metrics import mean_absolute_error +from sklearn. metrics import accuracy_score +from sklearn import metrics +from sklearn.metrics import r2_score +from sklearn.metrics import classification_report +from sklearn.metrics import mean_absolute_percentage_error +from sklearn import metrics +from sklearn.metrics import mean_squared_error +from sklearn.utils import resample +from sklearn.model_selection import cross_val_score +from sklearn.model_selection import LeaveOneOut +from sklearn import preprocessing +import matplotlib.dates as mdates + +import matplotlib.pyplot as plt +from sklearn.preprocessing import PolynomialFeatures +from sklearn.pipeline import make_pipeline +import seaborn as sns; sns.set() +import joblib +from sklearn.linear_model import LassoCV +from sklearn.datasets import make_regression +from pathlib import Path +import copy +import pickle + +#Trying out recusive feature elimination to compare with step wise regression +from sklearn.feature_selection import RFE +from sklearn.linear_model import LinearRegression +from sklearn.model_selection import cross_val_score +from sklearn.model_selection import KFold +from sklearn.model_selection import GridSearchCV +from sklearn.pipeline import make_pipeline +import sklearn + +import statsmodels.api as sm +from time import strptime +import datetime +import calendar +from calendar import monthrange +from progressbar import ProgressBar +import warnings +warnings.filterwarnings('ignore') + + +#ignoring unnecessary warnings +np.warnings.filterwarnings('ignore', category=np.VisibleDeprecationWarning) +np.warnings.filterwarnings('ignore', category=UserWarning) +from pandas.core.common import SettingWithCopyWarning +np.warnings.simplefilter(action="ignore", category=SettingWithCopyWarning) + +plt.rcParams["axes.grid"] = False +plt.rcParams["axes.facecolor"] ='white' + + + +class CSDWDM(): + + def __init__(self, cwd): + self = self + self.cwd = cwd + + def SLC_Data_Processing(self, slc, snow, O_cons, I_cons, time): + + #rename the gpcd column + for i in slc: + slc[i].rename(columns={i+'_gpcd': 'Obs_gpcd'}, inplace=True) + slc[i]=slc[i].set_index('Year') + snow=snow.set_index('Year') + #need to remove certain features + + colrem= ['Dem_AF', 'seven', 'meantemp_days', 'maxtemp_days', 'mean_max', 'mill', 'precip_days', + 'Days_abovemax','Days_abovemean', 'red' , 'emig', 'sqmi','max_Days_WO', + 'mtn','ResHouseDensity', 'Urban_Area_Perc','Residential_Area_Perc', 'IrrPopulationDensity', + 'Irrigated_Area_Perc','CityCrk_AcFt_WR_Mar', 'LitCotCrk_AcFt_WR_Jun']#, 'AcFt', 'WO', 'days', 'days', 'above' , 'Perc'] + + + for i in slc: + for j in colrem: + slc[i]=slc[i].loc[:,~slc[i].columns.str.contains(j , case=False)] + + #Create training and testing data, use most recent low, average, and high water years + self.slc_train=copy.deepcopy(slc) + self.slc_test=copy.deepcopy(slc) + + #2008 is a high year + #2011 and 2017 are average years + #2014 and 2016 are below average years + #2015 is a very low year + + IN_WY_Months = ['Jan' , 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug','Sep', 'Oct'] + Prior_YR_WY_Months = ['Nov', 'Dec'] + testWYyrs = [2008,2015,2017] + + + for i in slc: + #Select the training/testing dataframes + self.slc_train[i]=self.slc_train[i][~self.slc_train[i].index.isin(testWYyrs)] + self.slc_test[i]=self.slc_test[i][self.slc_test[i].index.isin(testWYyrs)] + + + #Determine the indoor mean to subtract from outdoor + self.I_mean_train=(self.slc_train['Jan']['Obs_gpcd']+ + self.slc_train['Feb']['Obs_gpcd']+ + self.slc_train['Mar']['Obs_gpcd']+ + self.slc_train['Nov']['Obs_gpcd']+ + self.slc_train['Dec']['Obs_gpcd'])/5 + self.I_mean_test=(self.slc_test['Jan']['Obs_gpcd']+ + self.slc_test['Feb']['Obs_gpcd']+ + self.slc_test['Mar']['Obs_gpcd']+ + self.slc_test['Nov']['Obs_gpcd']+ + self.slc_test['Dec']['Obs_gpcd'])/5 + + for i in self.slc_train: + self.slc_train[i]['Iave']=self.I_mean_train + #for now include testing years + self.slc_test[i]['Iave']=self.I_mean_test + + IrrSeason= ['Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct'] + Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec'] + colrem=['Iave', 'Obs_gpcd'] + #set the target gpcd to indoor for indoor and total-indoor for outdoor + #change to indoor to separate outdoor demands from total + for i in Indoor: + self.slc_train[i]['Target_gpcd']=self.slc_train[i]['Obs_gpcd'] + self.slc_train[i]= self.slc_train[i].drop(columns=colrem) + #for now include testing years + self.slc_test[i]['Target_gpcd']=self.slc_test[i]['Obs_gpcd'] + self.slc_test[i]= self.slc_test[i].drop(columns=colrem) + + for i in IrrSeason: + self.slc_train[i]['Target_gpcd']=self.slc_train[i]['Obs_gpcd']-self.slc_train[i]['Iave'] + self.slc_train[i].loc[self.slc_train[i]['Target_gpcd'] < 0, 'Target_gpcd'] = 0 + + #add in snow info + self.slc_train[i]=pd.concat([self.slc_train[i], snow], axis=1, join="inner") + + self.slc_train[i]= self.slc_train[i].drop(columns=colrem) + #for now include testing years + self.slc_test[i]=pd.concat([self.slc_test[i], snow], axis=1, join="inner") + self.slc_test[i]['Target_gpcd']=self.slc_test[i]['Obs_gpcd']-self.slc_test[i]['Iave'] + self.slc_test[i].loc[self.slc_test[i]['Target_gpcd'] < 0, 'Target_gpcd'] = 0 + + #create monthly historical mean and conservation trends + Out_mean = np.mean(self.slc_train[i]['Target_gpcd'].loc[2000:]) + goal = (1-O_cons)*Out_mean + O_cons_rate = (Out_mean -goal)/time + + + + self.slc_train[i]['cons_goal'] = Out_mean- ((self.slc_train[i].index-2000)*O_cons_rate) + self.slc_train[i].loc[ self.slc_train[i].index <2000, ['cons_goal']] = Out_mean + + t=self.slc_train[i]['Target_gpcd'].copy() + c=self.slc_train[i]['cons_goal'].copy() + self.slc_train[i] = self.slc_train[i].drop(columns=['Target_gpcd', 'cons_goal']) + self.slc_train[i]['Target_gpcd'] = t + self.slc_train[i]['cons_goal'] = c + + self.slc_test[i]['cons_goal'] = Out_mean - ((self.slc_test[i].index-2000)*O_cons_rate) + self.slc_test[i]= self.slc_test[i].drop(columns=colrem) + + #Determine the historical indoor mean to apply conservation strategies too + Indmean = np.mean(self.slc_train['Jan']['Target_gpcd'].loc[2000:]+ + self.slc_train['Feb']['Target_gpcd'].loc[2000:]+ + self.slc_train['Mar']['Target_gpcd'].loc[2000:]+ + self.slc_train['Nov']['Target_gpcd'].loc[2000:]+ + self.slc_train['Dec']['Target_gpcd'].loc[2000:])/5 + + goal = (1-I_cons)*Indmean + + + + cons_rate = (Indmean -goal)/time + + + #create feature called cons_goal! + for i in Indoor: + self.slc_test[i]['cons_goal'] = Indmean-((self.slc_test[i].index-2000)*cons_rate) + self.slc_train[i]['cons_goal'] = Indmean-((self.slc_train[i].index-2000)*cons_rate) + + self.slc_train[i].loc[self.slc_train[i].index <2000, ['cons_goal']] = Indmean + + + self.Cons_mean_test=(self.slc_test['Jan']['cons_goal']+ + self.slc_test['Feb']['cons_goal']+ + self.slc_test['Mar']['cons_goal']+ + self.slc_test['Nov']['cons_goal']+ + self.slc_test['Dec']['cons_goal'])/5 + + #split training and testing data into features and targets + self.slc_train_target=copy.deepcopy(self.slc_train) + self.slc_train_features=copy.deepcopy(self.slc_train) + + self.slc_test_target=copy.deepcopy(self.slc_test) + self.slc_test_features=copy.deepcopy(self.slc_test) + + + target=['Target_gpcd','Housing'] + for i in self.slc_train_target: + self.slc_train_target[i]=self.slc_train_target[i]['Target_gpcd'] + #for now include testing years + self.slc_test_target[i]=self.slc_test_target[i]['Target_gpcd'] + + + self.slc_train_features[i]= self.slc_train_features[i].drop(columns=target) + #for now include testing years + self.slc_test_features[i]= self.slc_test_features[i].drop(columns=target) + + #need to remove year from the list to run plots below + for i in self.slc_train: + self.slc_train[i]=self.slc_train[i].drop(columns=['Housing', 'Population', 'PopulationDensity']) + + + + + def CSD_WDM_Train(self, p_space, Outdoor_Months, IndoorMonths, scoring): + self.slc_val=copy.deepcopy(self.slc_test) + # calibrate and predict with the outdoor model + pbar = ProgressBar() + for i in pbar(Outdoor_Months): + print('The model is automatically selecting features and calibrating the ', i, 'outdoor demand model.' ) + #put the month, use conservation_goal (-1: no, -2: yes) correlation threshold, colineariy threshold, CV, aplpha, model type, tuning method + #put in the params, month, scoring method (R2, or RMSE for now) + PerfDF, cv_results, cor, X_test_RFE, coef = self.Demand_Optimization(p_space, i, scoring) + + colrem = self.slc_test[i].columns + self.slc_val[i] = self.slc_val[i].reset_index(drop=True) + self.slc_val[i] = pd.concat([self.slc_val[i], PerfDF], axis=1, join="inner") + self.slc_val[i] = self.slc_val[i].set_index('Date') + self.slc_val[i] = self.slc_val[i].drop(columns=colrem) + + + + + + def Outdoor_Demand_Model(self, TrainDF, month, X_train_features, y_train_target, X_test_features, y_test_target, + snowfeatures, conservation, cor_threshold, colinearity_thresh, cv_splits, + model_type, scoring ): + + + #subset these features out of main DF and put into cute heatmap plot + + DFcor = copy.deepcopy(TrainDF[month]) + + #if snowfeatures is True: + # print('LCC Snowfeatures are being used') + Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec'] + if snowfeatures is False: + if month in Indoor: + DFcor=DFcor + else: + snow=['Nov_snow_in','Dec_snow_in', 'Jan_snow_in','Feb_snow_in', + 'Mar_snow_in','Apr_snow_in', 'Total_snow_in', 'Snow_shortage'] + DFcor=DFcor.drop(columns=snow) + + + cor=DFcor.copy() + if conservation is False: + del cor['cons_goal'] + cor = cor.corr() + cor =cor.iloc[:,-1:] + if conservation is True: + cor = cor.corr() + cor =cor.iloc[:,-2:] + del cor['cons_goal'] + + cor['Target_gpcd']=np.abs(cor['Target_gpcd']) + cor=cor.sort_values(by=['Target_gpcd'], ascending=False) + cor=cor.dropna() + + #Selecting highly correlated features + relevant_features = cor[cor['Target_gpcd']>cor_threshold] + CorFeat = list(relevant_features.index) + + CorDF= DFcor[CorFeat] + cor = np.abs(CorDF.corr()) + cor = cor.mask(np.tril(np.ones(cor.shape)).astype(np.bool)) + #remove colinearity + cor = cor[cor.columns[cor.max() < colinearity_thresh]] + CorFeat=cor.columns + cor = cor.T + cor = cor[CorFeat] + + #print('Remaining features are', CorFeat) + + + #Set up training and testing data + X_train = X_train_features[month][CorFeat].copy() + #X_train = slc_train_features['Jul'][JulF] + y_train = y_train_target[month].copy() + + X_test = X_test_features[month][CorFeat].copy() + #X_test = slc_test_features['Jul'][JulF] + y_test = y_test_target[month].copy() + + # step-1: create a cross-validation scheme + folds = KFold(n_splits = cv_splits, shuffle = True, random_state = 42) + + # step-2: specify range of hyperparameters to tune + if len(CorFeat) > 1 : + hyper_params = [{'n_features_to_select': list(range(1, len(CorFeat)))}] + + + # step-3: perform grid search + # 3.1 specify model, key to set intercept to false + trainmodel = model_type + trainmodel.fit(X_train, y_train) + rfe = RFE(trainmodel) + + # 3.2 call GridSearchCV() + model_cv = GridSearchCV(estimator = rfe, + param_grid = hyper_params, + scoring= scoring, + cv = folds, + verbose = 0, + return_train_score=True) + + # fit the model + model_cv.fit(X_train, y_train) + + # create a KFold object with 5 splits + folds = KFold(n_splits = cv_splits, shuffle = True, random_state = 42) + scores = cross_val_score(trainmodel, X_train, y_train, scoring=scoring, cv=folds) + # print('CV scores = ', scores) + + # cv results + cv_results = pd.DataFrame(model_cv.cv_results_) + + + #code to select features for final model, tell how many features + N_feat=cv_results.loc[cv_results['mean_test_score'].idxmax()] + N_feat=N_feat['param_n_features_to_select'] + #print('Number of features to select is ', N_feat) + # intermediate model + n_features_optimal = N_feat + + Int_model = model_type + Int_model.fit(X_train, y_train) + + rfe = RFE(Int_model, n_features_to_select=n_features_optimal) + rfe = rfe.fit(X_train, y_train) + + #make the final model with rfe features + + # tuples of (feature name, whether selected, ranking) + # note that the 'rank' is > 1 for non-selected features + + Features =list(zip(X_train.columns,rfe.support_,rfe.ranking_)) + FeaturesDF=pd.DataFrame(Features, columns=['Feature', 'Important', 'Score']) + FeaturesDF = FeaturesDF[FeaturesDF.Score<=1] + RFE_features = list(FeaturesDF['Feature']) + # print('The final features are ', RFE_features) + + #select only RFE features for model training/validation + X_train = X_train[RFE_features] + X_test = X_test[RFE_features] + + + #plot of selected features to make sure not colinear + CorDF= X_train.copy() + CorDF['Target_gpcd']=self.slc_train[month]['Target_gpcd'] + + Final_model = model_type + Final_model.fit(X_train, y_train) + + #grab uncertainty stats + + # Uncertainty = sm.OLS(y_train, X_train).fit() + # print(Uncertainty.summary()) + + + else: + + #Set up training and testing data to have a random non-correlated feature then + X_train = X_train_features[month]['HousingDensity'].copy() + X_test = X_test_features[month]['HousingDensity'].copy() + cv_results = 0 + cor = 0 + + len1 = len(X_train) + len2 = len(X_test) + + X_train = np.array(X_train).reshape(len1, 1) + X_test = np.array(X_test).reshape(len2, 1) + + Final_model = model_type + Final_model.fit(X_train, y_train) + + # Uncertainty = sm.OLS(y_train, X_train).fit() + # print(Uncertainty.summary()) + + + # Get training data model performance to tune hyperparameters + yt_pred = Final_model.predict(X_train) + + yt_pred = [0 if x < 0 else x for x in yt_pred] + O_r2_train = sklearn.metrics.r2_score(y_train, yt_pred) + O_rmse_train = sklearn.metrics.mean_squared_error(y_train, yt_pred, squared = False) + + # predict X_test + y_pred = Final_model.predict(X_test) + + y_pred = [0 if x < 0 else x for x in y_pred] + O_r2_test = sklearn.metrics.r2_score(y_test, y_pred) + O_rmse_test = sklearn.metrics.mean_squared_error(y_test, y_pred, squared = False) + + + + #plot the predictions + PerfDF=pd.DataFrame(list(zip(y_pred, y_test)), columns=['y_pred', 'y_test']) + + #Add indoor demands + Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec'] + if month in Indoor: + PerfDF['y_test_tot']=PerfDF['y_test'] + PerfDF['y_pred_tot']=PerfDF['y_pred'] + else: + PerfDF['y_test_tot']=PerfDF['y_test']+list(self.I_mean_test) + PerfDF['y_pred_tot']=PerfDF['y_pred']+list(self.Cons_mean_test) + + T_r2 = sklearn.metrics.r2_score(PerfDF['y_test_tot'], PerfDF['y_pred_tot']) + T_rmse= sklearn.metrics.mean_squared_error(PerfDF['y_test_tot'], PerfDF['y_pred_tot'], + squared = False) + + #print('Total R2 is ', T_r2) + #print('Total rmse is ', T_rmse) + + + PerfDF['Year'] = list(self.slc_test['Jul'].index) + PerfDF=PerfDF.set_index('Year') + + + datetime_object = datetime.datetime.strptime(month, "%b") + PerfDF['month'] = datetime_object.month + PerfDF['Year']=PerfDF.index + + + #set up dates so all months can be combined and sorted + day=[] + for index, row in PerfDF.iterrows(): + day.append(calendar.monthrange(int(row['Year']), int(row['month']))[1]) + + PerfDF['Day']=day + + PerfDF['Date'] = pd.to_datetime(PerfDF[['Year', 'month', 'Day']]) + + #PerfDF=PerfDF.set_index('Date') + PerfDF=PerfDF.drop(columns=['Year', 'month', 'Day']) + PerfDF=PerfDF.reset_index() + + params = [snowfeatures, conservation, cor_threshold, colinearity_thresh] + + return X_test, PerfDF, O_rmse_train, O_r2_train ,O_rmse_test, O_r2_test , params, cv_results, cor , Final_model.coef_ + + + + def Outdoor_Demand_ModelFinal(self, TrainDF, month, X_train_features, y_train_target, X_test_features, y_test_target, + snowfeatures, conservation, cor_threshold, colinearity_thresh, cv_splits, + model_type, scoring ): + + + #subset these features out of main DF and put into cute heatmap plot + + DFcor = copy.deepcopy(TrainDF[month]) + + #if snowfeatures is True: + # print('LCC Snowfeatures are being used') + Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec'] + if snowfeatures is False: + if month in Indoor: + DFcor=DFcor + else: + snow=['Nov_snow_in','Dec_snow_in', 'Jan_snow_in','Feb_snow_in', + 'Mar_snow_in','Apr_snow_in', 'Total_snow_in', 'Snow_shortage'] + DFcor=DFcor.drop(columns=snow) + + + cor=DFcor.copy() + if conservation is False: + del cor['cons_goal'] + cor = cor.corr() + cor =cor.iloc[:,-1:] + if conservation is True: + cor = cor.corr() + cor =cor.iloc[:,-2:] + del cor['cons_goal'] + + cor['Target_gpcd']=np.abs(cor['Target_gpcd']) + cor=cor.sort_values(by=['Target_gpcd'], ascending=False) + cor=cor.dropna() + + #Selecting highly correlated features + relevant_features = cor[cor['Target_gpcd']>cor_threshold] + CorFeat = list(relevant_features.index) + + CorDF= DFcor[CorFeat] + cor = np.abs(CorDF.corr()) + cor = cor.mask(np.tril(np.ones(cor.shape)).astype(np.bool)) + #remove colinearity + cor = cor[cor.columns[cor.max() < colinearity_thresh]] + CorFeat=cor.columns + cor = cor.T + cor = cor[CorFeat] + + #print('Remaining features are', CorFeat) + + + #Set up training and testing data + X_train = X_train_features[month][CorFeat].copy() + #X_train = slc_train_features['Jul'][JulF] + y_train = y_train_target[month].copy() + + X_test = X_test_features[month][CorFeat].copy() + #X_test = slc_test_features['Jul'][JulF] + y_test = y_test_target[month].copy() + + # step-1: create a cross-validation scheme + folds = KFold(n_splits = cv_splits, shuffle = True, random_state = 42) + + # step-2: specify range of hyperparameters to tune + if len(CorFeat) > 1 : + hyper_params = [{'n_features_to_select': list(range(1, len(CorFeat)))}] + + + # step-3: perform grid search + # 3.1 specify model, key to set intercept to false + trainmodel = model_type + trainmodel.fit(X_train, y_train) + rfe = RFE(trainmodel) + + # 3.2 call GridSearchCV() + model_cv = GridSearchCV(estimator = rfe, + param_grid = hyper_params, + scoring= scoring, + cv = folds, + verbose = 0, + return_train_score=True) + + # fit the model + model_cv.fit(X_train, y_train) + + # create a KFold object with 5 splits + folds = KFold(n_splits = cv_splits, shuffle = True, random_state = 42) + scores = cross_val_score(trainmodel, X_train, y_train, scoring=scoring, cv=folds) + # print('CV scores = ', scores) + + # cv results + cv_results = pd.DataFrame(model_cv.cv_results_) + + + #code to select features for final model, tell how many features + N_feat=cv_results.loc[cv_results['mean_test_score'].idxmax()] + N_feat=N_feat['param_n_features_to_select'] + #print('Number of features to select is ', N_feat) + # intermediate model + n_features_optimal = N_feat + + Int_model = model_type + Int_model.fit(X_train, y_train) + + rfe = RFE(Int_model, n_features_to_select=n_features_optimal) + rfe = rfe.fit(X_train, y_train) + + #make the final model with rfe features + + # tuples of (feature name, whether selected, ranking) + # note that the 'rank' is > 1 for non-selected features + + Features =list(zip(X_train.columns,rfe.support_,rfe.ranking_)) + FeaturesDF=pd.DataFrame(Features, columns=['Feature', 'Important', 'Score']) + FeaturesDF = FeaturesDF[FeaturesDF.Score<=1] + RFE_features = list(FeaturesDF['Feature']) + print('The final features are ', RFE_features) + featurefile = self.cwd + '/Models/Features/' + month + '_features.pkl' + with open(featurefile, 'wb') as f: + pickle.dump(RFE_features, f) + + #select only RFE features for model training/validation + X_train = X_train[RFE_features] + X_test = X_test[RFE_features] + + + #plot of selected features to make sure not colinear + CorDF= X_train.copy() + CorDF['Target_gpcd']=self.slc_train[month]['Target_gpcd'] + + Final_model = model_type + Final_model.fit(X_train, y_train) + + #grab uncertainty stats + + Uncertainty = sm.OLS(y_train, X_train).fit() + print(Uncertainty.summary()) + + + else: + + #Set up training and testing data to have a random non-correlated feature then + X_train = X_train_features[month]['HousingDensity'].copy() + X_test = X_test_features[month]['HousingDensity'].copy() + cv_results = 0 + cor = 0 + + len1 = len(X_train) + len2 = len(X_test) + + X_train = np.array(X_train).reshape(len1, 1) + X_test = np.array(X_test).reshape(len2, 1) + + Final_model = model_type + Final_model.fit(X_train, y_train) + + Uncertainty = sm.OLS(y_train, X_train).fit() + print(Uncertainty.summary()) + + + # save the model to disk + filename = self.cwd+ '/Models/' + month + '_demand_model.sav' + pickle.dump(Final_model, open(filename, 'wb')) + + UNC_filename = self.cwd+ '/Models/' + month + '_demand_model_unc.sav' + pickle.dump(Uncertainty, open(UNC_filename, 'wb')) + + + + #load model + Final_model_loaded = pickle.load(open(filename, 'rb')) + Final_model_loaded_unc = pickle.load(open(UNC_filename, 'rb')) + + # Get training data model performance to tune hyperparameters + yt_pred = Final_model_loaded.predict(X_train) + + yt_pred = [0 if x < 0 else x for x in yt_pred] + O_r2_train = sklearn.metrics.r2_score(y_train, yt_pred) + O_rmse_train = sklearn.metrics.mean_squared_error(y_train, yt_pred, squared = False) + + # predict X_test + y_pred = Final_model_loaded.predict(X_test) + + y_pred = [0 if x < 0 else x for x in y_pred] + O_r2_test = sklearn.metrics.r2_score(y_test, y_pred) + O_rmse_test = sklearn.metrics.mean_squared_error(y_test, y_pred, squared = False) + + + #Predict using uncertainties + Uy_pred = Final_model_loaded_unc.get_prediction(X_test) + Uy_pred = Uy_pred.summary_frame() + print(Uy_pred) + lower = np.array(Uy_pred['mean_ci_lower']) + #cannot have values below zero + lower = [0 if x < 0 else x for x in lower] + + upper = np.array(Uy_pred['mean_ci_upper']) + + #plot the predictions + PerfDF=pd.DataFrame(list(zip(y_test, y_pred)), columns=['y_test', 'y_pred']) + PerfDF['y_pred_lower'] = lower + PerfDF['y_pred_upper'] = upper + + + + + #Add indoor demands + Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec'] + if month in Indoor: + PerfDF['y_test_tot']=PerfDF['y_test'] + PerfDF['y_pred_tot']=PerfDF['y_pred'] + else: + PerfDF['y_test_tot']=PerfDF['y_test']+list(self.I_mean_test) + PerfDF['y_pred_tot']=PerfDF['y_pred']+list(self.Cons_mean_test) + PerfDF['y_pred_lower_tot']=PerfDF['y_pred_lower']+list(self.Cons_mean_test) + PerfDF['y_pred_upper_tot']=PerfDF['y_pred_upper']+list(self.Cons_mean_test) + + T_r2 = sklearn.metrics.r2_score(PerfDF['y_test_tot'], PerfDF['y_pred_tot']) + T_rmse= sklearn.metrics.mean_squared_error(PerfDF['y_test_tot'], PerfDF['y_pred_tot'], + squared = False) + + + PerfDF['Year'] = list(self.slc_test['Jul'].index) + PerfDF=PerfDF.set_index('Year') + + + datetime_object = datetime.datetime.strptime(month, "%b") + PerfDF['month'] = datetime_object.month + PerfDF['Year']=PerfDF.index + + + #set up dates so all months can be combined and sorted + day=[] + for index, row in PerfDF.iterrows(): + day.append(calendar.monthrange(int(row['Year']), int(row['month']))[1]) + + PerfDF['Day']=day + + PerfDF['Date'] = pd.to_datetime(PerfDF[['Year', 'month', 'Day']]) + + #PerfDF=PerfDF.set_index('Date') + PerfDF=PerfDF.drop(columns=['Year', 'month', 'Day']) + PerfDF=PerfDF.reset_index() + + + params = [snowfeatures, conservation, cor_threshold, colinearity_thresh] + + + + + return X_test, PerfDF, O_rmse_train, O_r2_train ,O_rmse_test, O_r2_test , params, cv_results, cor , Final_model_loaded.coef_ + + + + + #make an optimization function + #put in your parameter dictionary, month of interest, and scoring method (RMSE or R2) + def Demand_Optimization(self, Param_dict, month, scoring ): + print('The automated algorithm automatically optimizes the respective model by looping over input parameters within') + print('the training data. In addiiton, the algorithm checks for colinearity between features, removing the one with') + print('less correlation to the target.') + param_list = [] + performance_list=[] + for i in Param_dict['snowfeatures']: + # print('Snowfeatures is ' + str(i)) + for j in Param_dict['conservation']: + # print('Conservation is ' + str(j)) + for k in Param_dict['cor_threshold']: + # print('Correlation threshold: ', k) + #pbar = ProgressBar() + for l in Param_dict['colinearity_thresh']: + # print('Colinearity threshold: ', l) + X_test_RFE, PerfDF, O_rmse_train,O_r2_train, O_rmse_test, O_r2_test, params, cv_results, cor, coef = self.Outdoor_Demand_Model(self.slc_train, month, self.slc_train_features, self.slc_train_target, self.slc_test_features, + self.slc_test_target, snowfeatures= i, conservation = j, cor_threshold = k, colinearity_thresh = l, cv_splits = 5, + model_type = linear_model.Ridge(fit_intercept = False, alpha=1), + scoring = 'neg_root_mean_squared_error') + param_list.append(params) + if scoring =='R2': + performance_list.append(O_r2_test) + if scoring =='RMSE': + performance_list.append(O_rmse_test) + + + + #take model performances and put into DF so they can be joined and sorted + ParamDF = pd.DataFrame(param_list, columns =list(Param_dict.keys())) + PerfDF = pd.DataFrame(performance_list, columns =[scoring]) + ParamEval = pd.concat([ParamDF, PerfDF], axis=1) + + if scoring =='R2': + ParamEval = ParamEval.sort_values(by=[scoring], ascending = False) + else: + ParamEval = ParamEval.sort_values(by=[scoring]) + + #select the first row of parameters as this is the one that shows the greatest performance + ParamEval=ParamEval.head(1) + + X_test_RFE, PerfDF, O_rmse_train,O_r2_train,O_rmse_test, O_r2_test, params, cv_results, cor, coef = self.Outdoor_Demand_ModelFinal(self.slc_train, month, self.slc_train_features, self.slc_train_target, self.slc_test_features, self.slc_test_target,snowfeatures= list(ParamEval['snowfeatures'])[0] , + conservation = list(ParamEval['conservation'])[0], + cor_threshold = list(ParamEval['cor_threshold'])[0], + colinearity_thresh = list(ParamEval['colinearity_thresh'])[0], + cv_splits = 5, model_type = linear_model.Ridge(fit_intercept = False, alpha=1), + scoring = 'neg_root_mean_squared_error') + # model_plots(PerfDF, cv_results, cor, X_test_RFE, coef, scoring, month) + + + + print('The best training parameters are below with their scoring method: ', scoring) + print(ParamEval) + return PerfDF, cv_results, cor, X_test_RFE, coef + + + #Make a function to put all of the predictions together + def Demand_Forecast(self, prediction_dictionary, pdict, df, pred, test, units, plotname, model, predcol, obscol): + FinalDF=pd.DataFrame() + if pdict is True: + print('yes') + for i in prediction_dictionary: + FinalDF=FinalDF.append(prediction_dictionary[i]) + + FinalDF=FinalDF.sort_index() + else: + print('pdict is not used') + FinalDF = df + + #adjust date range to improve figure + FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS') + #FinalDF['Date'] = Conditions + + FinalDF.index = FinalDF['Date'] + del FinalDF['Date'] + + + + plotmin_tot = FinalDF[[pred, test]].min().min() + plotmax_tot = FinalDF[[pred, test]].max().max() + + Xplotmin = FinalDF.index[0]-np.timedelta64(20, 'D') + Xplotmax = FinalDF.index[-1]+np.timedelta64(33, 'D') + + plt.rc_context({ 'xtick.color':'black'}) + fig, ax = plt.subplots(1,6, constrained_layout=True) + fig.set_size_inches(9,3.5) + + gs2 = ax[0].get_gridspec() + # remove the underlying axes + ax[0].remove() + ax[1].remove() + ax[2].remove() + ax[3].remove() + axbig = fig.add_subplot(gs2[:4]) + #axbig.set_title('Total demand Timeline Evaluation') + # axbig.plot(FinalDF[pred], color='orange', label= model) + #axbig.plot(FinalDF[test],color='blue', label='Observed') + axbig.bar(FinalDF.index-np.timedelta64(7, 'D'), FinalDF[pred], color=predcol, label= model ,width = 15, align="center") + axbig.bar(FinalDF.index+np.timedelta64(8, 'D'), FinalDF[test], color=obscol, label= 'Observed',width = 15, align="center") + axbig.set_xlabel('Wet Dry Average \n \n Supply Scenario') + axbig.set_ylim(plotmin_tot-.9,plotmax_tot*1.3) + axbig.set_xlim(Xplotmin, Xplotmax) + axbig.set_ylabel('Demand ('+ units+')') + axbig.legend(loc = 'upper left', facecolor = 'white') + axbig.set_facecolor("white") + axbig.spines['bottom'].set_color('black') + axbig.spines['left'].set_color('black') + axbig.tick_params(axis='both', which='both', length=5, color='red') + axbig.xaxis.set_major_locator(mdates.MonthLocator()) + # Get only the month to show in the x-axis: + axbig.xaxis.set_major_formatter(mdates.DateFormatter('%b')) + + axbig.annotate('A.', (FinalDF.index[-1], plotmax_tot*1.2), size = 14) + xticks = axbig.xaxis.get_major_ticks() + months = [0,5,10,12,17,22,24,29,34] + + xticks = axbig.xaxis.get_major_ticks() + for i,tick in enumerate(xticks): + #if i%5.5 != 0: + if i not in months: + tick.label1.set_visible(False) + + + ax[4].remove() + ax[5].remove() + + + axbig2 = fig.add_subplot(gs2[4:]) + axbig2.scatter(FinalDF[test], FinalDF[pred],color=predcol, alpha=0.5) + axbig2.set_ylabel('Predicted (' + units+')' ) + axbig2.set_xlabel('Observed (' + units+')') + axbig2.set_ylim(plotmin_tot*.95,plotmax_tot*1.2) + axbig2.set_xlim(plotmin_tot*.95,plotmax_tot*1.2) + # axbig2.set_title('Indoor and Outdoor \n Model Performance') + axbig2.plot([plotmin_tot,plotmax_tot],[plotmin_tot,plotmax_tot], color='black', linestyle='--' ) + #axbig2.set_xticks(np.arange(plotmin_tot, plotmax_tot, 100).round()) + #axbig2.set_yticks(np.arange(plotmin_tot, plotmax_tot, 100).round()) + axbig2.set_facecolor("white") + axbig2.spines['bottom'].set_color('black') + axbig2.spines['left'].set_color('black') + axbig2.annotate('B.', (2050,plotmax_tot*1.1), size = 14) + axbig2.set_xticks(np.arange(300, 2301, 500)) + axbig2.set_yticks(np.arange(300, 2301, 500)) + fig.tight_layout(pad=0.5) + + fig.savefig(self.cwd+'/Figures/' +str(plotname)+'.png', dpi = 300) + r2 = sklearn.metrics.r2_score(FinalDF[test], FinalDF[pred]) + MAE= sklearn.metrics.mean_absolute_error(FinalDF[test], FinalDF[pred]) + RMSE= sklearn.metrics.mean_squared_error(FinalDF[test], FinalDF[pred], squared = False) + MAPE=np.mean(np.abs((FinalDF[test]- FinalDF[pred])/FinalDF[test])*100) + + print('Total R2 is ', r2) + print('Total MAE is ', MAE) + print('Total RMSE is ', RMSE) + print('Total MAPE is ', MAPE) + + FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M') + FinalDF.index = FinalDF['Date'] + del FinalDF['Date'] + return FinalDF + + + #Make a function to put all of the predictions together + def Demand_ForecastErr(self, prediction_dictionary, pdict, df, pred, test, units, plotname, model, predcol, obscol): + FinalDF=pd.DataFrame() + if pdict is True: + print('yes') + for i in prediction_dictionary: + FinalDF=FinalDF.append(prediction_dictionary[i]) + + FinalDF=FinalDF.sort_index() + else: + print('pdict is not used') + FinalDF = df + + #adjust date range to improve figure + FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS') + #FinalDF['Date'] = Conditions + + FinalDF.index = FinalDF['Date'] + del FinalDF['Date'] + + #Define Error bars for visualization + FinalDF['UErr'] = FinalDF['y_pred_upper_tot'] - FinalDF['y_pred_tot'] + FinalDF['LErr'] = FinalDF['y_pred_tot'] - FinalDF['y_pred_lower_tot'] + + asymmetric_error = [FinalDF['LErr'], FinalDF['UErr'] ] + + + plotmin_tot = FinalDF[[pred, test]].min().min() + plotmax_tot = FinalDF[[pred, test]].max().max() + + Xplotmin = FinalDF.index[0]-np.timedelta64(20, 'D') + Xplotmax = FinalDF.index[-1]+np.timedelta64(33, 'D') + + plt.rc_context({ 'xtick.color':'black'}) + fig, ax = plt.subplots(1,5, constrained_layout=True) + fig.set_size_inches(10,3.5) + + gs2 = ax[0].get_gridspec() + # remove the underlying axes + ax[0].remove() + ax[1].remove() + ax[2].remove() + axbig = fig.add_subplot(gs2[:3]) + axbig.set_title('Total demand Timeline Evaluation') + #axbig.plot(FinalDF['y_pred_lower_tot'], color='steelblue', label= model) + axbig.plot(FinalDF['y_pred_upper_tot'], color='steelblue', label= model) + axbig.fill_between(FinalDF.index, FinalDF['y_pred_upper_tot'],FinalDF['y_pred_lower_tot'], color = 'steelblue') + axbig.plot(FinalDF[test],color='orange', label='Observed') + axbig.scatter(FinalDF.index, FinalDF['y_pred_tot'], color = 'blue', s = 25) + # axbig.bar(FinalDF.index-np.timedelta64(7, 'D'), FinalDF[pred], color=predcol, + # yerr = asymmetric_error, + # label= model ,width = 15, align="center") + #axbig.bar(FinalDF.index+np.timedelta64(8, 'D'), FinalDF[test], color=obscol, label= 'Observed',width = 15, align="center") + + + + + + axbig.set_xlabel('Wet Dry Average \n \n Supply Scenario') + axbig.set_ylim(plotmin_tot-.9,plotmax_tot*1.3) + axbig.set_xlim(Xplotmin, Xplotmax) + axbig.set_ylabel('Demand ('+ units+')') + axbig.legend(loc = 'upper right', facecolor = 'white') + axbig.set_facecolor("white") + axbig.spines['bottom'].set_color('black') + axbig.spines['left'].set_color('black') + axbig.tick_params(axis='both', which='both', length=5, color='red') + axbig.xaxis.set_major_locator(mdates.MonthLocator()) + # Get only the month to show in the x-axis: + axbig.xaxis.set_major_formatter(mdates.DateFormatter('%b')) + + axbig.annotate('A.', (FinalDF.index[-1], plotmax_tot*1.2), size = 14) + xticks = axbig.xaxis.get_major_ticks() + months = [0,5,10,12,17,22,24,29,34] + + xticks = axbig.xaxis.get_major_ticks() + for i,tick in enumerate(xticks): + #if i%5.5 != 0: + if i not in months: + tick.label1.set_visible(False) + + + ax[3].remove() + ax[4].remove() + + + axbig2 = fig.add_subplot(gs2[3:]) + axbig2.errorbar(FinalDF[test], FinalDF[pred], yerr = asymmetric_error, fmt='.k', ecolor = 'steelblue', mec = 'blue') + axbig2.set_ylabel('Predicted (' + units+')' ) + axbig2.set_xlabel('Observed (' + units+')') + axbig2.set_ylim(plotmin_tot*.95,plotmax_tot*1.2) + axbig2.set_xlim(plotmin_tot*.95,plotmax_tot*1.2) + # axbig2.set_title('Indoor and Outdoor \n Model Performance') + axbig2.plot([plotmin_tot,plotmax_tot],[plotmin_tot,plotmax_tot], color='black', linestyle='--' ) + #axbig2.set_xticks(np.arange(plotmin_tot, plotmax_tot, 100).round()) + #axbig2.set_yticks(np.arange(plotmin_tot, plotmax_tot, 100).round()) + axbig2.set_facecolor("white") + axbig2.spines['bottom'].set_color('black') + axbig2.spines['left'].set_color('black') + axbig2.annotate('B.', (2050,plotmax_tot*1.1), size = 14) + axbig2.set_xticks(np.arange(300, 2301, 500)) + axbig2.set_yticks(np.arange(300, 2301, 500)) + + fig.tight_layout(pad=0.5) + + fig.savefig(self.cwd + '/Figures/' +str(plotname)+'bar.png', dpi = 300) + r2 = sklearn.metrics.r2_score(FinalDF[test], FinalDF[pred]) + MAE= sklearn.metrics.mean_absolute_error(FinalDF[test], FinalDF[pred]) + RMSE= sklearn.metrics.mean_squared_error(FinalDF[test], FinalDF[pred], squared = False) + MAPE=np.mean(np.abs((FinalDF[test]- FinalDF[pred])/FinalDF[test])*100) + + print('Total R2 is ', r2) + print('Total MAE is ', MAE) + print('Total RMSE is ', RMSE) + print('Total MAPE is ', MAPE) + + FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M') + FinalDF.index = FinalDF['Date'] + del FinalDF['Date'] + return FinalDF + + + + + + + def gradientbars_sliced(self, bars): + ax = bars[0].axes + xmin, xmax = ax.get_xlim() + ymin, ymax = ax.get_ylim() + for bar in bars: + bar.set_zorder(1) + bar.set_facecolor("none") + x, y = bar.get_xy() + w, h = bar.get_width(), bar.get_height() + grad = np.linspace(y, y + h, 256).reshape(256, 1) + ax.imshow(grad, extent=[x, x + w, y, y + h], aspect="auto", zorder=0, origin='lower', + vmin= - max(np.abs(ymin), ymax), vmax=max(np.abs(ymin), ymax), cmap='Spectral') + ax.axis([xmin, xmax, ymin, ymax]) + + + + def model_plots(self, PerfDF, cv_results,cor, X_test_RFE, coef, scoring, month): + + plotmin = PerfDF[['y_pred', 'y_test']].min().min() + plotmax = PerfDF[['y_pred', 'y_test']].max().max() + + plotmin_tot = PerfDF[['y_pred_tot', 'y_test_tot']].min().min() + plotmax_tot = PerfDF[['y_pred_tot', 'y_test_tot']].max().max() + + # plotting cv results + plt.figure(figsize=(12,10)) + sns.heatmap(cor, annot=True, cmap=plt.cm.Reds) + plt.savefig('C:/Users/rjohnson18/Box/Dissertation/Paper1/Figs/' + month + '_corMatrix.pdf') + plt.show() + + fig, ax = plt.subplots(3,3, constrained_layout=True) + fig.set_size_inches(9,10) + + + ax[0,0].plot(cv_results["param_n_features_to_select"], cv_results["mean_test_score"]) + ax[0,0].plot(cv_results["param_n_features_to_select"], cv_results["mean_train_score"]) + ax[0,0].set_xlabel('number of features') + ax[0,0].set_ylabel(scoring) + ax[0,0].set_title("Optimal Number of Features") + ax[0,0].legend(['test score', 'train score'], loc='upper left') + ax[0,0].spines['bottom'].set_color('black') + ax[0,0].spines['left'].set_color('black') + + ax[0,1].scatter(PerfDF['y_test'], PerfDF['y_pred'],color='blue', alpha=0.5) + ax[0,1].set_ylabel('Predicted') + ax[0,1].set_xlabel('Observed') + ax[0,1].set_ylim(plotmin-5,plotmax+5) + ax[0,1].set_xlim(plotmin-5,plotmax+5) + ax[0,1].set_title('Outdoor Model Performance') + ax[0,1].plot([plotmin,plotmax],[plotmin,plotmax], color='red', linestyle='--' ) + ax[0,1].spines['bottom'].set_color('black') + ax[0,1].spines['left'].set_color('black') + + ax[0,2].scatter(PerfDF['y_test_tot'], PerfDF['y_pred_tot'],color='blue', alpha=0.5) + ax[0,2].set_ylabel('Predicted') + ax[0,2].set_xlabel('Observed') + ax[0,2].set_ylim(plotmin_tot-5,plotmax_tot+5) + ax[0,2].set_xlim(plotmin_tot-5,plotmax_tot+5) + ax[0,2].set_title('Indoor and Outdoor \n Model Performance') + ax[0,2].plot([plotmin_tot,plotmax_tot],[plotmin_tot,plotmax_tot], color='red', linestyle='--' ) + ax[0,2].spines['bottom'].set_color('black') + ax[0,2].spines['left'].set_color('black') + + + + + gs = ax[1, 1].get_gridspec() + # remove the underlying axes + ax[1,0].remove() + ax[1,1].remove() + ax[1,2].remove() + + PerfDF['Error'] = (PerfDF['y_pred']-PerfDF['y_test']) + axbig1 = fig.add_subplot(gs[1, :]) + axbig1.set_title(month+' Outdoor demand Timeline Evaluation') + axbig1.axhline(y = 0 , color = 'black') + #axbig1.bar(PerfDF.index, PerfDF['y_pred'], color='orange', label='Predicted') + Error1 = axbig1.bar(PerfDF.index, PerfDF['Error'],color='blue', label='Prediction Error') + axbig1.set_xlabel('Year') + axbig1.set_ylabel('Error (GPCD)') + axbig1.spines['bottom'].set_color('black') + axbig1.spines['left'].set_color('black') + gradientbars_sliced(Error1) + + + gs2 = ax[2, 1].get_gridspec() + # remove the underlying axes + ax[2,0].remove() + ax[2,1].remove() + ax[2,2].remove() + + #create error value + PerfDF['Error_tot'] = (PerfDF['y_pred_tot']-PerfDF['y_test_tot']) + + axbig2 = fig.add_subplot(gs2[2, :]) + axbig2.set_title(month+' Total Demand Error Timeline Evaluation') + Error2 = axbig2.bar(PerfDF.index, PerfDF['Error_tot'], color='blue', label='Predicted') + axbig2.axhline(y = 0 , color = 'black') + #axbig2.bar(PerfDF.index, PerfDF['y_test_tot'],color='blue', label='Observed') + axbig2.set_xlabel('Year') + axbig2.set_ylabel('Error (GPCD)') + axbig2.spines['bottom'].set_color('black') + axbig2.spines['left'].set_color('black') + gradientbars_sliced(Error2) + + fig.suptitle(month+ ' Evaluation', size = 16) + fig.savefig('C:/Users/rjohnson18/Box/Dissertation/Paper1/Figs/' + month + '_demand.pdf') + + O_r2 = sklearn.metrics.r2_score(PerfDF['y_test'],PerfDF['y_pred']) + O_rmse= sklearn.metrics.mean_squared_error(PerfDF['y_test'],PerfDF['y_pred'], squared = False) + O_mae= sklearn.metrics.mean_absolute_error(PerfDF['y_test'],PerfDF['y_pred']) + O_mape= sklearn.metrics.mean_absolute_percentage_error(PerfDF['y_test'],PerfDF['y_pred']) + + T_r2 = sklearn.metrics.r2_score(PerfDF['y_test_tot'],PerfDF['y_pred_tot']) + T_rmse= sklearn.metrics.mean_squared_error(PerfDF['y_test_tot'],PerfDF['y_pred_tot'], squared = False) + T_mae= sklearn.metrics.mean_absolute_error(PerfDF['y_test_tot'],PerfDF['y_pred_tot']) + T_mape= sklearn.metrics.mean_absolute_percentage_error(PerfDF['y_test_tot'],PerfDF['y_pred_tot']) + + print('The outdoor Demand prediction RMSE is ', O_rmse) + print('The outdoor Demand prediction R2 is ', O_r2) + + print('The Total Demand prediction RMSE is ', T_rmse) + print('The Total Demand prediction R2 is ', T_r2) + print('The Total Demand prediction MAE is ', T_mae) + print('The Total Demand prediction MAPE is ', T_mape, '%') + + print('The final set of features for ' + month + ' are', list(X_test_RFE.columns)) + print('The coefficients for each feature are', coef) + #set DF up so that all months can be easily combined, basically year-month index + + + + + #need to make predictions with model + def Prediction(self, Forecast_data, IndoorDemand, units, Season, population,pred_name, save_fig): + self.units = units + self.Season = Season, + self.population = population + self.pred_name = pred_name + self.save_fig = save_fig + + outdoor_months = ['Apr', 'May', 'Jun', 'Jul','Aug', 'Sep','Oct'] + Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec'] + All_months = ['Jan', 'Feb', 'Mar','Apr', 'May', 'Jun', 'Jul','Aug', 'Sep','Oct', 'Nov', 'Dec'] + + self.Forecast=copy.deepcopy(Forecast_data) + + #CSD-WDM has a unique model for each month + for month in All_months: + + if month in outdoor_months: + #load optimized features and models + #filepaths + featurefile = self.cwd + '/Models/Features/' + month + '_features.pkl' + modelfile = self.cwd+ '/Models/' + month + '_demand_model.sav' + UNC_filename = self.cwd+ '/Models/' + month + '_demand_model_unc.sav' + + #Loading + features = pickle.load(open(featurefile, 'rb')) + model = pickle.load(open(modelfile, 'rb')) + model_unc = pickle.load(open(UNC_filename, 'rb')) + + #select only RFE features for model prediction + Forecast_data = self.Forecast[month][features] + + + #Predict + #Deterministic + y_pred = model.predict(Forecast_data) + + #Using uncertainties + Uy_pred = model_unc.get_prediction(Forecast_data) + Uy_pred = Uy_pred.summary_frame() + #print(Uy_pred) + lower = np.array(Uy_pred['mean_ci_lower']) + + #cannot have values below zero + lower = [0 if x < 0 else x for x in lower] + + upper = np.array(Uy_pred['mean_ci_upper']) + + #put in dataframe + PerfDF=pd.DataFrame(list(y_pred), columns=['y_pred']) + PerfDF['y_pred_lower'] = lower + PerfDF['y_pred_upper'] = upper + + #Add indoor demands + if month in Indoor: + Forecast_data = self.Forecast[month] + Ind_dem_list = [IndoorDemand]*len(Forecast_data) + PerfDF=pd.DataFrame(Ind_dem_list, columns=['y_pred_tot']) + PerfDF['y_pred_lower_tot'] = PerfDF['y_pred_tot'] + PerfDF['y_pred_upper_tot'] = PerfDF['y_pred_tot'] + else: + PerfDF['y_pred_tot']=PerfDF['y_pred']+IndoorDemand + PerfDF['y_pred_lower_tot']=PerfDF['y_pred_lower']+IndoorDemand + PerfDF['y_pred_upper_tot']=PerfDF['y_pred_upper']+IndoorDemand + + PerfDF['Year'] = list(Forecast_data.index) + PerfDF=PerfDF.set_index('Year') + + + datetime_object = datetime.datetime.strptime(month, "%b") + PerfDF['month'] = datetime_object.month + PerfDF['Year']=PerfDF.index + + + #set up dates so all months can be combined and sorted + day=[] + for index, row in PerfDF.iterrows(): + day.append(calendar.monthrange(int(row['Year']), int(row['month']))[1]) + + PerfDF['Day']=day + + PerfDF['Date'] = pd.to_datetime(PerfDF[['Year', 'month', 'Day']]) + + #PerfDF=PerfDF.set_index('Date') + PerfDF=PerfDF.drop(columns=['Year', 'month', 'Day']) + PerfDF=PerfDF.reset_index() + + colrem = Forecast_data.columns + self.Forecast[month] = self.Forecast[month].reset_index(drop=True) + self.Forecast[month] = pd.concat([self.Forecast[month], PerfDF], axis=1, join="inner") + self.Forecast[month] = self.Forecast[month].set_index('Date') + self.Forecast[month] = self.Forecast[month].drop(columns=colrem) + + print('Predictions complete, displaying results results') + print('CSDWDM demand estimates based in user input conditions complete, access results with CSDWDM.Forecast and/or CSDWDM.SeasonDF') + self.Season_Demand() + #make a plot of predictions + self.Demand_Plot('y_pred_tot', 'CSD_WDM_Err','CSD-WDM ') + + #Make a function to put all of the predictions together + def Demand_Plot(self, pred, plotname, model): + FinalDF=pd.DataFrame() + + #Extract predictions + pred_list = ['y_pred_tot', 'y_pred_lower_tot', 'y_pred_upper_tot'] + + for i in self.Forecast: + preds = self.Forecast[i][pred_list] + FinalDF=FinalDF.append(preds) + FinalDF=FinalDF.sort_index() + + + #adjust date range to improve figure + FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2017,12,1), freq='MS') + #FinalDF['Date'] = Conditions + + FinalDF.index = FinalDF['Date'] + del FinalDF['Date'] + + #Define Error bars for visualization + FinalDF['UErr'] = FinalDF['y_pred_upper_tot'] - FinalDF['y_pred_tot'] + FinalDF['LErr'] = FinalDF['y_pred_tot'] - FinalDF['y_pred_lower_tot'] + + asymmetric_error = [FinalDF['LErr'], FinalDF['UErr'] ] + + + plotmin_tot = FinalDF['y_pred_lower_tot'].min()*.3 + plotmax_tot = FinalDF['y_pred_upper_tot'].max()*1.3 + + Xplotmin = FinalDF.index[0]-np.timedelta64(20, 'D') + Xplotmax = FinalDF.index[-1]+np.timedelta64(33, 'D') + + plt.rc_context({ 'xtick.color':'black'}) + fig, ax = plt.subplots(1,4, constrained_layout=True) + fig.set_size_inches(7,3.5) + + gs2 = ax[0].get_gridspec() + # remove the underlying axes + ax[0].remove() + ax[1].remove() + ax[2].remove() + ax[3].remove() + axbig = fig.add_subplot(gs2[:4]) + #axbig.set_title('Total demand Timeline Evaluation') + #axbig.plot(FinalDF['y_pred_lower_tot'], color='steelblue', label= model) + #axbig.plot(FinalDF['y_pred_upper_tot'], color='steelblue', label= model) + #axbig.fill_between(FinalDF.index, FinalDF['y_pred_upper_tot'],FinalDF['y_pred_lower_tot'], color = 'steelblue') + #axbig.plot(FinalDF[test],color='orange', label='Observed') + #axbig.scatter(FinalDF.index, FinalDF['y_pred_tot'], color = 'blue', s = 25) + axbig.bar(FinalDF.index-np.timedelta64(7, 'D'), FinalDF[pred], + yerr = asymmetric_error, capsize = 4, + label= model ,width = 15, align="center", color='blue' ) + # axbig.bar(FinalDF.index+np.timedelta64(8, 'D'), FinalDF[test], color=obscol, label= 'Observed',width = 15, align="center") + + + + + + axbig.set_xlabel('Wet Dry Average \n \n Supply Scenario') + axbig.set_ylim(plotmin_tot-.9,plotmax_tot*1.3) + axbig.set_xlim(Xplotmin, Xplotmax) + axbig.set_ylabel('Demand ('+ self.units+')') + axbig.legend(loc = 'upper left', facecolor = 'white') + axbig.set_facecolor("white") + axbig.spines['bottom'].set_color('black') + axbig.spines['left'].set_color('black') + axbig.tick_params(axis='both', which='both', length=5, color='red') + axbig.xaxis.set_major_locator(mdates.MonthLocator()) + # Get only the month to show in the x-axis: + axbig.xaxis.set_major_formatter(mdates.DateFormatter('%b')) + + #axbig.annotate('A.', (FinalDF.index[-1], plotmax_tot*1.2), size = 14) + xticks = axbig.xaxis.get_major_ticks() + months = [0,5,10,12,17,22,24,29,34] + + xticks = axbig.xaxis.get_major_ticks() + for i,tick in enumerate(xticks): + #if i%5.5 != 0: + if i not in months: + tick.label1.set_visible(False) + + + FinalDF['Date']= pd.date_range(start=pd.datetime(2015,1,1),end=pd.datetime(2018,1,1), freq='M') + FinalDF.index = FinalDF['Date'] + del FinalDF['Date'] + self.FinalDF = FinalDF + + if self.save_fig == True: + print('Saving results in prediction folder') + fig.savefig(self.cwd + '/Predictions/' + self.pred_name+ '.png', dpi=500) + + + #create a function to inform cumulative demand + def Season_Demand(self): + self.gal_2_AF = 3.06889e-6 + self.SeasonDF = pd.DataFrame() + for month in self.Season[0]: + #convert month to number and get days + month_num = strptime(month,'%b').tm_mon + days = monthrange(2022,month_num )[1] + + month_lab = month + '_dem' + self.SeasonDF[month_lab] = self.Forecast[month]['y_pred_tot'].values * days * self.population * self.gal_2_AF + + #Determine the season sum + self.SeasonDF['Season_dem'] = self.SeasonDF.sum(axis =1) + print(self.SeasonDF) + + + + + #Need to make a scenario generator to run simulations through CSDWDM + + def ScenarioGenerator(self, Testing_df, supply_beg, supply_end, supply_step, climate_beg, climate_end, climate_step, indoordemand, Season, population, predname, save_results): + + #make range of values to add to scenarios + self.supplyrange = list(map(str, list(np.arange(supply_beg, supply_end, supply_step)))) + self.climaterange = list(map(str,list(np.arange(climate_beg, climate_end, climate_step)))) + + print('Making a total of ', len(self.supplyrange)*len(self.climaterange), ' climate and supply scenarios based in user inputs') + + + self.indoordemand = indoordemand + self.Season = Season + self.population = population + self.predname = predname + self.save_results = save_results + + #This uses the 'average use as a baseline, 2017' + self.Average = copy.deepcopy(Testing_df) + for month in Season: + self.Average[month] = pd.concat([self.Average[month].iloc[-1:]]*len(self.supplyrange)) + self.Average[month]['Supply_Range_%'] = self.supplyrange + + + # initialize dictionary + self.Scenarios = {} + + # iterating through the elements of list + for climate in self.climaterange: + self.Scenarios[climate] = copy.deepcopy(self.Average) + + for climate in self.climaterange: + for month in self.Season: + self.Scenarios[climate][month]['climate'] = float(climate) + #get list of columns with key words + temp_keyword = 'temp' + temp_Key_cols = [col for col in self.Scenarios[climate][month].columns if temp_keyword in col] + for temp_col in temp_Key_cols: + self.Scenarios[climate][month][temp_col] = self.Scenarios[climate][month][temp_col]+ self.Scenarios[climate][month]['climate'] + + Supply_keyword = 'AcFt' + Supply_Key_cols = [col for col in self.Scenarios[climate][month].columns if Supply_keyword in col] + for sup_col in Supply_Key_cols: + self.Scenarios[climate][month][sup_col] = self.Scenarios[climate][month][sup_col] * ((self.Scenarios[climate][month]['Supply_Range_%'].astype(float)+100)/100) + + print('Scenario generation complete') + #make a prediction on scenarios + print('Using the CSD-WDM to make predictions on generated climate and supply scenarios') + self.ScenarioPrediction() + print('Predictions complete, now calculating the seasonal demands based as a function of ', ', '.join(self.Season), ', and a population of ', self.population) + self.Season_Demand_Totals() + print('Scenario generation and simulation complte, below are the resulting season demand estimates from CSD-WDM. To access this data, use CSDWDM.Demand_Matrix, with the climate scenarios as columns and supply scenarios as rows.') + #print(self.Demand_Matrix) + self.Demand_Heatmap() + + #save results + + if self.save_results == True: + print('Saving results in prediction folder') + self.Demand_Matrix.to_excel(self.cwd + '/Predictions/' + self.predname+ '_Demand_Matrix.xlsx') + + + + #Use the CSD-WDM to predict on a dictionary of input features + def ScenarioPrediction(self): + + + self.Simulation=copy.deepcopy(self.Scenarios) + + outdoor_months = ['Apr', 'May', 'Jun', 'Jul','Aug', 'Sep','Oct'] + Indoor=['Jan', 'Feb', 'Mar', 'Nov', 'Dec'] + All_months = ['Jan', 'Feb', 'Mar','Apr', 'May', 'Jun', 'Jul','Aug', 'Sep','Oct', 'Nov', 'Dec'] + + for scenario in self.Simulation.keys(): + + #CSD-WDM has a unique model for each month + for month in All_months: + + if month in outdoor_months: + #load optimized features and models + #filepaths + featurefile = self.cwd + '/Models/Features/' + month + '_features.pkl' + modelfile = self.cwd+ '/Models/' + month + '_demand_model.sav' + UNC_filename = self.cwd+ '/Models/' + month + '_demand_model_unc.sav' + + #Loading + features = pickle.load(open(featurefile, 'rb')) + model = pickle.load(open(modelfile, 'rb')) + model_unc = pickle.load(open(UNC_filename, 'rb')) + + #select only RFE features for model prediction + Forecast_data = self.Simulation[scenario][month][features] + + + #Predict + #Deterministic + y_pred = model.predict(Forecast_data) + + #Using uncertainties + Uy_pred = model_unc.get_prediction(Forecast_data) + Uy_pred = Uy_pred.summary_frame() + #print(Uy_pred) + lower = np.array(Uy_pred['mean_ci_lower']) + + #cannot have values below zero + lower = [0 if x < 0 else x for x in lower] + + upper = np.array(Uy_pred['mean_ci_upper']) + + #put in dataframe + PerfDF=pd.DataFrame(list(y_pred), columns=['y_pred']) + PerfDF['y_pred_lower'] = lower + PerfDF['y_pred_upper'] = upper + + #Add indoor demands + if month in Indoor: + Forecast_data = self.Simulation[scenario][month] + Ind_dem_list = [self.indoordemand]*len(Forecast_data) + PerfDF=pd.DataFrame(Ind_dem_list, columns=['y_pred_tot']) + PerfDF['y_pred_lower_tot'] = PerfDF['y_pred_tot'] + PerfDF['y_pred_upper_tot'] = PerfDF['y_pred_tot'] + else: + PerfDF['y_pred_tot']=PerfDF['y_pred']+self.indoordemand + PerfDF['y_pred_lower_tot']=PerfDF['y_pred_lower']+self.indoordemand + PerfDF['y_pred_upper_tot']=PerfDF['y_pred_upper']+self.indoordemand + + PerfDF['Year'] = list(Forecast_data.index) + PerfDF=PerfDF.set_index('Year') + + + datetime_object = datetime.datetime.strptime(month, "%b") + PerfDF['month'] = datetime_object.month + PerfDF['Year']=PerfDF.index + + + #set up dates so all months can be combined and sorted + day=[] + for index, row in PerfDF.iterrows(): + day.append(calendar.monthrange(int(row['Year']), int(row['month']))[1]) + + PerfDF['Day']=day + + PerfDF['Date'] = pd.to_datetime(PerfDF[['Year', 'month', 'Day']]) + + #PerfDF=PerfDF.set_index('Date') + PerfDF=PerfDF.drop(columns=['Year', 'month', 'Day']) + PerfDF=PerfDF.reset_index() + + colrem = Forecast_data.columns + self.Simulation[scenario][month] = self.Simulation[scenario][month].reset_index(drop=True) + self.Simulation[scenario][month] = pd.concat([self.Simulation[scenario][month], PerfDF], axis=1, join="inner") + self.Simulation[scenario][month] = self.Simulation[scenario][month].set_index('Date') + self.Simulation[scenario][month] = self.Simulation[scenario][month].drop(columns=colrem) + + + + #create a function to inform cumulative demand + def Season_Demand_Totals(self): + self.gal_2_AF = 3.06889e-6 + self.SeasonSimDF = {} + for scenario in self.Simulation.keys(): + self.SeasonSimDF[scenario] = pd.DataFrame() + for month in self.Season: + #convert month to number and get days + month_num = strptime(month,'%b').tm_mon + days = monthrange(2022,month_num )[1] + + month_lab = month + '_dem' + self.SeasonSimDF[scenario][month_lab] = self.Simulation[scenario][month]['y_pred_tot'].values * days * self.population * self.gal_2_AF + + #Determine the season sum + self.SeasonSimDF[scenario]['Season_dem'] = self.SeasonSimDF[scenario].sum(axis =1) + + #put into a matrix for easy lookup/reference + self.DemandMatrix() + + + + def DemandMatrix(self): + self.Demand_Matrix = pd.DataFrame(columns=[self.climaterange], index=[self.supplyrange]) + for climate in self.climaterange: + self.Demand_Matrix[climate] = np.around(self.SeasonSimDF[climate]['Season_dem'].values,-1) + + + + def Demand_Heatmap(self): + + fontsize = 25 + ticksize = 20 + + sns.set(rc = {'figure.figsize':(17,14)}) + sns.color_palette("Spectral", as_cmap=True) + + plt = sns.heatmap(self.Demand_Matrix, annot=True, fmt = 'g',cmap = 'Spectral_r', cbar_kws ={'label':'Demand (AcFt)'}, + annot_kws={"size": 12}) + plt.set_xlabel('Climate Scenario ($^{o}C$)', fontsize = fontsize) + plt.set_ylabel('Supply Scenario (% of average)', fontsize = fontsize) + plt.set_yticklabels(plt.get_ymajorticklabels(),size = ticksize) + plt.set_xticklabels(plt.get_xmajorticklabels(),size = ticksize) + plt.figure.axes[-1].yaxis.label.set_size(fontsize) + + if self.save_results == True: + print('Saving results in prediction folder') + fig = plt.get_figure() + fig.savefig(self.cwd + '/Predictions/' + self.predname + '_Demand_Matrix.png', dpi=500) + + + + + + diff --git a/CSD_WDM_interactive.ipynb b/CSD_WDM_interactive.ipynb new file mode 100644 index 0000000..dae306c --- /dev/null +++ b/CSD_WDM_interactive.ipynb @@ -0,0 +1,918 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pathlib import Path\n", + "import CSD_WDM_OOP as WDM\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "#set path directory\n", + "cwd = os.getcwd()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#Case Study Application of CSD-WDM on the Salt Lake City Department of Public Utilities in Northern Utah, USA\n", + "#Load Training/Testing data\n", + "p = Path(cwd + '/Data/Processed_Training_Data')\n", + "Municipaldata = {i.stem[0:3] : pd.read_excel(i) for i in p.glob('**/*.xlsx')}\n", + "snowdata=pd.read_excel(cwd + '/Data/Alta_LCC_snow.xlsx')\n", + "\n", + "\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", + "#Establish conservation thresholds\n", + "#Duration in years since implementation of conservation goals (depends on municipality)\n", + "Conservation_Duration = 20\n", + "Outdoor_Conservation_rate = 0.25\n", + "Indoor_Conservation_rate = 0.28\n", + "\n", + "#Set up CSD-WDM module\n", + "CSDWDM = WDM.CSDWDM(cwd)\n", + "\n", + "#Process training data (for case use in Salt lake City)\n", + "CSDWDM.SLC_Data_Processing(Municipaldata,snowdata, Outdoor_Conservation_rate, Indoor_Conservation_rate, Conservation_Duration)\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0% | |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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": [ + " 14% |########## |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final features are ['Val_Apr_Monthly_mean_Day_temp_C', 'Val_Apr_Monthly_precip_mm', 'LitCotCrk_AcFt_WR_Apr', 'LitCotCrk_AcFt_WR_Mar']\n", + " OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: Target_gpcd R-squared (uncentered): 0.890\n", + "Model: OLS Adj. R-squared (uncentered): 0.873\n", + "Method: Least Squares F-statistic: 52.42\n", + "Date: Fri, 10 Jun 2022 Prob (F-statistic): 4.51e-12\n", + "Time: 13:36:11 Log-Likelihood: -125.98\n", + "No. Observations: 30 AIC: 260.0\n", + "Df Residuals: 26 BIC: 265.6\n", + "Df Model: 4 \n", + "Covariance Type: nonrobust \n", + "===================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------------\n", + "Val_Apr_Monthly_mean_Day_temp_C 5.6739 1.423 3.988 0.000 2.750 8.598\n", + "Val_Apr_Monthly_precip_mm -0.3083 0.091 -3.403 0.002 -0.495 -0.122\n", + "LitCotCrk_AcFt_WR_Apr 0.0073 0.005 1.429 0.165 -0.003 0.018\n", + "LitCotCrk_AcFt_WR_Mar -0.0120 0.006 -2.047 0.051 -0.024 5.2e-05\n", + "==============================================================================\n", + "Omnibus: 0.588 Durbin-Watson: 1.496\n", + "Prob(Omnibus): 0.745 Jarque-Bera (JB): 0.641\n", + "Skew: -0.291 Prob(JB): 0.726\n", + "Kurtosis: 2.581 Cond. No. 1.55e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[3] The condition number is large, 1.55e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + " mean mean_se mean_ci_lower mean_ci_upper obs_ci_lower \\\n", + "Year \n", + "2008 19.529015 2.301277 14.798673 24.259356 -16.383501 \n", + "2015 41.320810 10.015243 20.734183 61.907437 0.197315 \n", + "2017 0.366781 7.873727 -15.817896 16.551459 -38.739183 \n", + "\n", + " obs_ci_upper \n", + "Year \n", + "2008 55.441531 \n", + "2015 82.444306 \n", + "2017 39.472746 \n", + "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": [ + " 28% |#################### |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final features are ['Val_May_Monthly_precip_mm', 'Val_May_Monthly_mean_Day_temp_C']\n", + " OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: Target_gpcd R-squared (uncentered): 0.966\n", + "Model: OLS Adj. R-squared (uncentered): 0.963\n", + "Method: Least Squares F-statistic: 396.0\n", + "Date: Fri, 10 Jun 2022 Prob (F-statistic): 2.93e-21\n", + "Time: 13:37:06 Log-Likelihood: -143.30\n", + "No. Observations: 30 AIC: 290.6\n", + "Df Residuals: 28 BIC: 293.4\n", + "Df Model: 2 \n", + "Covariance Type: nonrobust \n", + "===================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------------\n", + "Val_May_Monthly_precip_mm -1.0508 0.144 -7.311 0.000 -1.345 -0.756\n", + "Val_May_Monthly_mean_Day_temp_C 14.2887 0.686 20.821 0.000 12.883 15.695\n", + "==============================================================================\n", + "Omnibus: 2.504 Durbin-Watson: 1.791\n", + "Prob(Omnibus): 0.286 Jarque-Bera (JB): 1.341\n", + "Skew: -0.154 Prob(JB): 0.511\n", + "Kurtosis: 2.011 Cond. No. 9.13\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + " mean mean_se mean_ci_lower mean_ci_upper obs_ci_lower \\\n", + "Year \n", + "2008 126.248484 4.538397 116.951999 135.544969 64.649013 \n", + "2015 39.386196 14.451868 9.782886 68.989506 -28.322195 \n", + "2017 151.272228 5.609640 139.781402 162.763053 89.303612 \n", + "\n", + " obs_ci_upper \n", + "Year \n", + "2008 187.847955 \n", + "2015 107.094587 \n", + "2017 213.240843 \n", + "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" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42% |############################## |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final features are ['Val_Jun_Monthly_precip_mm', 'Val_Apr_Monthly_mean_Day_temp_C', 'Total_snow_in', 'Val_May_Monthly_mean_Day_temp_C']\n", + " OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: Target_gpcd R-squared (uncentered): 0.986\n", + "Model: OLS Adj. R-squared (uncentered): 0.984\n", + "Method: Least Squares F-statistic: 460.1\n", + "Date: Fri, 10 Jun 2022 Prob (F-statistic): 1.03e-23\n", + "Time: 13:38:16 Log-Likelihood: -150.87\n", + "No. Observations: 30 AIC: 309.7\n", + "Df Residuals: 26 BIC: 315.3\n", + "Df Model: 4 \n", + "Covariance Type: nonrobust \n", + "===================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------------\n", + "Val_Jun_Monthly_precip_mm -1.9853 0.321 -6.189 0.000 -2.645 -1.326\n", + "Val_Apr_Monthly_mean_Day_temp_C 8.8988 5.404 1.647 0.112 -2.209 20.007\n", + "Total_snow_in 0.1184 0.059 2.009 0.055 -0.003 0.240\n", + "Val_May_Monthly_mean_Day_temp_C 14.9764 4.592 3.262 0.003 5.538 24.415\n", + "==============================================================================\n", + "Omnibus: 1.882 Durbin-Watson: 2.115\n", + "Prob(Omnibus): 0.390 Jarque-Bera (JB): 1.595\n", + "Skew: 0.427 Prob(JB): 0.450\n", + "Kurtosis: 2.260 Cond. No. 511.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + " mean mean_se mean_ci_lower mean_ci_upper obs_ci_lower \\\n", + "Year \n", + "2008 254.089758 19.025383 214.982524 293.196992 163.575060 \n", + "2015 258.924102 15.043521 228.001702 289.846501 171.633039 \n", + "2017 282.112409 23.114831 234.599193 329.625625 187.661149 \n", + "\n", + " obs_ci_upper \n", + "Year \n", + "2008 344.604456 \n", + "2015 346.215165 \n", + "2017 376.563669 \n", + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "136 True False 0.4 0.85 17.425846\n", + "The model is automatically selecting features and calibrating the Jul 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": [ + " 57% |######################################### |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final features are ['UrbPopulationDensity', 'Val_Jul_Monthly_mean_Day_temp_C', 'Val_Apr_Monthly_mean_Day_temp_C', 'Val_May_Monthly_mean_Day_temp_C']\n", + " OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: Target_gpcd R-squared (uncentered): 0.988\n", + "Model: OLS Adj. R-squared (uncentered): 0.986\n", + "Method: Least Squares F-statistic: 522.4\n", + "Date: Fri, 10 Jun 2022 Prob (F-statistic): 2.02e-24\n", + "Time: 13:39:27 Log-Likelihood: -156.68\n", + "No. Observations: 30 AIC: 321.4\n", + "Df Residuals: 26 BIC: 327.0\n", + "Df Model: 4 \n", + "Covariance Type: nonrobust \n", + "===================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------------\n", + "UrbPopulationDensity -0.0769 0.022 -3.538 0.002 -0.122 -0.032\n", + "Val_Jul_Monthly_mean_Day_temp_C 31.6954 6.407 4.947 0.000 18.525 44.866\n", + "Val_Apr_Monthly_mean_Day_temp_C -4.2770 6.276 -0.681 0.502 -17.178 8.624\n", + "Val_May_Monthly_mean_Day_temp_C 9.6645 6.183 1.563 0.130 -3.046 22.375\n", + "==============================================================================\n", + "Omnibus: 1.375 Durbin-Watson: 1.302\n", + "Prob(Omnibus): 0.503 Jarque-Bera (JB): 1.086\n", + "Skew: -0.231 Prob(JB): 0.581\n", + "Kurtosis: 2.191 Cond. No. 5.95e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[3] The condition number is large, 5.95e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + " mean mean_se mean_ci_lower mean_ci_upper obs_ci_lower \\\n", + "Year \n", + "2008 392.298136 24.633336 341.663589 442.932683 281.041420 \n", + "2015 275.899403 29.661024 214.930296 336.868511 159.574722 \n", + "2017 381.050537 26.890024 325.777301 436.323773 267.607467 \n", + "\n", + " obs_ci_upper \n", + "Year \n", + "2008 503.554852 \n", + "2015 392.224085 \n", + "2017 494.493607 \n", + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "283 False False 0.25 0.7 18.99765\n", + "The model is automatically selecting features and calibrating the Aug 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": [ + " 71% |################################################### |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final features are ['Val_Aug_Monthly_precip_mm', 'UrbPopulationDensity', 'LitCotCrk_AcFt_WR_Apr', 'Val_Apr_Monthly_mean_Day_temp_C', 'Val_Aug_Monthly_mean_Day_temp_C', 'LitCotCrk_AcFt_WR_Mar', 'Val_Apr_Monthly_precip_mm', 'Val_May_Monthly_mean_Day_temp_C', 'Val_Jul_Monthly_mean_Day_temp_C', 'Val_Jun_Monthly_mean_Day_temp_C', 'Val_Jun_Monthly_precip_mm', 'BigCotCrk_AcFt_WR_May', 'LitCotCrk_AcFt_WR_May']\n", + " OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: Target_gpcd R-squared (uncentered): 0.997\n", + "Model: OLS Adj. R-squared (uncentered): 0.995\n", + "Method: Least Squares F-statistic: 424.9\n", + "Date: Fri, 10 Jun 2022 Prob (F-statistic): 1.09e-18\n", + "Time: 13:40:56 Log-Likelihood: -133.17\n", + "No. Observations: 30 AIC: 292.3\n", + "Df Residuals: 17 BIC: 310.6\n", + "Df Model: 13 \n", + "Covariance Type: nonrobust \n", + "===================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------------\n", + "Val_Aug_Monthly_precip_mm -1.8261 0.319 -5.724 0.000 -2.499 -1.153\n", + "UrbPopulationDensity -0.0313 0.016 -1.984 0.064 -0.065 0.002\n", + "LitCotCrk_AcFt_WR_Apr 0.0070 0.013 0.559 0.584 -0.020 0.034\n", + "Val_Apr_Monthly_mean_Day_temp_C 6.0210 6.911 0.871 0.396 -8.559 20.601\n", + "Val_Aug_Monthly_mean_Day_temp_C 15.6568 5.399 2.900 0.010 4.266 27.047\n", + "LitCotCrk_AcFt_WR_Mar 0.0096 0.015 0.659 0.519 -0.021 0.040\n", + "Val_Apr_Monthly_precip_mm -0.2877 0.253 -1.136 0.272 -0.822 0.246\n", + "Val_May_Monthly_mean_Day_temp_C 12.1470 6.661 1.823 0.086 -1.907 26.201\n", + "Val_Jul_Monthly_mean_Day_temp_C 0.9390 5.532 0.170 0.867 -10.732 12.610\n", + "Val_Jun_Monthly_mean_Day_temp_C 0.8265 6.173 0.134 0.895 -12.198 13.851\n", + "Val_Jun_Monthly_precip_mm 0.4139 0.336 1.232 0.235 -0.295 1.123\n", + "BigCotCrk_AcFt_WR_May 0.0141 0.003 4.159 0.001 0.007 0.021\n", + "LitCotCrk_AcFt_WR_May -0.0239 0.005 -4.781 0.000 -0.035 -0.013\n", + "==============================================================================\n", + "Omnibus: 7.473 Durbin-Watson: 1.828\n", + "Prob(Omnibus): 0.024 Jarque-Bera (JB): 5.818\n", + "Skew: -0.851 Prob(JB): 0.0545\n", + "Kurtosis: 4.326 Cond. No. 3.77e+04\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[3] The condition number is large, 3.77e+04. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + " mean mean_se mean_ci_lower mean_ci_upper obs_ci_lower \\\n", + "Year \n", + "2008 387.049874 30.064129 323.620106 450.479642 301.477643 \n", + "2015 240.574230 33.360129 170.190510 310.957951 149.727440 \n", + "2017 212.971075 40.267376 128.014338 297.927812 110.419048 \n", + "\n", + " obs_ci_upper \n", + "Year \n", + "2008 472.622105 \n", + "2015 331.421020 \n", + "2017 315.523102 \n", + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "255 False False 0.0 0.8 37.759604\n", + "The model is automatically selecting features and calibrating the Sep 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": [ + " 85% |############################################################# |\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final features are ['Val_Sep_Monthly_precip_mm', 'Val_Sep_Monthly_mean_Day_temp_C', 'Val_Aug_Monthly_mean_Day_temp_C', 'Val_May_Monthly_mean_Day_temp_C', 'Val_Apr_Monthly_mean_Day_temp_C', 'Val_Jun_Monthly_mean_Day_temp_C', 'Val_Jul_Monthly_mean_Day_temp_C']\n", + " OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: Target_gpcd R-squared (uncentered): 0.989\n", + "Model: OLS Adj. R-squared (uncentered): 0.985\n", + "Method: Least Squares F-statistic: 292.0\n", + "Date: Fri, 10 Jun 2022 Prob (F-statistic): 6.38e-21\n", + "Time: 13:42:20 Log-Likelihood: -139.05\n", + "No. Observations: 30 AIC: 292.1\n", + "Df Residuals: 23 BIC: 301.9\n", + "Df Model: 7 \n", + "Covariance Type: nonrobust \n", + "===================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------------\n", + "Val_Sep_Monthly_precip_mm -0.9601 0.192 -4.991 0.000 -1.358 -0.562\n", + "Val_Sep_Monthly_mean_Day_temp_C 8.1203 4.372 1.857 0.076 -0.924 17.164\n", + "Val_Aug_Monthly_mean_Day_temp_C 12.2602 4.642 2.641 0.015 2.657 21.864\n", + "Val_May_Monthly_mean_Day_temp_C 3.3190 3.966 0.837 0.411 -4.885 11.523\n", + "Val_Apr_Monthly_mean_Day_temp_C 3.1277 3.945 0.793 0.436 -5.033 11.288\n", + "Val_Jun_Monthly_mean_Day_temp_C -3.9832 4.512 -0.883 0.387 -13.318 5.352\n", + "Val_Jul_Monthly_mean_Day_temp_C -7.5345 3.806 -1.980 0.060 -15.408 0.339\n", + "==============================================================================\n", + "Omnibus: 0.587 Durbin-Watson: 1.809\n", + "Prob(Omnibus): 0.745 Jarque-Bera (JB): 0.452\n", + "Skew: 0.283 Prob(JB): 0.798\n", + "Kurtosis: 2.798 Cond. No. 78.7\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + " mean mean_se mean_ci_lower mean_ci_upper obs_ci_lower \\\n", + "Year \n", + "2008 204.668055 15.490260 172.624009 236.712100 137.621468 \n", + "2015 227.921904 23.350284 179.618162 276.225646 151.753174 \n", + "2017 161.778130 19.782029 120.855884 202.700375 90.063040 \n", + "\n", + " obs_ci_upper \n", + "Year \n", + "2008 271.714642 \n", + "2015 304.090634 \n", + "2017 233.493220 \n", + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "261 False False 0.05 0.8 11.65712\n", + "The model is automatically selecting features and calibrating the Oct 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": [ + "100% |########################################################################|\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final features are ['Val_Oct_Monthly_mean_Day_temp_C', 'Val_Apr_Monthly_mean_Day_temp_C', 'Val_May_Monthly_mean_Day_temp_C']\n", + " OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: Target_gpcd R-squared (uncentered): 0.852\n", + "Model: OLS Adj. R-squared (uncentered): 0.835\n", + "Method: Least Squares F-statistic: 51.66\n", + "Date: Fri, 10 Jun 2022 Prob (F-statistic): 2.57e-11\n", + "Time: 13:44:11 Log-Likelihood: -148.21\n", + "No. Observations: 30 AIC: 302.4\n", + "Df Residuals: 27 BIC: 306.6\n", + "Df Model: 3 \n", + "Covariance Type: nonrobust \n", + "===================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------------\n", + "Val_Oct_Monthly_mean_Day_temp_C 5.7781 2.914 1.983 0.058 -0.200 11.756\n", + "Val_Apr_Monthly_mean_Day_temp_C 4.2928 4.313 0.995 0.328 -4.557 13.143\n", + "Val_May_Monthly_mean_Day_temp_C -2.1013 3.453 -0.609 0.548 -9.185 4.983\n", + "==============================================================================\n", + "Omnibus: 2.119 Durbin-Watson: 1.779\n", + "Prob(Omnibus): 0.347 Jarque-Bera (JB): 1.915\n", + "Skew: 0.560 Prob(JB): 0.384\n", + "Kurtosis: 2.472 Cond. No. 16.9\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + " mean mean_se mean_ci_lower mean_ci_upper obs_ci_lower \\\n", + "Year \n", + "2008 64.061193 15.086653 33.105937 95.016449 -15.380244 \n", + "2015 91.718008 9.468099 72.291073 111.144944 16.020454 \n", + "2017 71.566406 19.816853 30.905583 112.227229 -12.135545 \n", + "\n", + " obs_ci_upper \n", + "Year \n", + "2008 143.502630 \n", + "2015 167.415563 \n", + "2017 155.268357 \n", + "The best training parameters are below with their scoring method: RMSE\n", + " snowfeatures conservation cor_threshold colinearity_thresh RMSE\n", + "259 False False 0.05 0.7 20.247452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\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", + "\n", + "CSDWDM.CSD_WDM_Train(p_space, Outdoor_Months, IndoorMonths, scoring = 'RMSE')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions complete, displaying results results\n", + "CSDWDM demand estimates based in user input conditions complete, access results with CSDWDM.Forecast and/or CSDWDM.SeasonDF\n", + " Apr_dem May_dem Jun_dem Jul_dem Aug_dem \\\n", + "0 3815.491637 7191.237594 10728.589733 15256.522866 15095.136169 \n", + "1 4451.651413 4550.810089 10862.770627 11825.719864 10648.201943 \n", + "2 3256.468532 7952.289515 11548.397854 14926.841499 9840.590881 \n", + "\n", + " Sep_dem Oct_dem Season_dem \n", + "0 9289.124606 5303.065944 66679.168549 \n", + "1 9961.665080 6136.302759 58437.121775 \n", + "2 8037.810848 5531.688307 61094.087436 \n", + "Saving results in prediction folder\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Set indoor demand estimates\n", + "IndoorDemand = 110\n", + "units = 'gpcd'\n", + "Season = ['Apr', 'May', 'Jun', 'Jul','Aug', 'Sep','Oct']\n", + "population = 320000\n", + "prediction_name = 'Wet_Dry_Average_Climate'\n", + "\n", + "CSDWDM.Prediction(CSDWDM.slc_test, IndoorDemand, units, Season, population, prediction_name, save_fig = True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Making a total of 121 climate and supply scenarios based in user inputs\n", + "Scenario generation complete\n", + "Using the CSD-WDM to make predictions on generated climate and supply scenarios\n", + "Predictions complete, now calculating the seasonal demands based as a function of Apr, May, Jun, Jul, Aug, Sep, Oct , and a population of 320000\n", + "Scenario generation and simulation complte, below are the resulting season demand estimates from CSD-WDM. To access this data, use CSDWDM.Demand_Matrix, with the climate scenarios as columns and supply scenarios as rows.\n", + "Saving results in prediction folder\n", + "Saving results in prediction folder\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Make climate and supply scenarios to run in the tuned CSDWDM\n", + "\n", + "supply_beg =-50 \n", + "supply_end = 60\n", + "supply_step = 10\n", + "climate_beg = -2.5 \n", + "climate_end = 3 \n", + "climate_step = .5\n", + "IndoorDemand = 110\n", + "Season = ['Apr', 'May', 'Jun', 'Jul','Aug', 'Sep','Oct']\n", + "population = 320000\n", + "prediction_name = 'Ave_Sim_Trial'\n", + "\n", + "\n", + "CSDWDM.ScenarioGenerator(CSDWDM.slc_test, supply_beg, supply_end, supply_step, \n", + " climate_beg, climate_end, climate_step, IndoorDemand, \n", + " Season, population, prediction_name, save_results =True)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
-2.5-2.0-1.5-1.0-0.50.00.51.01.52.02.5
-5052380.054480.056580.058680.060770.062870.064970.067060.069160.071260.073360.0
-4052030.054130.056220.058320.060420.062510.064610.066710.068810.070900.073000.0
-3051670.053770.055870.057960.060060.062160.064260.066350.068450.070550.072650.0
-2051320.053410.055510.057610.059710.061800.063900.066000.068100.070190.072290.0
-1050960.053060.055160.057250.059350.061450.063550.065640.067740.069840.071940.0
050610.052700.054800.056900.059000.061090.063190.065290.067390.069480.071580.0
1050250.052350.054450.056540.058640.060740.062840.064930.067030.069130.071230.0
2049900.051990.054090.056190.058290.060380.062480.064580.066680.068770.070870.0
3049540.051640.053740.055830.057930.060030.062130.064220.066320.068420.070520.0
4049190.051280.053380.055480.057580.059670.061770.063870.065970.068060.070160.0
5048830.050930.053030.055120.057220.059320.061420.063510.065610.067710.069800.0
\n", + "
" + ], + "text/plain": [ + " -2.5 -2.0 -1.5 -1.0 -0.5 0.0 0.5 1.0 \\\n", + "-50 52380.0 54480.0 56580.0 58680.0 60770.0 62870.0 64970.0 67060.0 \n", + "-40 52030.0 54130.0 56220.0 58320.0 60420.0 62510.0 64610.0 66710.0 \n", + "-30 51670.0 53770.0 55870.0 57960.0 60060.0 62160.0 64260.0 66350.0 \n", + "-20 51320.0 53410.0 55510.0 57610.0 59710.0 61800.0 63900.0 66000.0 \n", + "-10 50960.0 53060.0 55160.0 57250.0 59350.0 61450.0 63550.0 65640.0 \n", + "0 50610.0 52700.0 54800.0 56900.0 59000.0 61090.0 63190.0 65290.0 \n", + "10 50250.0 52350.0 54450.0 56540.0 58640.0 60740.0 62840.0 64930.0 \n", + "20 49900.0 51990.0 54090.0 56190.0 58290.0 60380.0 62480.0 64580.0 \n", + "30 49540.0 51640.0 53740.0 55830.0 57930.0 60030.0 62130.0 64220.0 \n", + "40 49190.0 51280.0 53380.0 55480.0 57580.0 59670.0 61770.0 63870.0 \n", + "50 48830.0 50930.0 53030.0 55120.0 57220.0 59320.0 61420.0 63510.0 \n", + "\n", + " 1.5 2.0 2.5 \n", + "-50 69160.0 71260.0 73360.0 \n", + "-40 68810.0 70900.0 73000.0 \n", + "-30 68450.0 70550.0 72650.0 \n", + "-20 68100.0 70190.0 72290.0 \n", + "-10 67740.0 69840.0 71940.0 \n", + "0 67390.0 69480.0 71580.0 \n", + "10 67030.0 69130.0 71230.0 \n", + "20 66680.0 68770.0 70870.0 \n", + "30 66320.0 68420.0 70520.0 \n", + "40 65970.0 68060.0 70160.0 \n", + "50 65610.0 67710.0 69800.0 " + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "CSDWDM.Demand_Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}