diff --git a/mgwr/gwr.py b/mgwr/gwr.py index 3862e85..a249f92 100755 --- a/mgwr/gwr.py +++ b/mgwr/gwr.py @@ -1484,7 +1484,8 @@ def _chunk_compute_R(self, chunk_id=0): for i in range(n): wi = self._build_wi(i, self.bw_init).reshape(-1, 1) - if isinstance(self.family, Poisson): + if isinstance(self.family, (Poisson, Binomial)): + #if isinstance(self.family, Poisson): wi=wi.reshape(-1,1) rslt = iwls(self.y, self.X, self.family, self.offset, None, wi=wi) inv_xtx_xt = rslt[5] @@ -1510,7 +1511,9 @@ def _chunk_compute_R(self, chunk_id=0): for i in range(len(chunk_index_Aj)): index = chunk_index_Aj[i] wi = self._build_wi(index, self.bws_history[iter_i, j]) - if isinstance(self.family, Poisson): + + if isinstance(self.family, (Poisson, Binomial)): + #if isinstance(self.family, Poisson): Xj = Xj.reshape(-1,1) wi = wi.reshape(-1,1) rslt = iwls(self.y, Xj, self.family, self.offset, None, wi=wi) @@ -1559,7 +1562,9 @@ def fit(self, n_chunks=1, pool=None): predy = self.offset*(np.exp(np.sum(self.X * params, axis=1).reshape(-1, 1))) elif isinstance(self.family,Binomial): - predy = 1/(1+np.exp(-1*np.sum(self.X * params, axis=1).reshape(-1, 1))) + #XXB = np.multiply(param, X) + #p = np.exp(XXB) / ( 1 + np.exp (XXB)) + predy = (np.exp(np.sum(self.X * params, axis=1).reshape(-1, 1)))/(1+np.exp(np.sum(self.X * params, axis=1).reshape(-1, 1))) else: predy = np.sum(self.X * params, axis=1).reshape(-1, 1) diff --git a/mgwr/search.py b/mgwr/search.py index c759219..b0dcf45 100755 --- a/mgwr/search.py +++ b/mgwr/search.py @@ -6,7 +6,6 @@ from copy import deepcopy from spglm.family import Gaussian, Binomial, Poisson - def golden_section(a, c, delta, function, tol, max_iter, int_score=False, verbose=False): """ @@ -180,20 +179,17 @@ def multi_bw(init, y, X, n, k, family, offset, tol, max_iter, rss_score, gwr_fun bw_gwr = bw err = optim_model.resid_response.reshape((-1, 1)) param = optim_model.params + old_param=param + ni = np.multiply(param, X) + p = np.exp(ni) / ( 1 + np.exp (ni)) + w = (p)*(1-p) if isinstance(family, Poisson): XB = offset*np.exp(np.multiply(param,X)) + elif isinstance(family, Binomial): - #v = np.multiply(X, param) - #XB = 1 / (1 + np.exp(-1 * v)) - #XB = v + ((1 / (mu * (1 - mu))) * (y - mu)) - m = np.multiply(param, X) - XB = 1 / ( 1 + np.exp (-1 * m)) - #print("XB "+str(XB.shape)) - #mu = 1 / ( 1 + np.exp (-1 * np.multiply (param, X))) - #XB = np.multiply(param, X) - #print(XB.shape) - #XB=np.log(XB/(1-XB)) + XB = ni + ((y - p)/(p*(1-p))) + else: XB = np.multiply(param, X) @@ -215,28 +211,25 @@ def tqdm(x, desc=''): #otherwise, just passthrough the range for iters in tqdm(range(1, max_iter + 1), desc='Backfitting'): new_XB = np.zeros_like(X) + new_p = np.zeros_like(X) + new_ni = np.zeros_like(X) + new_w = np.zeros_like(X) + new_add = np.zeros_like(X) params = np.zeros_like(X) for j in range(k): + temp_y = XB[:,j].reshape((-1, 1)) + if isinstance(family, (Poisson,Gaussian)): + temp_y = temp_y + err - if isinstance(family, Binomial): - ni_old = np.log((XB[:,j])/(1-XB[:,j])) - temp_y = (ni_old + ((optim_model.y.reshape(-1) - XB[:,j].reshape(-1))/XB[:,j].reshape(-1)*(1-XB[:,j].reshape(-1)))).reshape(-1,1) - print(temp_y.shape) - #temp_y = ((XB[:,j] + (y - mu[:,j]))/(mu[:,j] * ( 1 - mu[:,j] ))) - #print(temp_y.shape) - else: - temp_y = XB[:, j].reshape((-1, 1)) - #temp_y = (1 / (1+np.exp((-1*(np.multiply(temp_X ,param.reshape(-1,1)))+err))).reshape(-1)) - - #temp_y = y_new - #temp_y = temp_y + err - #print(min(err)) temp_X = X[:, j].reshape((-1, 1)) + temp_w = np.sqrt(w[:,j]).reshape((-1, 1)) + temp_X_w = np.multiply(temp_X, temp_w) + temp_y_w = np.multiply(temp_y, temp_w) if isinstance(family, Binomial): - bw_class = bw_func_g(temp_y, temp_X) + bw_class = bw_func_g(temp_y_w, temp_X_w) else: bw_class = bw_func(temp_y, temp_X) @@ -251,41 +244,50 @@ def tqdm(x, desc=''): #otherwise, just passthrough the range bw_stable_counter = np.ones(k) if isinstance(family, Binomial): - optim_model = gwr_func_g(temp_y, temp_X, bw) + optim_model = gwr_func_g(temp_y_w, temp_X_w, bw) else: optim_model = gwr_func(temp_y, temp_X, bw) - #err=(temp_y - optim_model.predy).reshape(-1,1) - #print(err.shape) - err = optim_model.resid_response.reshape((-1, 1)) - #print(err.shape) + + err = optim_model.resid_response.reshape((-1,1)) + #Needs further investigation + param = optim_model.params.reshape((-1, )) - #print(param.shape) - #print(temp_X.shape) - #print(err.shape) - #new_XB[:, j] = 1 / (1+np.exp(-1*np.multiply(temp_X ,param)+err)).reshape(-1) - new_XB[:, j] = 1 / (1+np.exp((-1*(np.multiply(temp_X ,param.reshape(-1,1)))))).reshape(-1) - #new_XB[:,j] = optim_model.predy.reshape(-1) - #new_XB[:,j] = np.multiply(param, temp_X).reshape(-1) - #new_XB[:, j] = optim_model.predy.reshape(-1) - #neww_XB[:, j] = (1 / (1+np.exp((-1*(np.multiply(temp_X ,param.reshape(-1,1)))+err))).reshape(-1)) - #new_XB[:, j] = np.log(new_XB[:,j]/(1-new_XB[:,j])) - params[:, j] = param + + new_ni[:,j] = np.multiply(param.reshape(-1), temp_X_w.reshape(-1)) + new_p[:,j] = np.exp(new_ni[:,j])/(1+(np.exp(new_ni[:,j]))) + + if isinstance(family, (Poisson, Gaussian)): + new_XB[:,j] = optim_model.predy.reshape(-1) + else: + new_XB[:,j] = new_ni[:,j] + ((y.reshape(-1) - new_p[:,j])/(new_p[:,j]*(1-new_p[:,j]))) + + new_w[:,j] = new_p[:,j]*(1-new_p[:,j]) + params[:, j] = param*2 bws[j] = bw - num = np.sum((new_XB - XB)**2) / n - den = np.sum(np.sum(new_XB, axis=1)**2) - score = (num / den)**0.5 + if isinstance(family, Binomial): + num = np.sum((params - old_param)**2) / n + den = np.sum(np.sum(params, axis=1)**2) + score = (num / den)**0.5 + else: + num = np.sum((new_XB - XB)**2) / n + den = np.sum(np.sum(new_XB, axis=1)**2) + score = (num / den)**0.5 + XB = new_XB - #mu = new_mu - #XXB = neww_XB + p = new_p + ni = new_ni + w = new_w + add = new_add + old_param = params if rss_score: if isinstance(family, Poisson): predy = offset*(np.exp(np.sum(X * params, axis=1).reshape(-1, 1))) elif isinstance(family,Binomial): - predy = 1/(1+np.exp(-1*np.sum(X * params, axis=1).reshape(-1, 1))) + predy = (np.exp(np.sum(X * params, axis=1).reshape(-1, 1)))/(1+np.exp(np.sum(X * params, axis=1).reshape(-1, 1))) else: predy = np.sum(np.multiply(params, X), axis=1).reshape((-1, 1)) diff --git a/notebooks/Binomial_MC_script_2/main_mc.py b/notebooks/Binomial_MC_script_2/main_mc.py new file mode 100644 index 0000000..6f36996 --- /dev/null +++ b/notebooks/Binomial_MC_script_2/main_mc.py @@ -0,0 +1,24 @@ +from multiprocessing import Process, Queue +import multiprocessing as mp + + +import model_mc +import warnings +import pickle +import sys +warnings.filterwarnings("ignore") + + +if __name__ == '__main__': + for i in range(int(sys.argv[1]),int(sys.argv[2]), 50): + start = i + end = i + 50 + + print("Starting iterations for indexes: {} to {}".format(str(start), str(end))) + + pool = mp.Pool(processes=50) + result = pool.map(model_mc.models, range(start,end)) + + print("Completing iterations for indexes: {} to {}".format(str(start), str(end))) + with open("pkls/results-{}-{}.pkl".format(str(start), str(end)), 'wb') as out: + pickle.dump(result, out, pickle.HIGHEST_PROTOCOL) diff --git a/notebooks/Binomial_MC_script_2/model_mc.py b/notebooks/Binomial_MC_script_2/model_mc.py new file mode 100644 index 0000000..2a8936e --- /dev/null +++ b/notebooks/Binomial_MC_script_2/model_mc.py @@ -0,0 +1,117 @@ +import sys +sys.path.append("C:/Users/msachde1/Downloads/Research/Development/mgwr") +import pandas as pd +import numpy as np + +from mgwr.gwr import GWR +from spglm.family import Gaussian, Binomial, Poisson +from mgwr.gwr import MGWR +from mgwr.sel_bw import Sel_BW + +class stats(object): + def __init__(self): + self.gwr_bw = [] + self.gwr_aicc = [] + self.gwr_bic=[] + self.gwr_aic=[] + self.gwr_params = [] + self.gwr_predy = [] + self.gwr_rss = [] + + self.mgwr_bw = [] + self.mgwr_aicc = [] + self.mgwr_bic=[] + self.mgwr_aic=[] + self.mgwr_params = [] + self.mgwr_predy = [] + self.mgwr_rss = [] + +def add(a,b): + return 1+((1/12)*(a+b)) + +def con(u,v): + return (0*(u)*(v))+0.3 + +def sp(u,v): + return 1+1/324*(36-(6-u/2)**2)*(36-(6-v/2)**2) + +def med(u,v): + B = np.zeros((25,25)) + for i in range(25): + for j in range(25): + + if u[i][j]<=8: + B[i][j]=0.2 + elif u[i][j]>17: + B[i][j]=0.7 + else: + B[i][j]=0.5 + return B + +class foo(object): + def __init__(self): + self.x = [] + self.name = "" + self.num = 0 + +def fkj(name, output): + ff = foo() + ff.x = [1] + ff.name = name + output.put(ff) + return + +def models(output): + print("start of the function") + s = stats() + x = np.linspace(0, 25, 25) + y = np.linspace(25, 0, 25) + X, Y = np.meshgrid(x, y) + x1=np.random.normal(0,1,625).reshape(-1,1) + x2=np.random.normal(0,1,625).reshape(-1,1) + #x3=np.random.normal(0,1,625).reshape(-1,1) + error = np.random.normal(0,0.1,625) + + B0=con(X,Y).reshape(-1,1) + #B1=add(X,Y).reshape(-1,1) + B2=sp(X,Y).reshape(-1,1) + B3=med(X,Y).reshape(-1,1) + + lat=Y.reshape(-1,1) + lon=X.reshape(-1,1) + + param = np.hstack([B0,B2,B3]) + cons=np.ones_like(x1) + X=np.hstack([cons,x1,x2]) + y_raw = ((np.exp(np.sum(X * param, axis=1)+error)/(1+(np.exp(np.sum(X * param, axis=1)+error))))).reshape(-1,1) + #y_raw=(np.exp((np.sum(X * param, axis=1)+error).reshape(-1, 1))) + #y_new = np.random.poisson(y_raw) + y_new = np.random.binomial(1,y_raw,(625,1)) + + coords = np.array(list(zip(lon,lat))) + y = np.array(y_new).reshape((-1,1)) + X1=np.hstack([x1,x2]) + + bw=Sel_BW(coords,y,X1,family=Binomial()) + bw=bw.search() + s.gwr_bw.append(bw) + gwr_model=GWR(coords,y,X1,bw,family=Binomial()).fit() + s.gwr_aicc.append(gwr_model.aicc) + s.gwr_bic.append(gwr_model.bic) + s.gwr_aic.append(gwr_model.aic) + s.gwr_params.append(gwr_model.params) + s.gwr_predy.append(gwr_model.predy) + s.gwr_rss.append(gwr_model.resid_ss) + + selector=Sel_BW(coords,y,X1,multi=True,family=Binomial()) + selector.search() + s.mgwr_bw.append(selector.bw[0]) + mgwr_model=MGWR(coords,y,X1,selector,family=Binomial()).fit() + s.mgwr_aicc.append(mgwr_model.aicc) + s.mgwr_bic.append(mgwr_model.bic) + s.mgwr_aic.append(mgwr_model.aic) + s.mgwr_params.append(mgwr_model.params) + s.mgwr_predy.append(mgwr_model.predy) + s.mgwr_rss.append(mgwr_model.resid_ss) + + return s diff --git a/notebooks/Binomial_MC_script_2/pkls/results-0-50.pkl b/notebooks/Binomial_MC_script_2/pkls/results-0-50.pkl new file mode 100644 index 0000000..cff358a Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-0-50.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-100-150.pkl b/notebooks/Binomial_MC_script_2/pkls/results-100-150.pkl new file mode 100644 index 0000000..abf79e5 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-100-150.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-150-200.pkl b/notebooks/Binomial_MC_script_2/pkls/results-150-200.pkl new file mode 100644 index 0000000..60f3a61 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-150-200.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-200-250.pkl b/notebooks/Binomial_MC_script_2/pkls/results-200-250.pkl new file mode 100644 index 0000000..104ff2b Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-200-250.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-250-300.pkl b/notebooks/Binomial_MC_script_2/pkls/results-250-300.pkl new file mode 100644 index 0000000..1943026 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-250-300.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-300-350.pkl b/notebooks/Binomial_MC_script_2/pkls/results-300-350.pkl new file mode 100644 index 0000000..8a143b1 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-300-350.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-350-400.pkl b/notebooks/Binomial_MC_script_2/pkls/results-350-400.pkl new file mode 100644 index 0000000..7c33f59 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-350-400.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-400-450.pkl b/notebooks/Binomial_MC_script_2/pkls/results-400-450.pkl new file mode 100644 index 0000000..b32f6bd Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-400-450.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-450-500.pkl b/notebooks/Binomial_MC_script_2/pkls/results-450-500.pkl new file mode 100644 index 0000000..340c114 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-450-500.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-50-100.pkl b/notebooks/Binomial_MC_script_2/pkls/results-50-100.pkl new file mode 100644 index 0000000..b349d48 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-50-100.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-500-550.pkl b/notebooks/Binomial_MC_script_2/pkls/results-500-550.pkl new file mode 100644 index 0000000..72da4e0 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-500-550.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-550-600.pkl b/notebooks/Binomial_MC_script_2/pkls/results-550-600.pkl new file mode 100644 index 0000000..bececfc Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-550-600.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-600-650.pkl b/notebooks/Binomial_MC_script_2/pkls/results-600-650.pkl new file mode 100644 index 0000000..c5fdc52 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-600-650.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-650-700.pkl b/notebooks/Binomial_MC_script_2/pkls/results-650-700.pkl new file mode 100644 index 0000000..ace830b Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-650-700.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-700-750.pkl b/notebooks/Binomial_MC_script_2/pkls/results-700-750.pkl new file mode 100644 index 0000000..0a58cdd Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-700-750.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-750-800.pkl b/notebooks/Binomial_MC_script_2/pkls/results-750-800.pkl new file mode 100644 index 0000000..c7c8a96 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-750-800.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-800-850.pkl b/notebooks/Binomial_MC_script_2/pkls/results-800-850.pkl new file mode 100644 index 0000000..dcd8250 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-800-850.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-850-900.pkl b/notebooks/Binomial_MC_script_2/pkls/results-850-900.pkl new file mode 100644 index 0000000..b54d885 Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-850-900.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-900-950.pkl b/notebooks/Binomial_MC_script_2/pkls/results-900-950.pkl new file mode 100644 index 0000000..f8709da Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-900-950.pkl differ diff --git a/notebooks/Binomial_MC_script_2/pkls/results-950-1000.pkl b/notebooks/Binomial_MC_script_2/pkls/results-950-1000.pkl new file mode 100644 index 0000000..b0dc0fb Binary files /dev/null and b/notebooks/Binomial_MC_script_2/pkls/results-950-1000.pkl differ diff --git a/notebooks/Binomial_MC_script_we/main_mc.py b/notebooks/Binomial_MC_script_we/main_mc.py new file mode 100644 index 0000000..672d30b --- /dev/null +++ b/notebooks/Binomial_MC_script_we/main_mc.py @@ -0,0 +1,24 @@ +from multiprocessing import Process, Queue +import multiprocessing as mp + + +import model_mc +import warnings +import pickle +import sys +warnings.filterwarnings("ignore") + + +if __name__ == '__main__': + for i in range(int(sys.argv[1]),int(sys.argv[2]), 10): + start = i + end = i + 10 + + print("Starting iterations for indexes: {} to {}".format(str(start), str(end))) + + pool = mp.Pool(processes=10) + result = pool.map(model_mc.models, range(start,end)) + + print("Completing iterations for indexes: {} to {}".format(str(start), str(end))) + with open("pkls/results-{}-{}.pkl".format(str(start), str(end)), 'wb') as out: + pickle.dump(result, out, pickle.HIGHEST_PROTOCOL) diff --git a/notebooks/Binomial_MC_script_we/model_mc.py b/notebooks/Binomial_MC_script_we/model_mc.py new file mode 100644 index 0000000..2a8936e --- /dev/null +++ b/notebooks/Binomial_MC_script_we/model_mc.py @@ -0,0 +1,117 @@ +import sys +sys.path.append("C:/Users/msachde1/Downloads/Research/Development/mgwr") +import pandas as pd +import numpy as np + +from mgwr.gwr import GWR +from spglm.family import Gaussian, Binomial, Poisson +from mgwr.gwr import MGWR +from mgwr.sel_bw import Sel_BW + +class stats(object): + def __init__(self): + self.gwr_bw = [] + self.gwr_aicc = [] + self.gwr_bic=[] + self.gwr_aic=[] + self.gwr_params = [] + self.gwr_predy = [] + self.gwr_rss = [] + + self.mgwr_bw = [] + self.mgwr_aicc = [] + self.mgwr_bic=[] + self.mgwr_aic=[] + self.mgwr_params = [] + self.mgwr_predy = [] + self.mgwr_rss = [] + +def add(a,b): + return 1+((1/12)*(a+b)) + +def con(u,v): + return (0*(u)*(v))+0.3 + +def sp(u,v): + return 1+1/324*(36-(6-u/2)**2)*(36-(6-v/2)**2) + +def med(u,v): + B = np.zeros((25,25)) + for i in range(25): + for j in range(25): + + if u[i][j]<=8: + B[i][j]=0.2 + elif u[i][j]>17: + B[i][j]=0.7 + else: + B[i][j]=0.5 + return B + +class foo(object): + def __init__(self): + self.x = [] + self.name = "" + self.num = 0 + +def fkj(name, output): + ff = foo() + ff.x = [1] + ff.name = name + output.put(ff) + return + +def models(output): + print("start of the function") + s = stats() + x = np.linspace(0, 25, 25) + y = np.linspace(25, 0, 25) + X, Y = np.meshgrid(x, y) + x1=np.random.normal(0,1,625).reshape(-1,1) + x2=np.random.normal(0,1,625).reshape(-1,1) + #x3=np.random.normal(0,1,625).reshape(-1,1) + error = np.random.normal(0,0.1,625) + + B0=con(X,Y).reshape(-1,1) + #B1=add(X,Y).reshape(-1,1) + B2=sp(X,Y).reshape(-1,1) + B3=med(X,Y).reshape(-1,1) + + lat=Y.reshape(-1,1) + lon=X.reshape(-1,1) + + param = np.hstack([B0,B2,B3]) + cons=np.ones_like(x1) + X=np.hstack([cons,x1,x2]) + y_raw = ((np.exp(np.sum(X * param, axis=1)+error)/(1+(np.exp(np.sum(X * param, axis=1)+error))))).reshape(-1,1) + #y_raw=(np.exp((np.sum(X * param, axis=1)+error).reshape(-1, 1))) + #y_new = np.random.poisson(y_raw) + y_new = np.random.binomial(1,y_raw,(625,1)) + + coords = np.array(list(zip(lon,lat))) + y = np.array(y_new).reshape((-1,1)) + X1=np.hstack([x1,x2]) + + bw=Sel_BW(coords,y,X1,family=Binomial()) + bw=bw.search() + s.gwr_bw.append(bw) + gwr_model=GWR(coords,y,X1,bw,family=Binomial()).fit() + s.gwr_aicc.append(gwr_model.aicc) + s.gwr_bic.append(gwr_model.bic) + s.gwr_aic.append(gwr_model.aic) + s.gwr_params.append(gwr_model.params) + s.gwr_predy.append(gwr_model.predy) + s.gwr_rss.append(gwr_model.resid_ss) + + selector=Sel_BW(coords,y,X1,multi=True,family=Binomial()) + selector.search() + s.mgwr_bw.append(selector.bw[0]) + mgwr_model=MGWR(coords,y,X1,selector,family=Binomial()).fit() + s.mgwr_aicc.append(mgwr_model.aicc) + s.mgwr_bic.append(mgwr_model.bic) + s.mgwr_aic.append(mgwr_model.aic) + s.mgwr_params.append(mgwr_model.params) + s.mgwr_predy.append(mgwr_model.predy) + s.mgwr_rss.append(mgwr_model.resid_ss) + + return s diff --git a/notebooks/Binomial_MC_script_we/pkls/results-0-10.pkl b/notebooks/Binomial_MC_script_we/pkls/results-0-10.pkl new file mode 100644 index 0000000..7e2bf06 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-0-10.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-10-20.pkl b/notebooks/Binomial_MC_script_we/pkls/results-10-20.pkl new file mode 100644 index 0000000..fd813c8 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-10-20.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-100-110.pkl b/notebooks/Binomial_MC_script_we/pkls/results-100-110.pkl new file mode 100644 index 0000000..642c7aa Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-100-110.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-110-120.pkl b/notebooks/Binomial_MC_script_we/pkls/results-110-120.pkl new file mode 100644 index 0000000..e8f3dd1 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-110-120.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-120-130.pkl b/notebooks/Binomial_MC_script_we/pkls/results-120-130.pkl new file mode 100644 index 0000000..8085fa8 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-120-130.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-130-140.pkl b/notebooks/Binomial_MC_script_we/pkls/results-130-140.pkl new file mode 100644 index 0000000..45a1b69 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-130-140.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-140-150.pkl b/notebooks/Binomial_MC_script_we/pkls/results-140-150.pkl new file mode 100644 index 0000000..a20aa34 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-140-150.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-150-160.pkl b/notebooks/Binomial_MC_script_we/pkls/results-150-160.pkl new file mode 100644 index 0000000..6c2f9c9 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-150-160.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-160-170.pkl b/notebooks/Binomial_MC_script_we/pkls/results-160-170.pkl new file mode 100644 index 0000000..26ef19b Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-160-170.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-170-180.pkl b/notebooks/Binomial_MC_script_we/pkls/results-170-180.pkl new file mode 100644 index 0000000..542fbcd Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-170-180.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-180-190.pkl b/notebooks/Binomial_MC_script_we/pkls/results-180-190.pkl new file mode 100644 index 0000000..d1a52fe Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-180-190.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-190-200.pkl b/notebooks/Binomial_MC_script_we/pkls/results-190-200.pkl new file mode 100644 index 0000000..18ca51a Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-190-200.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-20-30.pkl b/notebooks/Binomial_MC_script_we/pkls/results-20-30.pkl new file mode 100644 index 0000000..6caac32 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-20-30.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-200-210.pkl b/notebooks/Binomial_MC_script_we/pkls/results-200-210.pkl new file mode 100644 index 0000000..297de46 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-200-210.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-210-220.pkl b/notebooks/Binomial_MC_script_we/pkls/results-210-220.pkl new file mode 100644 index 0000000..9e2d798 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-210-220.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-220-230.pkl b/notebooks/Binomial_MC_script_we/pkls/results-220-230.pkl new file mode 100644 index 0000000..c2ca677 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-220-230.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-230-240.pkl b/notebooks/Binomial_MC_script_we/pkls/results-230-240.pkl new file mode 100644 index 0000000..cb1d94a Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-230-240.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-240-250.pkl b/notebooks/Binomial_MC_script_we/pkls/results-240-250.pkl new file mode 100644 index 0000000..c02e542 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-240-250.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-250-260.pkl b/notebooks/Binomial_MC_script_we/pkls/results-250-260.pkl new file mode 100644 index 0000000..846114f Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-250-260.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-260-270.pkl b/notebooks/Binomial_MC_script_we/pkls/results-260-270.pkl new file mode 100644 index 0000000..1a8f0b7 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-260-270.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-270-280.pkl b/notebooks/Binomial_MC_script_we/pkls/results-270-280.pkl new file mode 100644 index 0000000..2bb2ed8 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-270-280.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-280-290.pkl b/notebooks/Binomial_MC_script_we/pkls/results-280-290.pkl new file mode 100644 index 0000000..105d0ec Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-280-290.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-290-300.pkl b/notebooks/Binomial_MC_script_we/pkls/results-290-300.pkl new file mode 100644 index 0000000..8b15e6e Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-290-300.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-30-40.pkl b/notebooks/Binomial_MC_script_we/pkls/results-30-40.pkl new file mode 100644 index 0000000..e61826b Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-30-40.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-300-310.pkl b/notebooks/Binomial_MC_script_we/pkls/results-300-310.pkl new file mode 100644 index 0000000..ec9c192 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-300-310.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-310-320.pkl b/notebooks/Binomial_MC_script_we/pkls/results-310-320.pkl new file mode 100644 index 0000000..d59f841 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-310-320.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-320-330.pkl b/notebooks/Binomial_MC_script_we/pkls/results-320-330.pkl new file mode 100644 index 0000000..3cd9d5c Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-320-330.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-330-340.pkl b/notebooks/Binomial_MC_script_we/pkls/results-330-340.pkl new file mode 100644 index 0000000..523921c Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-330-340.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-340-350.pkl b/notebooks/Binomial_MC_script_we/pkls/results-340-350.pkl new file mode 100644 index 0000000..552a0e2 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-340-350.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-350-360.pkl b/notebooks/Binomial_MC_script_we/pkls/results-350-360.pkl new file mode 100644 index 0000000..b462899 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-350-360.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-360-370.pkl b/notebooks/Binomial_MC_script_we/pkls/results-360-370.pkl new file mode 100644 index 0000000..8369656 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-360-370.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-370-380.pkl b/notebooks/Binomial_MC_script_we/pkls/results-370-380.pkl new file mode 100644 index 0000000..7b45cbe Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-370-380.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-380-390.pkl b/notebooks/Binomial_MC_script_we/pkls/results-380-390.pkl new file mode 100644 index 0000000..7f31425 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-380-390.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-390-400.pkl b/notebooks/Binomial_MC_script_we/pkls/results-390-400.pkl new file mode 100644 index 0000000..39d6538 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-390-400.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-40-50.pkl b/notebooks/Binomial_MC_script_we/pkls/results-40-50.pkl new file mode 100644 index 0000000..24e91ef Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-40-50.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-400-410.pkl b/notebooks/Binomial_MC_script_we/pkls/results-400-410.pkl new file mode 100644 index 0000000..4efba1a Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-400-410.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-410-420.pkl b/notebooks/Binomial_MC_script_we/pkls/results-410-420.pkl new file mode 100644 index 0000000..e1523ed Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-410-420.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-420-430.pkl b/notebooks/Binomial_MC_script_we/pkls/results-420-430.pkl new file mode 100644 index 0000000..b5d12bd Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-420-430.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-430-440.pkl b/notebooks/Binomial_MC_script_we/pkls/results-430-440.pkl new file mode 100644 index 0000000..76fed3e Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-430-440.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-440-450.pkl b/notebooks/Binomial_MC_script_we/pkls/results-440-450.pkl new file mode 100644 index 0000000..f533e0a Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-440-450.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-450-460.pkl b/notebooks/Binomial_MC_script_we/pkls/results-450-460.pkl new file mode 100644 index 0000000..98d1e64 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-450-460.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-460-470.pkl b/notebooks/Binomial_MC_script_we/pkls/results-460-470.pkl new file mode 100644 index 0000000..37da0d1 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-460-470.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-470-480.pkl b/notebooks/Binomial_MC_script_we/pkls/results-470-480.pkl new file mode 100644 index 0000000..c05add5 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-470-480.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-480-490.pkl b/notebooks/Binomial_MC_script_we/pkls/results-480-490.pkl new file mode 100644 index 0000000..9e6f86c Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-480-490.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-490-500.pkl b/notebooks/Binomial_MC_script_we/pkls/results-490-500.pkl new file mode 100644 index 0000000..c9728b8 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-490-500.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-50-60.pkl b/notebooks/Binomial_MC_script_we/pkls/results-50-60.pkl new file mode 100644 index 0000000..93a2e8a Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-50-60.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-60-70.pkl b/notebooks/Binomial_MC_script_we/pkls/results-60-70.pkl new file mode 100644 index 0000000..7badd13 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-60-70.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-70-80.pkl b/notebooks/Binomial_MC_script_we/pkls/results-70-80.pkl new file mode 100644 index 0000000..953215f Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-70-80.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-80-90.pkl b/notebooks/Binomial_MC_script_we/pkls/results-80-90.pkl new file mode 100644 index 0000000..3ee4fe4 Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-80-90.pkl differ diff --git a/notebooks/Binomial_MC_script_we/pkls/results-90-100.pkl b/notebooks/Binomial_MC_script_we/pkls/results-90-100.pkl new file mode 100644 index 0000000..0acac9a Binary files /dev/null and b/notebooks/Binomial_MC_script_we/pkls/results-90-100.pkl differ diff --git a/notebooks/Binomial_MGWR.ipynb b/notebooks/Binomial_MGWR.ipynb new file mode 100644 index 0000000..74218ab --- /dev/null +++ b/notebooks/Binomial_MGWR.ipynb @@ -0,0 +1,137 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiscale Geographically Weighted Regression - Binomial dependent variable\n", + "\n", + "\n", + "The model has been explored and tested for multiple parameters on real and simulated datasets. The research includes the following outline with separate notebooks for each part.\n", + "\n", + "\n", + "**Notebook Outline:** \n", + " \n", + "**[Introduction Notebook (current)](Poisson_MGWR.ipynb)**\n", + "- [Introduction](#Introduction)\n", + " - [Introduction to the problem](#Introduction-to-the-project)\n", + " - [Important Equations](#Statistical-Equations) \n", + "- [Approaches Explored](#Approaches-Explored)\n", + "- [References](#References)\n", + "\n", + "**[Initial module changes and univariate model check ](Poisson_MGWR_univariate_check.ipynb)**\n", + "- [Setup with libraries](#Set-up-Cells)\n", + "- [Fundamental equations for Binomial MGWR](#Fundamental-equations-for-Poisson-MGWR)\n", + "- [Example Dataset](#Example-Dataset)\n", + "- [Helper functions](#Helper-functions)\n", + "- [Univariate example](#Univariate-example)\n", + " - [Parameter check](#Parameter-check)\n", + " - [Bandwidths check](#Bandwidths-check)\n", + "\n", + "**[Simulated Data example](Simulated_data_example_Poisson-MGWR.ipynb)**\n", + "- [Setup with libraries](#Set-up-Cells)\n", + "- [Create Simulated Dataset](#Create-Simulated-Dataset)\n", + " - [Forming independent variables](#Forming-independent-variables)\n", + " - [Creating y variable with Binomial distribution](#Creating-y-variable-with-Poisson-distribution)\n", + "- [Univariate example](#Univariate-example)\n", + " - [Bandwidth: Random initialization check](#Bandwidth:-Random-initialization-check)\n", + " - [Parameters check](#Parameters-check)\n", + "- [Multivariate example](#Multivariate-example)\n", + " - [Bandwidths: Random initialization check](#Bandwidths:-Random-initialization-check)\n", + " - [Parameters check](#Parameters-check)\n", + "- [Global model parameter check](#Global-model-parameter-check)\n", + " \n", + "**[Real Data example](Real_data_example_Poisson-MGWR.ipynb)**\n", + "\n", + "- [Setup with libraries](#Set-up-Cells)\n", + "- [Landslide Dataset](#Tokyo-Mortality-Dataset)\n", + "- [Univariate example](#Univariate-example)\n", + " - [Bandwidth: Random initialization check](#Bandwidth:-Random-initialization-check)\n", + " - [Parameter check](Parameter-check)\n", + "- [Multivariate example](#Multivariate-example)\n", + " [Bandwidths: Random initialization check](#Bandwidths:-Random-initialization-check)\n", + "- [MGWR bandwidths](#MGWR-bandwidths)\n", + "- [AIC, AICc, BIC check](#AIC,-AICc,-BIC-check)\n", + "\n", + "**[Monte Carlo Simulation Visualization](Poisson_MGWR_MonteCarlo_Results.ipynb)**\n", + " \n", + "- [Setup with libraries](#Set-up-Cell)\n", + "- [List bandwidths from pickles](#List-bandwidths-from-pickles)\n", + "- [Parameter functions](#Parameter-functions)\n", + "- [GWR bandwidth](#GWR-bandwidth)\n", + "- [MGWR bandwidths](#MGWR-bandwidths)\n", + "- [AIC, AICc, BIC check](#AIC,-AICc,-BIC-check)\n", + " - [AIC, AICc, BIC Boxplots for comparison](#AIC,-AICc,-BIC-Boxplots-for-comparison)\n", + "- [Parameter comparison from MGWR and GWR](#Parameter-comparison-from-MGWR-and-GWR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Local Scoring Algorithm\n", + "\n", + "1. Initialize: ${\\beta}_0$ = g($\\bar{y}$); $f^{0}_1$=$f^{0}_2$=0\n", + "\n", + "2. Update and Construct an adjusted dependent variable:\n", + "$z_i$ = ${\\eta}^{0}_i$ + ($y_i - {\\mu}^{0}_i$) (${\\delta}{\\eta}_i$ / ${\\delta}{\\mu}_i$)\n", + "\n", + "with ${\\eta}^{0}_i$ = ${\\beta}^0_0$ + ${\\sum} f_j(X_j)$ and ${\\mu}^0_i$ = $g^{-1}({\\eta}^0_i)$\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\\begin{align}\n", + "\\beta^{(l+1)} (u_i) = (X^{t} W (u_i) A(u_i)^{(l)} X)^{-1} X^{t} W (u_i) A (u_i) ^{(l)} z (u_i){(l)} \\\\\n", + "\\end{align}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "n_old = sum(beta_0 + beta_1 * X_1 + beta_2 * X_2)\n", + "\n", + "p_old = exp(n_old) / (1+exp(n_old))\n", + "\n", + "z = n_old + ((yi-p_old)/(p_old * (1-p_old)))\n", + "\n", + "w = p_old * (1 - p_old)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "log(p/1-p) = beta_0 + sum(f_j(x_j))\n", + "\n", + "n_old = log(optim_model.predy/1-optim_model.predy) + (y-optim_model.predy)/(optim_model.predy*(1-optim_model.predy))\n", + "\n" + ] + } + ], + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Binomial_MGWR_MonteCarlo_Results-we.ipynb b/notebooks/Binomial_MGWR_MonteCarlo_Results-we.ipynb new file mode 100644 index 0000000..b92c4a9 --- /dev/null +++ b/notebooks/Binomial_MGWR_MonteCarlo_Results-we.ipynb @@ -0,0 +1,1483 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notebook Outline:** \n", + " \n", + "- [Setup with libraries](#Set-up-Cell)\n", + "- [List bandwidths from pickles](#List-bandwidths-from-pickles)\n", + "- [Parameter functions](#Parameter-functions)\n", + "- [GWR bandwidth](#GWR-bandwidth)\n", + "- [MGWR bandwidths](#MGWR-bandwidths)\n", + "- [AIC, AICc, BIC check](#AIC,-AICc,-BIC-check)\n", + " - [AIC, AICc, BIC Boxplots for comparison](#AIC,-AICc,-BIC-Boxplots-for-comparison)\n", + "- [Parameter comparison from MGWR and GWR](#Parameter-comparison-from-MGWR-and-GWR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Monte Carlo experiment code can be found in path mgwr/notebooks/Poisson_MC_script/" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up Cell" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\msachde1\\AppData\\Local\\Continuum\\anaconda3\\envs\\gwrenv\\lib\\site-packages\\libpysal\\io\\iohandlers\\__init__.py:25: UserWarning: SQLAlchemy and Geomet not installed, database I/O disabled\n", + " warnings.warn('SQLAlchemy and Geomet not installed, database I/O disabled')\n" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pickle\n", + "import sys\n", + "import seaborn as sns\n", + "import numpy as np\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Binomial_MC_script_2/\")\n", + "import model_mc\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### List bandwidths from pickles" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_bw0=[]\n", + "mgwr_bw1=[]\n", + "mgwr_bw2=[]\n", + "gwr_bw=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,500,10):\n", + " p1 = pickle.load( open( \"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Binomial_MC_script_we/pkls/results-{}-{}.pkl\".format(str(i), str(i+10)),\"rb\") )\n", + " for j in range(10):\n", + " mgwr_bw0.append(p1[j].mgwr_bw[0][0])\n", + " mgwr_bw1.append(p1[j].mgwr_bw[0][1])\n", + " mgwr_bw2.append(p1[j].mgwr_bw[0][2])\n", + " gwr_bw.append(p1[j].gwr_bw[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter functions" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "def add(a,b):\n", + " return 1+((1/120)*(a+b))\n", + "\n", + "def con(u,v):\n", + " return (0*(u)*(v))+0.3\n", + "\n", + "def sp(u,v):\n", + " return 1+1/3240*(36-(6-u/2)**2)*(36-(6-v/2)**2)\n", + "\n", + "def med(u,v):\n", + " B = np.zeros((25,25))\n", + " for i in range(25):\n", + " for j in range(25):\n", + " \n", + " if u[i][j]<=8:\n", + " B[i][j]=0.2\n", + " elif u[i][j]>17:\n", + " B[i][j]=0.7\n", + " else:\n", + " B[i][j]=0.5\n", + " return B" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)\n", + "X, Y = np.meshgrid(x, y)\n", + "\n", + "B0=con(X,Y)\n", + "#B1=add(X,Y)\n", + "B1=sp(X,Y)\n", + "B2=med(X,Y)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GWR bandwidth" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(gwr_bw)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "243.354" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(gwr_bw)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MGWR bandwidths" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(B0, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(mgwr_bw0)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "532.386" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw0)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(B1, extent=[0,25, 0, 25], origin='lower',cmap='RdBu_r')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "234.168" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw1)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(mgwr_bw1)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(B2, extent=[0,25, 0, 25], origin='lower',cmap='RdBu_r')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "502.406" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw2)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(mgwr_bw2)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(532.386, 234.168, 502.406)" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw0),np.mean(mgwr_bw1),np.mean(mgwr_bw2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### AIC, AICc, BIC check" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_aicc=[]\n", + "gwr_aicc=[]\n", + "mgwr_bic=[]\n", + "gwr_bic=[]\n", + "mgwr_aic=[]\n", + "gwr_aic=[]\n", + "mgwr_params=[]\n", + "gwr_params=[]\n", + "mgwr_predy=[]\n", + "gwr_predy=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,500,10):\n", + " p1 = pickle.load( open( \"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Binomial_MC_script_we/pkls/results-{}-{}.pkl\".format(str(i), str(i+10)),\"rb\") )\n", + " for j in range(10):\n", + " mgwr_aicc.append(p1[j].mgwr_aicc[0])\n", + " gwr_aicc.append(p1[j].gwr_aicc[0])\n", + " \n", + " mgwr_bic.append(p1[j].mgwr_bic[0])\n", + " gwr_bic.append(p1[j].gwr_bic[0])\n", + " \n", + " mgwr_aic.append(p1[j].mgwr_aic[0])\n", + " gwr_aic.append(p1[j].gwr_aic[0])\n", + " \n", + " mgwr_params.append(p1[j].mgwr_params[0])\n", + " gwr_params.append(p1[j].gwr_params[0])\n", + " \n", + " mgwr_predy.append(p1[j].mgwr_predy[0])\n", + " gwr_predy.append(p1[j].gwr_predy[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(np.mean(gwr_predy,axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(np.mean(mgwr_predy,axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, axes = plt.subplots(1, 2, figsize=(4, 4), sharex=True)\n", + "sns.despine(left=True)\n", + "sns.distplot(mgwr_bic,ax=axes[0])\n", + "sns.distplot(gwr_bic,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, axes = plt.subplots(1, 2, figsize=(4, 4), sharex=True)\n", + "sns.despine(left=True)\n", + "sns.distplot(mgwr_aic,ax=axes[0])\n", + "sns.distplot(gwr_aic,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, axes = plt.subplots(1, 2, figsize=(4, 4), sharex=True)\n", + "sns.despine(left=True)\n", + "sns.distplot(mgwr_aicc,ax=axes[0])\n", + "sns.distplot(gwr_aicc,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(573.0542142681326, 564.1109593727111)" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_aicc), np.mean(gwr_aicc)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(573.0155189048916, 562.4075174365614)" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_aic), np.mean(gwr_aic)" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(586.3381072542409, 657.4481261493207)" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bic), np.mean(gwr_bic)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### AIC, AICc, BIC Boxplots for comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*500\n", + "model2 = ['mgwr']*500\n", + "model=model+model2" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [], + "source": [ + "aic=[]\n", + "aic=gwr_aic\n", + "aic=aic+mgwr_aic" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "aicc=[]\n", + "aicc=gwr_aicc\n", + "aicc=aicc+mgwr_aicc" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "bic=[]\n", + "bic=gwr_bic\n", + "bic=bic+mgwr_bic" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "d = {'aic':aic,'bic':bic,'aicc':aicc,'model':model}" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "df=pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['aic'],x=df['model'])" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['aicc'],x=df['model'])" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['bic'],x=df['model'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter comparison from MGWR and GWR" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_params_mean=np.mean(mgwr_params,axis=0)\n", + "gwr_params_mean=np.mean(gwr_params,axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.31469142, 1.61932981, 0.24680036],\n", + " [0.31376851, 1.62072329, 0.25249583],\n", + " [0.31251579, 1.62234972, 0.25957388],\n", + " ...,\n", + " [0.29442015, 1.71479871, 0.64257558],\n", + " [0.2947018 , 1.67897208, 0.64781585],\n", + " [0.29479386, 1.64721497, 0.65266 ]])" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_params_mean" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [], + "source": [ + "B0_mgwr=np.hsplit(mgwr_params_mean,3)[0]\n", + "B1_mgwr=np.hsplit(mgwr_params_mean,3)[1]\n", + "B2_mgwr=np.hsplit(mgwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [], + "source": [ + "B0_gwr=np.hsplit(gwr_params_mean,3)[0]\n", + "B1_gwr=np.hsplit(gwr_params_mean,3)[1]\n", + "B2_gwr=np.hsplit(gwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [], + "source": [ + "B0_mgwr=B0_mgwr.reshape(25,25)\n", + "B1_mgwr=B1_mgwr.reshape(25,25)\n", + "B2_mgwr=B2_mgwr.reshape(25,25)" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.3162876373767867, 0.3000642017402459, 0.3)" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(B0_mgwr),np.mean(B0_gwr),np.mean(B0)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [], + "source": [ + "B0_gwr=B0_gwr.reshape(25,25)\n", + "B1_gwr=B1_gwr.reshape(25,25)\n", + "B2_gwr=B2_gwr.reshape(25,25)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax, ax2,ax3, cax) = plt.subplots(ncols=4,figsize=(10,6), \n", + " gridspec_kw={\"width_ratios\":[1,1,1, 0.1],\"height_ratios\":[1]})\n", + "fig.subplots_adjust(wspace=0.3)\n", + "im = ax.imshow(B0, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "ax.text(3, -2, 'Original B0')\n", + "im2 = ax2.imshow(B0_mgwr, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "ax2.text(3, -2, 'MGWR B0')\n", + "im3 = ax3.imshow(B0_gwr, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "ax3.text(3, -2, 'GWR B0')\n", + "\n", + "divider = make_axes_locatable(ax3)\n", + "\n", + "fig.colorbar(im, cax=cax)\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "\n", + "ax2.set_xticks([])\n", + "ax2.set_yticks([])\n", + "\n", + "ax3.set_xticks([])\n", + "ax3.set_yticks([])\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax, ax2,ax3, cax) = plt.subplots(ncols=4,figsize=(10,6), \n", + " gridspec_kw={\"width_ratios\":[1,1,1, 0.1],\"height_ratios\":[1]})\n", + "fig.subplots_adjust(wspace=0.3)\n", + "im = ax.imshow(B1, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax.text(3, -2, 'Original B1')\n", + "im2 = ax2.imshow(B1_mgwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax2.text(3, -2, 'MGWR B1')\n", + "im3 = ax3.imshow(B1_gwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax3.text(3, -2, 'GWR B1')\n", + "\n", + "divider = make_axes_locatable(ax3)\n", + "\n", + "fig.colorbar(im, cax=cax)\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "\n", + "ax2.set_xticks([])\n", + "ax2.set_yticks([])\n", + "\n", + "ax3.set_xticks([])\n", + "ax3.set_yticks([])\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax, ax2,ax3, cax) = plt.subplots(ncols=4,figsize=(10,6), \n", + " gridspec_kw={\"width_ratios\":[1,1,1, 0.1],\"height_ratios\":[1]})\n", + "fig.subplots_adjust(wspace=0.3)\n", + "im = ax.imshow(B2, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax.text(3, -2, 'Original B2')\n", + "im2 = ax2.imshow(B2_mgwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax2.text(3, -2, 'MGWR B2')\n", + "im3 = ax3.imshow(B2_gwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax3.text(3, -2, 'GWR B2')\n", + "\n", + "divider = make_axes_locatable(ax3)\n", + "\n", + "fig.colorbar(im, cax=cax)\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "\n", + "ax2.set_xticks([])\n", + "ax2.set_yticks([])\n", + "\n", + "ax3.set_xticks([])\n", + "ax3.set_yticks([])\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing parameters (MGWR and GWR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$RMSE_j$ = $\\sqrt{1/n \\sum{(\\beta_j (u_i, v_i) - \\hat{\\beta}(u_i, v_i))^2}}$" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "B0_g=np.hsplit(gwr_params_mean,3)[0]\n", + "B1_g=np.hsplit(gwr_params_mean,3)[1]\n", + "B2_g=np.hsplit(gwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "B0_m=np.hsplit(mgwr_params_mean,3)[0]\n", + "B1_m=np.hsplit(mgwr_params_mean,3)[1]\n", + "B2_m=np.hsplit(mgwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "b0 = B0.reshape(-1,1)\n", + "b1 = B1.reshape(-1,1)\n", + "b2 = B2.reshape(-1,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_0$" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b0_m=[]\n", + "for i in range(100):\n", + " rmse_b0_m.append(np.sqrt((np.sum((b0 - (np.hsplit(mgwr_params[i],3)[0]))**2))/625))\n", + " \n", + "rmse_b0_g=[]\n", + "for i in range(100):\n", + " rmse_b0_g.append(np.sqrt((np.sum((b0 - (np.hsplit(gwr_params[i],3)[0]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*100\n", + "model2 = ['mgwr']*100\n", + "model=model+model2\n", + "\n", + "rmse_b0 = rmse_b0_g+rmse_b0_m\n", + "d = {\"model\":model,\"rmse_b0\":rmse_b0}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['rmse_b0'],x=df['model'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_1$" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b1_m=[]\n", + "for i in range(100):\n", + " rmse_b1_m.append(np.sqrt((np.sum((b1 - (np.hsplit(mgwr_params[i],3)[1]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b1_g=[]\n", + "for i in range(100):\n", + " rmse_b1_g.append(np.sqrt((np.sum((b1 - (np.hsplit(gwr_params[i],3)[1]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*100\n", + "model2 = ['mgwr']*100\n", + "model=model+model2\n", + "rmse_b1=[]\n", + "rmse_b1 = rmse_b1_g+rmse_b1_m\n", + "d = {\"model\":model,\"rmse_b1\":rmse_b1}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(x=df['model'],y=df['rmse_b1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.8237125254924693" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b1 - (np.hsplit(mgwr_params_mean,3)[1]))**2))/625)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.5244657525329972" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b1 - (np.hsplit(gwr_params_mean,3)[1]))**2))/625)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_2$" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b2_m=[]\n", + "for i in range(100):\n", + " rmse_b2_m.append(np.sqrt((np.sum((b2 - np.hsplit(mgwr_params[i],3)[2])**2))/625))\n", + " \n", + "rmse_b2_g=[]\n", + "for i in range(100):\n", + " rmse_b2_g.append(np.sqrt((np.sum((b2 - np.hsplit(gwr_params[i],3)[2])**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*100\n", + "model2 = ['mgwr']*100\n", + "model=model+model2\n", + "rmse_b2=[]\n", + "rmse_b2 = rmse_b2_g+rmse_b2_m\n", + "d = {\"model\":model,\"rmse_b2\":rmse_b2}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEPCAYAAABcA4N7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAG5hJREFUeJzt3X1UVHXix/HPjDwoRgHJgK6/XM2T+QAeY1dYzgaKD6wubNpykmNJm0nWqWVjO5WarWVrmm3ayR6xk24urp5DWNF2AMusVkgXt1bRyp9hWWsCOmqggMDM7w9/zi6Z1xG53ivzfv3ld+Yy9zM68rkPc7/X4fV6vQIA4CycVgcAANgbRQEAMERRAAAMURQAAEMUBQDAEEUBADBEUQAADFEUAABDphZFSUmJJk+erIkTJ6qwsPCM52tqajRjxgz96le/0u23365jx46ZGQcA0AmmFUVtba2WL1+utWvX6vXXX9f69eu1d+9e3/Ner1d33XWXcnNz9eabb2ro0KEqKCgwKw4AoJNMK4qKigolJSUpIiJCYWFhSk9PV2lpqe/5Xbt2KSwsTCkpKZKkO++8UzfffLNZcQAAnRRk1gvX1dUpOjraN3a5XNqxY4dvvH//fvXp00fz5s3Tp59+qkGDBunhhx/267U9Ho+OHz+u4OBgORyOLs8OAN2R1+tVa2urevfuLafT//0E04rC4/F0+CXu9Xo7jNva2rRt2zb95S9/UVxcnJ5++mktWbJES5YsOedrHz9+XHv27DElNwB0d9dcc43Cw8P9Xt60ooiNjVVVVZVvXF9fL5fL5RtHR0drwIABiouLkyRlZGQoLy/Pr9cODg6WdOrNhoSEdGFqAOi+Tp48qT179vh+h/rLtKJITk7WihUr5Ha71atXL5WXl+uxxx7zPT9q1Ci53W599tlnuvbaa7Vp0yYNHz7cr9c+vWcSEhKi0NBQU/IDQHd1vofsTSuKmJgY5efnKycnR62trcrKylJ8fLxyc3OVl5enuLg4Pffcc5o/f76ampoUGxurpUuXmhUHANBJjkvxxkUtLS2qrq7WiBEj2KMAAD919ncnV2YDAAxRFABsy+12a86cOTpy5IjVUQIaRQHAttatW6fdu3dr3bp1VkcJaBQFAFtyu91699135fV69c4777BXYSGKAoAtrVu3Th6PR9KpC3jZq7AORQHAljZv3qy2tjZJp2ZyeO+99yxOFLgoCgC2NGbMGAUFnbrUKygoSGPHjrU4UeCiKADYUnZ2tm/iOqfTqezsbIsTBS6KAoAtRUVFady4cXI4HBo/frwiIyOtjhSwTJvCAwAuVHZ2tvbv38/ehMXYowAAGKIoANgWF9zZA0UBwJa44M4+KAoAtsQFd/ZBUQCwJS64sw+KAoAtccGdfVAUAGyJC+7sg6IAYEtccGcfXHAHwLa44M4eKAoAthUVFaUlS5ZYHSPgcegJAGCIogAAGKIoAACGKAoAgCGKAgBgiKIAABiiKAAAhigKAIAhigIAYIiiAAAYoigA2Jbb7dacOXO4u53FTC2KkpISTZ48WRMnTlRhYeEZzz/77LMaO3asbrjhBt1www0/uAyAwMU9s+3BtEkBa2trtXz5chUXFyskJETZ2dlKTEzU4MGDfctUV1dr2bJlGjVqlFkx4Ae3262lS5fqwQcfZCpn2Mb375mdnZ3N59Mipu1RVFRUKCkpSREREQoLC1N6erpKS0s7LFNdXa2XXnpJmZmZWrhwoVpaWsyKAwNstcGOuGe2fZhWFHV1dYqOjvaNXS6XamtrfePjx49r6NChuv/++7VhwwZ99913ev75582Kg7P4/lYbx4JhF9wz2z5MO/Tk8XjkcDh8Y6/X22Hcu3dvrVy50jeeOXOm5s2bp/z8fL/XUV1d3TVhA9hbb72l9vZ2SVJ7e7ueeeYZZWRkWJwKkIYPH66PP/5Y7e3t6tGjh4YPH67t27dbHSsgmVYUsbGxqqqq8o3r6+vlcrl84wMHDqiiokJZWVmSThXJ6Rup+2vEiBEKDQ3tmsAB6oknnuhQFLt27dKCBQssTgVIAwcOVG5urq8o8vLyOEdxgVpaWjq1gW3aoafk5GRVVlbK7XarqalJ5eXlSklJ8T3fs2dPPfnkk/r666/l9XpVWFioCRMmmBUHZzFmzBhfQQcFBWns2LEWJwJO4Z7Z9mFaUcTExCg/P185OTmaMmWKMjIyFB8fr9zcXO3cuVNRUVFauHCh7rrrLv3iF7+Q1+vVbbfdZlYcnEV2dnaHE4bcmxh2kp2drWHDhvG5tJjD6/V6rQ5xvk7vPnHo6cK53W7ddttt8ng8cjqdWr16NVtuQDfV2d+dXJkd4NatW+f7koHD4eAriADOQFEEuM2bN3c4mc1XEAF8H0UR4DiZDeBcKIoAl52dLafz1MfA6XRy0hDAGSiKAMdXEAGci2kX3OHSkZ2drf3797M3AeAHURQW2rRpkzZu3Gh1DB09elSStHTpUktzTJgwQWlpaZZmAHAmigJyu92SpIiICIuTwE7ssCFzeiPGDp/NQN6QoSgslJaWZosP3ty5cyVJixcvtjgJ0BEbMfZAUQD4QXbYkGEjxh741hMAwBBFAQAwRFEAAAxRFAAAQxQFAMAQRQEAMERRAAAMURQAAEMUBQDAEEUBADBEUQAADFEUAABDFAUAwBBFAQAwRFEAAAxRFAAAQxQFAMAQRQEAMERRAAAMURQAAEMUBQDAEEUBADBkalGUlJRo8uTJmjhxogoLC8+63ObNm5WWlmZmFABAJwWZ9cK1tbVavny5iouLFRISouzsbCUmJmrw4MEdljt06JCeeOIJs2IAAC6QaXsUFRUVSkpKUkREhMLCwpSenq7S0tIzlps/f77uueces2IAAC6QaUVRV1en6Oho39jlcqm2trbDMq+++qqGDRumkSNHmhUDAHCBTDv05PF45HA4fGOv19thvGfPHpWXl2v16tU6ePBgp9ZRXV19wTkhNTQ0SJK2b99ucRKgIz6b9mBaUcTGxqqqqso3rq+vl8vl8o1LS0tVX1+vX//612ptbVVdXZ2mT5+utWvX+r2OESNGKDQ0tEtzB6KioiJJUkJCgsVJgI74bHatlpaWTm1gm3boKTk5WZWVlXK73WpqalJ5eblSUlJ8z+fl5amsrExvvPGGCgoK5HK5zqskAAAXh2lFERMTo/z8fOXk5GjKlCnKyMhQfHy8cnNztXPnTrNWCwDoYqYdepKkzMxMZWZmdnhs5cqVZyzXv39/bdq0ycwoAIBO4spsAIAhv4uira3tjMeOHTvWpWEAAPZzzqKorq7W2LFjNWrUKN17771qbGz0Pfeb3/zGzGwAABs4Z1EsWrRIjzzyiDZv3qygoCDNmjVLJ0+elHTq2ggAQPd2zqJobm5WamqqrrzySv3pT3+Sy+XS3LlzL0Y2AIANnLMoPB6PDh8+7Bs/8cQT2rt3r5577rkOV1oDALqncxbFzJkzNWXKFL3//vuSpF69eumFF15QcXGx9uzZY3pAAIC1znkdxQ033KD4+HiFhIT4HuvXr5/efPNNw3tMAAC6B78uuBs4cKAk6YsvvlBlZaWCgoKUnJysO+64w9RwAADr+X0dxWuvvaacnBzt2LFDVVVVmj59usrKyszMBgCwAb+n8Fi9erU2bNjgmwH2wIEDmj17ttLT000LBwCwnt97FMHBwR2mCe/Xr5+Cg4NNCQUAsI9z7lHs2rVLkjRkyBAtXLhQ06ZNU48ePVRcXKzrrrvO9IAAAGudsyh++9vfdhhv3rzZ92eHw6H58+d3eSgAgH2csyj8mf77lVde0cyZM7skEADAXrpkmvGSkpKueBkAgA11SVEwOSAAdF9dUhTM+QQA3Rd3uAMAGKIoAACGOEcBADB0XkXR3Nyszz//XF6vV01NTb7Hb7/99i4PBgCwB7+L4pNPPtH48eM1e/Zs1dbWasyYMfrnP/8pScrMzDQtIADAWn4XxdKlS7V69WpFREQoNjZWS5cu1aJFi8zMBgCwAb+Lorm5WYMHD/aNU1NT1d7ebkooAIB9+F0UQUFBOnbsmO+aiZqaGtNCAQDsw+/7Udx111265ZZbdOjQIf3+97/Xli1btHDhQjOzAQBswO+iGDt2rAYNGqQtW7bI4/Ho7rvv1tVXX21mNgCADfhdFJLkdDo1ffp0vffeeyotLVVOTo7Cw8PNymaqlStXcvjs/53+e5g7d67FSexh0KBBys3NtToGYBt+F8Uf/vAHSdKtt96qhx9+WNdff73mzZunFStWmBbOTDU1Nare/bl69IywOorlPG09JEmf1tRanMR67c1HrY4A2I7fRVFdXa2ioiIVFBRo6tSpuu+++3TjjTeamc10PXpGKGzAOKtjwEZOfPWu1REA2/H7W09er1dOp1NbtmxRUlKSpFNfmTVSUlKiyZMna+LEiSosLDzj+Y0bNyozM1O//OUvNWfOHJ08efI84wMAzOb3HsVVV12l3NxcffPNNxo9erTuu+8+DRky5KzL19bWavny5SouLlZISIiys7OVmJjouxbjxIkTWrhwoTZs2KA+ffooPz9fGzZs0LRp0y78XQGXMM6f/Qfnzzqy6vyZ30WxePFibdy4UQkJCQoODtZPfvITTZky5azLV1RUKCkpSRERp84BpKenq7S0VPfcc48kKSwsTJs2bVJwcLCampp0+PBhXX755Rf4doBLX01Njf73012Kvey8vmvSLfXyeiRJDV9/bnES6x1sbLNs3X5/EsPCwpScnKxjx45p7969+ulPf6p///vfHa7W/m91dXWKjo72jV0ul3bs2NFhmeDgYL3//vt64IEH5HK59POf/7yTbwPoXmIvC9Jt8VFWx4CNrNrhtmzd57VHUVhYqMsuu8z3mMPhUGVl5Q8u7/F4Otz5zuv1/uCd8FJTU7V161YtW7ZMjzzyiJ566im/w1dXV/u97Pc1NDR0+mfRvTU0NGj79u2Wrh/4IVZ9Nv0uio0bN+rDDz9UZGSkX8vHxsaqqqrKN66vr5fL5fKNjx49qurqat9eRGZmpvLz8/2NI0kaMWKEQkNDz+tnTisqKpLqT3TqZ9G9hYeHKyEhwbL1FxUVqYFv6eIHXOhns6WlpVMb2H5/6+nHP/7xeZ1DSE5OVmVlpdxut5qamlReXq6UlBTf816vV/fff78OHDggSSotLdV11113HtEBABeD33sUM2bM0C233KLExEQFBf3nx06fnP6+mJgY5efnKycnR62trcrKylJ8fLxyc3OVl5enuLg4PfbYY5o9e7YcDocGDx6sRx999MLfEQCgS/ldFAUFBbrsssvO6/hpZmbmGTc1Wrlype/P48eP1/jx4/1+PQDAxed3UTQ1Nemvf/2rmVkAADbk9zmKgQMH6rPPPjMzCwDAhvzeo/j222+VlZWlH/3oRwoJCfE9XlJSYkowAIA9+F0UJ06c0CuvvGJmFgCADZ3XldlXXXWVYmNjzcwDALCZ8zqZPW7cOMXGxiosLMz3OIeeAKB787soHnroITNzAABsyu+iGD16tJk5LrojR46ovfkoN6pBB+3NR3XkSMi5FwQCiN9fjwUABKaAnfA+MjJSB4+c5Fao6ODEV+/6PfElECjYowAAGKIoAACGKAoAgCGKAgBgiKIAABiiKAAAhigKAIAhigIAYIiiAAAYoigAAIYoCgCAoYCd6wmwqyNHjuhQY5tW7XBbHQU2crCxTW1HjliybvYoAACG2KMAbCYyMlJBjXW6LT7K6iiwkVU73Aq3aGZj9igAAIYoCgCAIYoCAGCIogAAGKIoAACGKAoAgKGA/npse/NRnfjqXatjWM7T1ixJcgb1tDiJ9dqbj0qKsToGYCsBWxSDBg2yOoJt1NTUSJIGDeIXpBTDZwP4HlOLoqSkRC+88ILa2tp066236uabb+7w/DvvvKMVK1bI6/Wqf//+Wrx4sa644gozI/nk5uZelPVcCubOnStJWrx4scVJANiRaecoamtrtXz5cq1du1avv/661q9fr7179/qeb2xs1COPPKKCggK9+eabGjJkiFasWGFWHABAJ5lWFBUVFUpKSlJERITCwsKUnp6u0tJS3/Otra1asGCBYmJOHe4YMmSIvv32W7PiAAA6ybSiqKurU3R0tG/scrlUW1vrG0dGRmrChAmSpObmZhUUFGj8+PFmxQEAdJJp5yg8Ho8cDodv7PV6O4xPa2ho0N13361rr71WU6dOPa91VFdXX3BOnPo3kKTt27dbnATSf/49gO9raGiw5P+paUURGxurqqoq37i+vl4ul6vDMnV1dbr99tuVlJSkefPmnfc6RowYodDQ0AvOGuiKiookSQkJCRYngXTq36PhqNUpYEfh4eEX9P+0paWlUxvYph16Sk5OVmVlpdxut5qamlReXq6UlBTf8+3t7brzzjs1adIkPfTQQz+4twEAsJ5pexQxMTHKz89XTk6OWltblZWVpfj4eOXm5iovL08HDx7U7t271d7errKyMkmn9hAWLVpkViQAQCeYeh1FZmamMjMzOzy2cuVKSVJcXJw+++wzM1cPAOgCAXtlNmBnB7lntiSp8aRHknRZCNPSHWxsU7hF66YoAJthCpH/qP//6WX6/g9/J+Gy7rNBUQA2w/Qy/8H0MvbA/hwAwBBFAQAwRFEAAAxRFAAAQxQFAMAQRQEAMERRAAAMURQAAEMUBQDAEEUBADBEUQAADFEUAABDFAUAwBBFAQAwRFEAAAxRFAAAQxQFAMAQRQEAMERRAAAMURQAAEMUBQDAEEUBADAUZHWAQLZp0yZt3LjR6hiqqamRJM2dO9fSHBMmTFBaWpqlGQCciaKAoqKirI4AwMYoCgulpaWxBQ3A9jhHAQAwRFEAAAxRFAAAQxQFAMCQqUVRUlKiyZMna+LEiSosLDzrcg888ICKi4vNjAIA6CTTiqK2tlbLly/X2rVr9frrr2v9+vXau3fvGcvceeedKisrMysGAOACmVYUFRUVSkpKUkREhMLCwpSenq7S0tIOy5SUlGjcuHGaNGmSWTEAABfItOso6urqFB0d7Ru7XC7t2LGjwzKzZs2SJG3fvr1T66iuru58QAC219DQIKnzvyPQNUwrCo/HI4fD4Rt7vd4O464wYsQIhYaGdulrArCPoqIiSVJCQoLFSbqHlpaWTm1gm3boKTY2VvX19b5xfX29XC6XWasDAJjEtKJITk5WZWWl3G63mpqaVF5erpSUFLNWBwAwiWmHnmJiYpSfn6+cnBy1trYqKytL8fHxys3NVV5enuLi4sxaNYAuYIfZje0ys7EU2LMbmzopYGZmpjIzMzs8tnLlyjOWW7JkiZkxAFyimNnYHpg9FsAPYnZjnMYUHgAAQxQFAMAQRQEAMERRAAAMURQAAEMUBQDAEEUBADB0SV5H4fV6JUknT560OAkAXDpO/848/TvUX5dkUbS2tkqS9uzZY3ESALj0tLa2qmfPnn4v7/Ceb7XYgMfj0fHjxxUcHNzlU5cDQHfl9XrV2tqq3r17y+n0/8zDJVkUAICLh5PZAABDFAUAwBBFAQAwRFEAAAxRFAAAQxQFAMAQRQEAMERRAAAMURQAAEOX5FxPOH9PPfWUysrKFBkZqejoaG3ZskVPP/20UlNTtWzZMu3evVsvv/yy6urqNHPmTL344ouaNWuWIiMj1bNnT61atcrqt4BuYOvWrXrxxRcVHBysb775RmlpaQoLC9M777wjSSooKNC2bdv0zDPPKCwsTEOHDlV7e7uuueYaHT58WPfff7/+/ve/Ky8vT9u2bVNQUJAmTZqkNWvW6KabblJ8fLw+/fRTrV27VldeeaXF77b7YI8iAGzatEnbt2/XW2+9pYKCAu3evVsPPPCAPvroI0lSVVWVampq1N7erg8//FCpqamSpH379unJJ5+kJNCl/vWvf+nRRx/Va6+9psLCQkVFRam4uFhDhgzRunXr9Pjjj+vPf/6zioqKdOzYMUlSamqqKisrJUkfffSRevbsqd27d+vrr79WeHi4+vTpI0lKSUlRWVkZJdHFKIoAUFFRoUmTJikkJERXXHGFxo8fL7fbrcrKSjU2NkqShgwZol27dumDDz7Q2LFjJUlXXnml+vfvb2V0dEPXXHON+vbtq169eikyMlI/+9nPJEn9+vVTWVmZRo0apZiYGDmdTk2ZMkWSdPXVV6uxsVHHjh1TVVWVpk+frm3btumDDz7wbdhI0siRIy15T90dRREAnE6nPB5Ph8f69u0rj8ej8vJyXXfddUpMTNRHH32kXbt2adSoUZJ0XtMQA/4KDg7uMO7Ro0eHP3//s3ra9ddfr40bN8rhcCgtLU3/+Mc/9OGHH/o2bCQpNDTUnNABjqIIAMnJySovL9fJkyfV2NiozZs3y+FwKCUlRS+88IJGjx6tpKQkrVmzRiNHjuzwHxe4mEaNGqWdO3eqrq5OXq9Xb7/9tu9WAqmpqXrppZeUkJCgoUOH6osvvtC+ffs0bNgwi1N3f5zMDgBjxozRxx9/rKlTp+qKK66Qy+VSaGioxowZo1WrVikhIUFhYWFqbW3tsHUGXGxRUVGaP3++Zs6cqZCQEPXv31+XX365JCkxMVH19fUaPXq0HA6Hhg4dqsjISIsTBwbuRxEAPv74Y3355ZeaOnWqWltbNW3aND3++OO69tprrY4GdHDkyBGtWbNG99xzj5xOp/74xz9qwIABmjFjhtXRAhp7FAFg4MCBevbZZ7Vq1Sp5vV5NmTKFkoAtRURE6LvvvlNGRoZ69Oih4cOH66abbrI6VsBjjwIAYIiT2QAAQxQFAMAQRQEAMERRABfB7NmzVVxcbLjM1q1blZGRcZESAf6jKAAAhvh6LPADtm7dqmXLlqlv377at2+fevXqpTvuuENr1qzRvn37NHHiRM2bN0/r16/XmjVr5HQ61adPHz388MMaOHCgamtrNWfOHNXV1alfv346fPiw77W/+OILLVq0SEePHlV7e7tmzJihrKwsC98tYIyiAM5i586dWrBggYYNG6ZZs2apoKBAr776qhobG5WSkqK4uDi9/PLLWr9+vW8G1Lvvvlt/+9vftHDhQo0cOVL33nuvvvrqK9/kdm1tbcrLy9PSpUs1fPhwNTQ0aNq0aRo8eLDF7xY4O4oCOIv+/fv75hG66qqrFB4erpCQEEVFRal3794qKyvT5MmTFRUVJUm68cYbtWjRIn3zzTeqqKjQgw8+KEkaMGCAEhMTJUlffvml9u/fr3nz5vnW09zcrN27d+vqq6++yO8Q8A9FAZxFSEhIh3FQUMf/Lqcnq/tvXq9XbW1tcjgc+u9rWU//bHt7u8LDw/XGG2/4njt06JDCw8P1ySefdGV8oMtwMhvopNGjR+vtt9+W2+2WJL322muKiIjQgAEDdP3112v9+vWSpAMHDmjr1q2STk2n0rNnT19RfPvtt8rIyFB1dbU1bwLwA3sUQCclJibK6XTq1ltvlcfjUVRUlF566SU5nU4tWLBAc+fO1aRJkxQbG+ubWyskJETPP/+8Fi1apJdfflltbW363e9+p4SEBF+ZAHbDXE8AAEMcegIAGKIoAACGKAoAgCGKAgBgiKIAABiiKAAAhigKAIAhigIAYOj/AO/9aGkY6y+cAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['rmse_b2'],x=df['model'])" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.10002993807213198" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b2 - (np.hsplit(mgwr_params_mean,3)[2]))**2))/625)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.07791108751758576" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b2 - (np.hsplit(gwr_params_mean,3)[2]))**2))/625)" + ] + } + ], + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Binomial_MGWR_MonteCarlo_Results.ipynb b/notebooks/Binomial_MGWR_MonteCarlo_Results.ipynb new file mode 100644 index 0000000..05146cc --- /dev/null +++ b/notebooks/Binomial_MGWR_MonteCarlo_Results.ipynb @@ -0,0 +1,1509 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notebook Outline:** \n", + " \n", + "- [Setup with libraries](#Set-up-Cell)\n", + "- [List bandwidths from pickles](#List-bandwidths-from-pickles)\n", + "- [Parameter functions](#Parameter-functions)\n", + "- [GWR bandwidth](#GWR-bandwidth)\n", + "- [MGWR bandwidths](#MGWR-bandwidths)\n", + "- [AIC, AICc, BIC check](#AIC,-AICc,-BIC-check)\n", + " - [AIC, AICc, BIC Boxplots for comparison](#AIC,-AICc,-BIC-Boxplots-for-comparison)\n", + "- [Parameter comparison from MGWR and GWR](#Parameter-comparison-from-MGWR-and-GWR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Monte Carlo experiment code can be found in path mgwr/notebooks/Poisson_MC_script/" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up Cell" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\msachde1\\AppData\\Local\\Continuum\\anaconda3\\envs\\gwrenv\\lib\\site-packages\\libpysal\\io\\iohandlers\\__init__.py:25: UserWarning: SQLAlchemy and Geomet not installed, database I/O disabled\n", + " warnings.warn('SQLAlchemy and Geomet not installed, database I/O disabled')\n" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pickle\n", + "import sys\n", + "import seaborn as sns\n", + "import numpy as np\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Binomial_MC_script_2/\")\n", + "import model_mc\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### List bandwidths from pickles" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_bw0=[]\n", + "mgwr_bw1=[]\n", + "mgwr_bw2=[]\n", + "gwr_bw=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,1000,50):\n", + " p1 = pickle.load( open( \"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Binomial_MC_script_2/pkls/results-{}-{}.pkl\".format(str(i), str(i+50)),\"rb\") )\n", + " for j in range(50):\n", + " mgwr_bw0.append(p1[j].mgwr_bw[0][0])\n", + " mgwr_bw1.append(p1[j].mgwr_bw[0][1])\n", + " mgwr_bw2.append(p1[j].mgwr_bw[0][2])\n", + " gwr_bw.append(p1[j].gwr_bw[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter functions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def add(a,b):\n", + " return 1+((1/120)*(a+b))\n", + "\n", + "def con(u,v):\n", + " return (0*(u)*(v))+0.3\n", + "\n", + "def sp(u,v):\n", + " return 1+1/3240*(36-(6-u/2)**2)*(36-(6-v/2)**2)\n", + "\n", + "def med(u,v):\n", + " B = np.zeros((25,25))\n", + " for i in range(25):\n", + " for j in range(25):\n", + " \n", + " if u[i][j]<=8:\n", + " B[i][j]=0.2\n", + " elif u[i][j]>17:\n", + " B[i][j]=0.7\n", + " else:\n", + " B[i][j]=0.5\n", + " return B" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)\n", + "X, Y = np.meshgrid(x, y)\n", + "\n", + "B0=con(X,Y)\n", + "#B1=add(X,Y)\n", + "B1=sp(X,Y)\n", + "B2=med(X,Y)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GWR bandwidth" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(gwr_bw)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "246.295" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(gwr_bw)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MGWR bandwidths" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(B0, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3X10XPV95/H3d2akkSzZkpFkMJaMbGxoDAYDjgOhSdNQEpNN4jzAiWke2C0pu23I9uHs2cLpCd1lk7Z0u5smLU1DAlnCKYGULa02cUIeIElDEmMZTLBxDLKNbWEby5YtybIe5uG7f8xvzHgYWSNbmhlJn9dhztz5ze/e+V4xvp+5vzv3jrk7IiIikXIXICIilUGBICIigAJBREQCBYKIiAAKBBERCRQIIiICKBBERCRQIIiICKBAEBGRIFbuAiaiubnZ29vby12GiMi0snnz5sPu3jJev2kVCO3t7XR2dpa7DBGRacXM9hTTT0NGIiICKBBERCQoKhDMbK2Z7TCzLjO7o8DzcTN7NDy/0czaQ/saM9sSbs+b2QeLXaaIiJTWuIFgZlHgXuAGYAVws5mtyOt2K3DU3ZcBnwfuCe1bgdXuvgpYC3zZzGJFLlNEREqomD2ENUCXu+9y91HgEWBdXp91wINh+jHgOjMzdz/h7snQXgNkf3yhmGWKiEgJFRMIi4B9OY+7Q1vBPiEA+oAmADN7i5ltA14A/lN4vphliohICRUTCFagLf9n1sbs4+4b3f0S4M3AnWZWU+QyMws2u83MOs2ss6enp4hyRUTkTBQTCN1AW87jVmD/WH3MLAY0AL25Hdx9OzAIXFrkMrPz3efuq919dUvLuOdViIjIGSomEDYBy81siZlVA+uBjrw+HcAtYfpG4El39zBPDMDMLgAuBl4pcpkiIlJC456p7O5JM7sdeAKIAg+4+zYzuxvodPcO4H7gITPrIrNnsD7M/uvAHWaWANLA77v7YYBCy5zkdRMRKcrDG/cW1e+337J4iispr6IuXeHuG4ANeW135UwPAzcVmO8h4KFilykiIuWjM5VFRARQIIiISKBAEBERQIEgIiKBAkFERAAFgoiIBAoEEREBFAgiIhIoEEREBFAgiIhIoEAQERFAgSAiIoECQUREAAWCiIgECgQREQEUCCIiEigQREQEUCCIiEigQBAREUCBICIigQJBREQABYKIiAQKBBERARQIIiISKBBERARQIIiISFBUIJjZWjPbYWZdZnZHgefjZvZoeH6jmbWH9uvNbLOZvRDu35kzz4/CMreE24LJWikREZm42HgdzCwK3AtcD3QDm8ysw91fzOl2K3DU3ZeZ2XrgHuAjwGHgfe6+38wuBZ4AFuXM91F375ykdRERkbNQzB7CGqDL3Xe5+yjwCLAur8864MEw/RhwnZmZuz/n7vtD+zagxszik1G4iIhMrmICYRGwL+dxN6d+yj+lj7sngT6gKa/Ph4Hn3H0kp+1rYbjoM2ZmE6pcREQmVTGBUGhD7RPpY2aXkBlG+o85z3/U3VcCbwu3jxd8cbPbzKzTzDp7enqKKFdERM5EMYHQDbTlPG4F9o/Vx8xiQAPQGx63Ao8Dn3D3ndkZ3P3VcD8APExmaOoN3P0+d1/t7qtbWlqKWScRETkDxQTCJmC5mS0xs2pgPdCR16cDuCVM3wg86e5uZo3At4E73f3pbGczi5lZc5iuAt4LbD27VRERkbMxbiCEYwK3k/mG0Hbgm+6+zczuNrP3h273A01m1gX8MZD9aurtwDLgM3lfL40DT5jZL4EtwKvAVyZzxUREZGLG/dopgLtvADbktd2VMz0M3FRgvs8Cnx1jsVcVX6aIiEw1naksIiKAAkFERAIFgoiIAAoEEREJFAgiIgIoEEREJFAgiIgIoEAQEZFAgSAiIoACQUREAgWCiIgACgQREQkUCCIiAigQREQkUCCIiAigQBARkUCBICIigAJBREQCBYKIiAAKBBERCRQIIiICKBBERCRQIIiICKBAEBGRQIEgIiKAAkFERIKiAsHM1prZDjPrMrM7CjwfN7NHw/Mbzaw9tF9vZpvN7IVw/86cea4K7V1m9kUzs8laKRERmbhxA8HMosC9wA3ACuBmM1uR1+1W4Ki7LwM+D9wT2g8D73P3lcAtwEM583wJuA1YHm5rz2I9RETkLBWzh7AG6HL3Xe4+CjwCrMvrsw54MEw/BlxnZubuz7n7/tC+DagJexMLgXnu/nN3d+DrwAfOem1EROSMFRMIi4B9OY+7Q1vBPu6eBPqAprw+Hwaec/eR0L97nGWKiEgJxYroU2hs3yfSx8wuITOM9K4JLDM7721khpZYvHjxeLWKiMgZKmYPoRtoy3ncCuwfq4+ZxYAGoDc8bgUeBz7h7jtz+reOs0wA3P0+d1/t7qtbWlqKKFdERM5EMYGwCVhuZkvMrBpYD3Tk9ekgc9AY4EbgSXd3M2sEvg3c6e5PZzu7+wFgwMyuDt8u+gTwr2e5LiIichbGDYRwTOB24AlgO/BNd99mZneb2ftDt/uBJjPrAv4YyH419XZgGfAZM9sSbgvCc78HfBXoAnYC35mslRIRkYkr5hgC7r4B2JDXdlfO9DBwU4H5Pgt8doxldgKXTqRYERGZOjpTWUREAAWCiIgECgQREQEUCCIiEigQREQEUCCIiEigQBAREUCBICIigQJBREQABYKIiAQKBBERARQIIiISKBBERARQIIiISKBAEBERQIEgIiKBAkFERAAFgoiIBAoEEREBFAgiIhIoEEREBFAgiIhIoEAQERFAgSAiIoECQUREAAWCiIgERQWCma01sx1m1mVmdxR4Pm5mj4bnN5pZe2hvMrOnzOy4mf1d3jw/CsvcEm4LJmOFRETkzMTG62BmUeBe4HqgG9hkZh3u/mJOt1uBo+6+zMzWA/cAHwGGgc8Al4Zbvo+6e+dZroOIiEyCYvYQ1gBd7r7L3UeBR4B1eX3WAQ+G6ceA68zM3H3Q3X9KJhhERKSCFRMIi4B9OY+7Q1vBPu6eBPqApiKW/bUwXPQZM7Mi+ouIyBQpJhAKbaj9DPrk+6i7rwTeFm4fL/jiZreZWaeZdfb09IxbrIiInJliAqEbaMt53ArsH6uPmcWABqD3dAt191fD/QDwMJmhqUL97nP31e6+uqWlpYhyRUTkTBQTCJuA5Wa2xMyqgfVAR16fDuCWMH0j8KS7j7mHYGYxM2sO01XAe4GtEy1eREQmz7jfMnL3pJndDjwBRIEH3H2bmd0NdLp7B3A/8JCZdZHZM1ifnd/MXgHmAdVm9gHgXcAe4IkQBlHgB8BXJnXNRERkQsYNBAB33wBsyGu7K2d6GLhpjHnbx1jsVcWVKCIipaAzlUVEBFAgiIhIoEAQERFAgSAiIoECQUREAAWCiIgECgQREQEUCCIiEigQREQEUCCIiEigQBAREUCBICIigQJBREQABYKIiAQKBBERARQIIiISFPUDOSIis9mBviGOnUiUu4wpp0AQETmNl14b4B837iGRcuZUR/mTtb9GJGLlLmtKaMhIRGQMz3cf4+s/f4Xm+jhvbp/Pl3+yi9//x2cZTabLXdqUUCCIiBTQN5Tgnzr3sficOn73bUv5wKpF/Ol73sR3tx3ksc3d5S5vSigQREQK2Lynl7TDh69cRE1VFDPjk29bwsXnzuWRTXvLXd6UUCCIiORJu9O55ygXttTRVB8/2W5m3LymjV9297Ftf18ZK5waCgQRkTxdh45z7ESCN7ef84bnPnhFK/FYhEee2VeGyqaWAkFEJM+mV3qZUx1lxcJ5b3iuYU4V71m5kH957lVOjCbLUN3UUSCIiOQYGE6w/UA/Vy2eTyxaeBN585rFDIwk+fYvD5S4uqmlQBARyfHL7j7SDqsLDBdlvbl9Pkua6+h4fn8JK5t6RQWCma01sx1m1mVmdxR4Pm5mj4bnN5pZe2hvMrOnzOy4mf1d3jxXmdkLYZ4vmtnMPNNDRKaVlw8N0FxfTcvc+Jh9zIzfuKiFTa/0MpJMlbC6qTVuIJhZFLgXuAFYAdxsZivyut0KHHX3ZcDngXtC+zDwGeC/FFj0l4DbgOXhtvZMVkBEZLIkU2l2Hx5k2YL6cfu+9cImhhNpntt7rASVlUYxewhrgC533+Xuo8AjwLq8PuuAB8P0Y8B1ZmbuPujuPyUTDCeZ2UJgnrv/3N0d+DrwgbNZERGRs7W39wSJlLOsZe64fd+ytImIwc92HilBZaVRTCAsAnK/X9Ud2gr2cfck0Ac0jbPM3FP9Ci1TRKSkunqOEzFY2lI3bt+G2ipWtjbys67DJaisNIoJhEJj+34Gfc6ov5ndZmadZtbZ09NzmkWKiJydrkPHaZ0/h5qqaFH9r72wiS37jjE4MjO+flpMIHQDbTmPW4H8Q+sn+5hZDGgAesdZZus4ywTA3e9z99XuvrqlpaWIckVEJm5oNMWrR4eKOn6Q9dYLm0mmnWd2n25zN30UEwibgOVmtsTMqoH1QEdenw7gljB9I/BkODZQkLsfAAbM7Orw7aJPAP864epFRCbJzp7jOLCspfhAWN0+n+pYhKdnyLDRuL+H4O5JM7sdeAKIAg+4+zYzuxvodPcO4H7gITPrIrNnsD47v5m9AswDqs3sA8C73P1F4PeA/wPUAt8JNxGRsug6dJx4LELbOXOKnqemKspVi+fz9Aw5sFzUD+S4+wZgQ17bXTnTw8BNY8zbPkZ7J3BpsYWKiEylXYePs6S5jugEf/zmrRc28b++/xLHTozSOKd6iqorDZ2pLCKz3uBIksPHR7mgafxvF+W76oL5AGzZN/3PR1AgiMist7f3BACLJzBclLWytQEzBYKIyIywt/cEEYPW+bUTnnduTRXLF9QrEEREZoK9vSc4v7GWqjGubjqeVW2NPL/vGKf5cuW0oEAQkVktkUrTffTEGQ0XZa1qm8/REwn2HDkxiZWVngJBRGa17Qf6SaT8LAOhEZj+xxEUCCIyq23ecxTgjL5hlHXRufXUVkUVCCIi09mze4/RUFtFQ23VGS8jFo2wsrWB5xQIIiLT17N7jp7VcFHWFW2NbN/fP61/MEeBICKz1sG+YV49NjQpgbCqrZHRVJoX9/dPQmXloUAQkVnr2b2Z4weTEgiLp/+BZQWCiMxam/ccJR6LsLCx5qyXtbChlnPnxRUIIiLT0eY9R7m8tZFYZHI2hVe0zVcgiIhMN8OJFNv293HFBY2TtsxVixvZc+QEvYOjk7bMUlIgiMistPXVPhIp56rF8ydtmdkT1J6fpnsJCgQRmZWyJ6RdecHkBcLKRQ1EjGl7PoICQURmpc17jtLeNIfm+vikLbMuHuOic+dO2+MICgQRmXXcnWf3HuPKSRwuyrpi8fS98qkCQURmnX29Qxw+PjKpw0VZq9oa6RtKsPvw4KQve6opEERk1tm8txd4/ecvJ9Oqtun7k5oKBBGZdTbvOUp9GO+fbMsW1FNXPT2vfKpAEJFZZ9Puo1x5wXyiEZv0ZUcjxmWtjQoEEZFKd3RwlB2vDbCmffKHi7JWLW5k+4F+hhPT68qnCgQRmVU6w/kHa5Y0TdlrrGprJJFytk2zK58qEERkVnlm9xGqYxEua22Yste4Ypr+pKYCQURmlWd297KqrZGaquiUvcaCeTWc31AzMwPBzNaa2Q4z6zKzOwo8HzezR8PzG82sPee5O0P7DjN7d077K2b2gpltMbPOyVgZEZHTGRxJsnV/P2vaz5ny11q1uJEt+45O+etMpnEDwcyiwL3ADcAK4GYzW5HX7VbgqLsvAz4P3BPmXQGsBy4B1gJ/H5aX9ZvuvsrdV5/1moiIjOPZvUdJpZ01S0oQCG2N7Osd4sjxkSl/rclSzB7CGqDL3Xe5+yjwCLAur8864MEw/RhwnZlZaH/E3UfcfTfQFZYnIlJyz+zuJRqxKTlDOd90PEGtmEBYBOzLedwd2gr2cfck0Ac0jTOvA98zs81mdtvESxcRmZiNu3u59Px51MdjU/5aKxc1EI3YjAuEQmdu5F+1aaw+p5v3Wne/ksxQ1KfM7O0FX9zsNjPrNLPOnp6eIsoVEXmj4USKLfuO8eYSHD8AqK2OcvE0u/JpMYHQDbTlPG4F9o/Vx8xiQAPQe7p53T17fwh4nDGGktz9Pndf7e6rW1paiihXROSNfrHrCKPJNL++vLlkr5k5sHyMdHp6XPm0mEDYBCw3syVmVk3mIHFHXp8O4JYwfSPwpGeu/doBrA/fQloCLAeeMbM6M5sLYGZ1wLuArWe/OiIihf1oRw/xWISrl07dCWn5VrU1MjCcZNc0ufLpuANp7p40s9uBJ4Ao8IC7bzOzu4FOd+8A7gceMrMuMnsG68O828zsm8CLQBL4lLunzOxc4PHMcWdiwMPu/t0pWD8REQB+/FIP11zYNKXnH+TLXk110yu9LFtQX7LXPVNFHVlx9w3Ahry2u3Kmh4Gbxpj3c8Dn8tp2AZdPtFgRkTOx58gguw8Pcss1F5T0dZc213HuvDg/23mEm9csLulrnwmdqSwiM96PdmS+kPKOixeU9HXNjGuWNvHznUemxS+oKRBEZMb70Y5DtDfNob25ruSv/dYLmzl8fISuQ8dL/toTpUAQkRltOJHi57uOlHzvIOuaCzMHsX+280hZXn8iFAgiMqNt3N3LcCLNb1xUnq+tt50zh9b5tfxs5+GyvP5EKBBEZEb71vP7qauOlvTrpvmuWdrEL3b1Vvz5CAoEEZmxhkZTfGfrQW5YuZDa6tJ93TTfW5c10TeU4MUDlf2DOQoEEZmxvr/9NY6PJPnQFfmXXyuta5Zmzo7+eYUfR1AgiMiM9fiz3SxsqCnrcBHAeQ01LG2p48cvVfb12BQIIjIj9QyM8JOXD7Nu1SIikULX2Sytd604j1/sOsKxE6PlLmVMCgQRmZH+3/P7SaWdD11Z3uGirLWXnkcy7fxg+6FylzImBYKIzDjptPPNzn1ccv48Ljp3brnLAeDy1gYWNtTw3a0Hy13KmBQIIjLjfO/F1/jVwQE++bYl5S7lJDPj3Zecx09e7mFwJFnucgpSIIjIjJJOO1/44cssaa7jfZedX+5yTnHDpecxmkzz1I7KHDZSIIjIjPL97a+x/UA/n37nMmLRytrErW4/h+b66oodNqqsv5aIyFlwd77wg5dpb5rD+y+vrL0DgGjEuH7FeTz1q0OcGK28YSMFgojMGA/9Yg8vHujn0+9cXnF7B1k3XrWIwdEU//zsq+Uu5Q0q8y8mIjJBL+7v57Pf3s47Lm7hg2U+M/l0rlw8n8taG/ja07sr7tpGCgQRmfZOjCb59DeepaG2ir++6fKKOBFtLGbG71y7hJ09g/xbV2VdAVWBICLT2tBoik8//By7Dg/yNx9ZRXN9vNwljes9KxeyYG6cB366u9ylnEKBICLT1uHjI6z/yi94csch7l53Kdcuay53SUWpjkX42NUX8OOXeug6NFDuck5SIIjItJNOO48/1837//an7DjYz5c/dhUfv/qCcpc1Ib/9lsXUVkX5y+/sqJjfW46VuwARkWLtPzbE9198jW88s5dfHRzgkvPn8aWPXcXlbY3lLm3Cmuvj/NH1y/nzDb/iiW0HWXvpwnKXpEAQkcpxYjTJkeOjHD4+wpHjo/QOjvJa/zA7Xhtg+4F+dvYMAnDRufX87c1X8O9WLqzoA8jj+Z1rl/Avz+3nzzq28dZlzcyrqSprPQoEmRB3p28owYG+YQ72D3Owb5gDfcMc6h9mcDTF0GiK4USKoUSK0WSaSMSIGsQiEaIRozoWob4mxtx4jLk1MerjVZnHJ9syj+uqo9RWR6mrjlFbHSUei2A2ff/hz1ajyTS9g2EDPzjKkbChPzkd7g8fH+XQwDCJVOGhk/lzqjivoZa1l5zHmxbO4w9+a3mJ12RqxKIR/uJDK/ng3z/Nn397O3/xoZVlfZ8rEOSkdNo5PDjCwb7Mhv5gf2Zjn3380msD9A8n3vCP1oC6eIx4LEJ1LEJVNEJV1IhFIjhOOg1pd9LuJFLOSDLNSCJFMu0MJVJF1WZkDsRVxyJUR19/nWjEMjfL3C9pqaMqYlRFI8SiEaqjRiz6ek0RM2IRIxLJ3Gfnz22LmBE72TdCNALRSOQN88VjEWqro9TEoifva6oz9Z3NP+pkKs1oKs1IIp35WyVTjCTTjGan89qzz6XdSaedtGf+3p695/XH2bHqbH1mYOROv96WuwpmlvNc5nEilWZgOMnxkSQDwwkGhpPhlqBvKMGRwVEGhgufjRuNGHXVUerjMeriMRbMjbOkuY66eIz6eDTcZ56rq45RHTv1cOfDG/ee8d+30lze1sjvvn0pX/7xLs6dV8MfXX9R2WpRIMwSiVSaQwOvb+wP9A1l7vuHeS37Kb/AJ7RYxDh3Xg3nNdRwfmMtb6qdx7zaKubVxGioraKhtoq5NVVEz3C3PZX2kxu54WSK4UQmLEZSaRLJzIZxNGzwTk6H+0QqTSoNI4kUaX99WYmUh42qk0xnlpNIO4lUmlIcuzOD2qooNVVRamIRaqqjxGNR3J1UOtzCdDpMjybTJzfuqQo7WWk8ddVR5tZUZfbyamI0zqmm7Zw5NNfHaaqrZmfP4MmNfHZDrz2+U/3Ju3+N3uOjfOGHL1MVNW5/Z3n2gIoKBDNbC3wBiAJfdfe/zHs+DnwduAo4AnzE3V8Jz90J3AqkgP/s7k8Us0w5PQ+ftocSKfqHEhwaGKFnYISe4+F+YIQte48yMJKkbyjB8eEk+ZuZqqgxryazUW+ZG2fZgnrm1VbRUFPFvNrMBr8uHiMyhf9woxFjTnWMOdVT9hKncH/jJ+h0Tls6ndt+6vOe8wk85U4ylQmZRCrNFYvnnxwqGwn3w4l0uM9MZ/Y0Tt1Lye7ZZPeu4rHM8NiLB/qJRoyqSIRY2MuJhb2Tk9NhLywWtZPLjZD36T/n03522nHCfzl/l3BfxHOZaYiYEa+KjPv+aJoG5wWUWyRi/OWHLyOZdv76ey+xbX8/f/a+SzivoaakdYwbCGYWBe4Frge6gU1m1uHuL+Z0uxU46u7LzGw9cA/wETNbAawHLgHOB35gZtn9ofGWOSO4ZzfamV3p/uEk/WH3un8oweBIkqGTG5I0Q6OpkxuR3I3JUCIzPj+STJ3sM9YHSTNoqqsmFokwtybGefNqcjb0mQCYVxujtio66z6lmWWOaUSZ/PWuCXsFk+Fty1smZTmFza7/59NFNGL8zxsvY9mCer74w5f5t5cP8x+ubecDVyziwpb6ktRQzB7CGqDL3XcBmNkjwDogd+O9DvhvYfox4O8ss6VZBzzi7iPAbjPrCsujiGVOmu9uPYA7tMyNM7+umpqqKNXRCPGqCPFYhFgkktl9z/nUmHLH05BMp09+2stupHMPnPYNJTh2ItyGRuk7keDYUIJjJ0bpG0pydHCUVBHjFNlPfNUnx7szY97Z6ZpYhLnxGFVhDD23b01VhPp4Zpc9c0A2dsZDOCJSPrFohE/95jLee9lC/se3tnPvU1387ZNdrFzUwAP//s20zJ3ava1iAmERsC/ncTfwlrH6uHvSzPqAptD+i7x5s1edGm+Zk+avvruDXYcHp2rxANTHM0MsjXMyt187LzPWvv/YELVVUeJVkVPHlcN0PBahKjb+breIzB4XNNXx1VtWc6h/mI7n97Nxdy/N9VM/rlpMIBTaUuV/5B2rz1jthc6QLvgx2sxuA24LD4+b2Y4x6gRoBirralHjU82loZpLY0bX/NEpLuR0vnrLKQ8n+ncu6jTuYgKhG2jLedwK7B+jT7eZxYAGoHececdbJgDufh9wXxF1Ymad7r66mL6VQjWXhmouDdVcGlNVczHXMtoELDezJWZWTeYgcUdenw4gm183Ak965gvPHcB6M4ub2RJgOfBMkcsUEZESGncPIRwTuB14gsxXRB9w921mdjfQ6e4dwP3AQ+GgcS+ZDTyh3zfJHCxOAp9y9xRAoWVO/uqJiEixijoPwd03ABvy2u7KmR4Gbhpj3s8BnytmmZOgqKGlCqOaS0M1l4ZqLo0pqdkq5bKrIiJSXvo9BBERAWZIIJjZWjPbYWZdZnZHuevJZWYPmNkhM9ua03aOmX3fzF4O9/NDu5nZF8N6/NLMrixDvW1m9pSZbTezbWb2B9Og5hoze8bMng81//fQvsTMNoaaHw1fYCB8yeHRUPNGM2svdc05tUfN7Dkz+9Y0qvkVM3vBzLaYWWdoq9j3R6ij0cweM7Nfhff2NZVcs5ldHP6+2Vu/mf3hlNfs7tP6Ruag9E5gKVANPA+sKHddOfW9HbgS2JrT9lfAHWH6DuCeMP0e4Dtkzt+4GthYhnoXAleG6bnAS8CKCq/ZgPowXQVsDLV8E1gf2v8B+L0w/fvAP4Tp9cCjZXx//DHwMPCt8Hg61PwK0JzXVrHvj1DHg8Anw3Q10FjpNefUHgUOkjmXYEprLttKTuIf6xrgiZzHdwJ3lruuvBrb8wJhB7AwTC8EdoTpLwM3F+pXxtr/lcw1p6ZFzcAc4FkyZ74fBmL57xMy3267JkzHQj8rQ62twA+BdwLfCv+YK7rm8PqFAqFi3x/APGB3/t+rkmvOq/NdwNOlqHkmDBkVurTGojH6Vopz3f0AQLhfENoral3CsMQVZD5xV3TNYehlC3AI+D6ZvcZj7p69IH9uXadcagXIXmql1P4G+K9AOjxuovJrhsxVBb5nZpstcyUBqOz3x1KgB/haGJ77qpnVUdk151oPfCNMT2nNMyEQirm0xnRRMetiZvXA/wX+0N37T9e1QFvJa3b3lLuvIvOpew3wpkLdwn3Zazaz9wKH3H1zbnOBrhVTc45r3f1K4AbgU2b29tP0rYS6Y2SGbb/k7lcAg2SGW8ZSCTUDEI4hvR/4p/G6FmibcM0zIRCKubRGpXnNzBYChPtDob0i1sXMqsiEwT+6+z+H5oquOcvdjwE/IjOO2miZS6nk13WyZjv1UiuldC3wfjN7BXiEzLDR31DZNQPg7vvD/SHgcTIBXMnvj26g2903hsePkQmISq456wbgWXd/LTye0ppnQiBMx8tg5F7q4xYy4/TZ9k+EbwxcDfRldw9LxcyMzJnn2939f+c8Vck1t5hZY5iuBX4L2A48ReZDjymQAAABCUlEQVRSKoVqLnSplZJx9zvdvdXd28m8Z590949SwTUDmFmdmc3NTpMZ395KBb8/3P0gsM/MLg5N15G5ekLF1pzjZl4fLoKprrlcB0om+aDLe8h8G2Yn8Kflrievtm8AB4AEmRS/lczY7w+Bl8P9OaGvkfnhoJ3AC8DqMtT762R2NX8JbAm391R4zZcBz4WatwJ3hfalZK6d1UVmlzse2mvC467w/NIyv0fewevfMqromkN9z4fbtuy/t0p+f4Q6VgGd4T3yL8D8aVDzHDK/QNmQ0zalNetMZRERAWbGkJGIiEwCBYKIiAAKBBERCRQIIiICKBBERCRQIIiICKBAEBGRQIEgIiIA/H/JwIcdSxazAAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(mgwr_bw0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "538.887" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw0)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(B1, extent=[0,25, 0, 25], origin='lower',cmap='RdBu_r')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "179.233" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw1)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xt8XdV95/3P75yjo7tk6+K7jWRsDOJOjIHCq03iBEyfNM7TgcbQdmjDDPOaQhum6aTw5NW0ZcpMeKYtIYHkGQZoINPEJE4yUVMXlxaYhjQxFuYqG4Ns2VhItmVL1v12zvk9f5wtIcu6HOt2dKTv+/XSy3uvs/bWWra8v1r7sra5OyIiIqF0N0BEROYGBYKIiAAKBBERCSgQREQEUCCIiEhAgSAiIoACQUREAgoEEREBUgwEM9tiZgfMrM7M7hvl82wzezb4fLeZVQTlpWb2opl1mtmjI7aJmtnjZvaumb1jZv9mOjokIiKTE5mogpmFgceATwINwB4zq3b3fcOq3Qm0uvs6M9sGPAR8FugF/gS4JPga7kvACXe/wMxCQMlEbSkrK/OKioqJeyUiIkNeffXVk+5ePlG9CQMB2ATUufshADPbDmwFhgfCVuDPguUdwKNmZu7eBbxsZutG2e/ngAsB3D0BnJyoIRUVFdTU1KTQZBERGWRmR1Kpl8opo5XA0WHrDUHZqHXcPQa0AaXjNG5RsPhfzGyvmX3fzJaOUfcuM6sxs5rm5uYUmisiIpORSiDYKGUjZ8RLpc5wEWAV8DN3vwr4OfCXo1V098fdfaO7bywvn3DEIyIik5RKIDQAq4etrwIax6pjZhGgGGgZZ5+ngG7gR8H694GrUmiLiIjMkFQCYQ+w3swqzSwKbAOqR9SpBu4Ilm8BXvBx5tUOPvs74KNB0WbOvCYhIiKzbMKLyu4eM7N7gF1AGHjK3WvN7AGgxt2rgSeBb5tZHcmRwbbB7c3sMFAERM3sM8CNwR1Kfxxs81WgGfjd6e2aiIicC8ukF+Rs3LjRdZeRiMi5MbNX3X3jRPX0pLKIiAAKBBERCSgQREQESO1JZZnDvrP7/VHLb79mzSy3REQynUYIIiICKBBERCSgQBAREUCBICIiAQWCiIgACgQREQkoEEREBFAgiIhIQIEgIiKAAkFERAIKBBERARQIIiISUCCIiAigQBARkUBKgWBmW8zsgJnVmdl9o3yebWbPBp/vNrOKoLzUzF40s04ze3SMfVeb2dtT6YSIiEzdhIFgZmHgMeBmoAq4zcyqRlS7E2h193XAw8BDQXkv8CfAH42x718HOifXdBERmU6pjBA2AXXufsjd+4HtwNYRdbYCTwfLO4DNZmbu3uXuL5MMhjOYWQHwh8BfTLr1IiIybVIJhJXA0WHrDUHZqHXcPQa0AaUT7Pe/AH8FdI9XyczuMrMaM6tpbm5OobkiIjIZqQSCjVLmk6jzYWWzK4B17v6jib65uz/u7hvdfWN5eflE1UVEZJJSCYQGYPWw9VVA41h1zCwCFAMt4+zzOuAjZnYYeBm4wMxeSq3JIiIyE1IJhD3AejOrNLMosA2oHlGnGrgjWL4FeMHdxxwhuPs33X2Fu1cANwDvuvtHz7XxIiIyfSITVXD3mJndA+wCwsBT7l5rZg8ANe5eDTwJfNvM6kiODLYNbh+MAoqAqJl9BrjR3fdNf1dERGQqJgwEAHffCewcUfblYcu9wK1jbFsxwb4PA5ek0g4REZk5elJZREQABYKIiAQUCCIiAigQREQkoEAQERFAgSAiIgEFgoiIAAoEEREJKBBERARQIIiISECBICIigAJBREQCCgQREQEUCCIiElAgiIgIoEAQEZGAAkFERIAUA8HMtpjZATOrM7P7Rvk828yeDT7fbWYVQXmpmb1oZp1m9uiw+nlm9vdm9o6Z1ZrZV6arQyIiMjkTBoKZhYHHgJuBKuA2M6saUe1OoNXd1wEPAw8F5b3AnwB/NMqu/9LdLwSuBK43s5sn1wUREZkOqYwQNgF17n7I3fuB7cDWEXW2Ak8HyzuAzWZm7t7l7i+TDIYh7t7t7i8Gy/3AXmDVFPohIiJTlEogrASODltvCMpGrePuMaANKE2lAWa2CPg14J9TqS8iIjMjlUCwUcp8EnXO3rFZBPgu8DV3PzRGnbvMrMbMapqbmydsrIiITE4qgdAArB62vgpoHKtOcJAvBlpS2PfjwHvu/tWxKrj74+6+0d03lpeXp7BLERGZjFQCYQ+w3swqzSwKbAOqR9SpBu4Ilm8BXnD3cUcIZvYXJIPj3nNrsoiIzITIRBXcPWZm9wC7gDDwlLvXmtkDQI27VwNPAt82szqSI4Ntg9ub2WGgCIia2WeAG4F24EvAO8BeMwN41N2fmM7OiYhI6iYMBAB33wnsHFH25WHLvcCtY2xbMcZuR7vuICIiaaInlUVEBFAgiIhIQIEgIiKAAkFERAIKBBERARQIIiISUCCIiAigQBARkYACQUREAAWCiIgEFAgiIgIoEEREJJDS5HYyN3xn9/vpboKIzGMaIYiICKBAEBGRgAJBREQABYKIiAQUCCIiAqR4l5GZbQEeIflO5Sfc/SsjPs8GngE+ApwCPuvuh82sFNgBXA18y93vGbbNR4BvAbkkX8/5eXf3KfdoAWnrGeDZPe9TlJvFtqvXTFh/tLuUbr9m4u1EZGGYcIRgZmHgMeBmoAq4zcyqRlS7E2h193XAw8BDQXkv8CfAH42y628CdwHrg68tk+nAQnXkVBePvVjH4VPdHDjWQUJZKiJTlMopo01Anbsfcvd+YDuwdUSdrcDTwfIOYLOZmbt3ufvLJINhiJktB4rc/efBqOAZ4DNT6chC0t0f46mf1ZMdCXHDujL6Yglau/rT3SwRyXCpBMJK4Oiw9YagbNQ67h4D2oDSCfbZMME+ZQwn2vsYiDufumw5l60qBqCprXeCrURExpdKINgoZSPPT6RSZ1L1zewuM6sxs5rm5uZxdrlwtHQnRwMl+dksLcohZAoEEZm6VC4qNwCrh62vAhrHqNNgZhGgGGiZYJ+rJtgnAO7+OPA4wMaNG3WiHGjp6seAxXlZRMIhygqyaWrrmdS+xpoOQxebRRaeVEYIe4D1ZlZpZlFgG1A9ok41cEewfAvwwnh3DLl7E9BhZteamQH/FvjxObd+gWrp6qc4NxkGACsW5WqEICJTNuEIwd1jZnYPsIvkbadPuXutmT0A1Lh7NfAk8G0zqyM5Mtg2uL2ZHQaKgKiZfQa40d33Af+RD287/YfgS1LQ0tXP4vzo0PqyohxeP3qa7r4Yedmar1BEJielo4e77yT5rMDwsi8PW+4Fbh1j24oxymuAS1JtqHyopaufC5cVDq0vX5QDQFN7L+eXF6SrWSKS4fSkcobpi8Xp7ItRMmyEsLw4F4Cm05O7jiAiAgqEjNPaNQBwRiAUZEcoyonoOoKITIkCIcO0dPUBZwYCJEcJCgQRmQoFQoZp6Rp8BmFkIORwoqOXWDyRjmaJyDygQMgwp7r6yckKkZsVPqN8WXEOCYcTHX1papmIZDoFQoZp7e6nJD9K8vGND5UVZAPJwBARmQwFQoY51dlPSV70rPLS4BRSiwJBRCZJgZBBEu6c7h6gJD/7rM+ys8LkR8Oc6tQpIxGZHAVCBmnrGSDuftYF5UGlBdkaIYjIpCkQMshYdxgNKsmPKhBEZNIUCBlk8GBfOtYIIT9KW8+Abj0VkUlRIGSQ1u5+QgZFuVmjfl6SH8X58H0J44knnAPH2vXqTREZokDIIB29MQqyI4RDo71fKHkNAaClc+JAeOVwC0///AjP7jlKPKFQEBEFQkbp6B2gIGfsCWoHry2k8ixC7QdtZEdCvPVBG9/ZfYQBnWYSWfAUCBmkszdGYfbop4sA8qNhsiOhCQOhqy9G/ckurju/lE9fvoL9xzp46cCJ6W6uiGQYBUIG6eiNUTjOCMHMKM2PDk2AN5Z3jrXjwMUrirl2bSmrFudy+FT3NLdWRDKNAiFDxBNOZ9/4gQCp3Xpa29jOorwsVhQnX6yTfAVnD+O89VREFgAFQoY41dWHAwU5Y58yguSF5daugTEvFPcNxHnvRCcXLy8amg9pRXEuvQMJWrsHprvZIpJBUgoEM9tiZgfMrM7M7hvl82wzezb4fLeZVQz77P6g/ICZ3TSs/D+ZWa2ZvW1m3zWznOno0HzVHMxiWjjBO5NL8qPE3Wkc4+1pB453EE84VSuKh8pWBK/gHGsbEVkYJgwEMwsDjwE3A1XAbWZWNaLanUCru68DHgYeCratArYBFwNbgG+YWdjMVgJ/AGx090uAcFBPxjA4rfVEp4wGH1o7MsY1gX1N7eRHw5xXmjdUtrQoh5BBY5sCQWQhS2WEsAmoc/dD7t4PbAe2jqizFXg6WN4BbLbk+YitwHZ373P3eqAu2B9ABMg1swiQBzROrSvz29AIYYJTRoO3nh5p6TrrM3fnYHMX65cWEho2fXZWOER5YTZNp/XGNZGFLJVAWAkcHbbeEJSNWsfdY0AbUDrWtu7+AfCXwPtAE9Dm7v84mQ4sFM0pjhCKcrOIhIzDJ88OhObOPrr6YlSW5Z/12YriXI0QRBa4VAJhtMdiR16xHKvOqOVmtpjk6KESWAHkm9lvjfrNze4ysxozq2lubk6hufNTc0cfOVkhssLj/5OFzFhWnMPrR0+f9Vl9EBKjBsKiXDp6Y3T06sKyyEKVSiA0AKuHra/i7NM7Q3WCU0DFQMs4234CqHf3ZncfAH4I/NJo39zdH3f3je6+sby8PIXmzk8nOnrHfShtuIrSfN442kbvQPyM8sMnuyjMjow6Od7y4MJyU5tOG4ksVKkEwh5gvZlVmlmU5MXf6hF1qoE7guVbgBc8eVN7NbAtuAupElgPvELyVNG1ZpYXXGvYDOyfenfmr+aOvnGnrRiuojSf/niCNxvahsrcnfqTXVSU5Z/1+k1InjIC3WkkspBNGAjBNYF7gF0kD9rfc/daM3vAzD4dVHsSKDWzOuAPgfuCbWuB7wH7gOeAu9097u67SV583gu8FbTj8Wnt2TxzoqNvwusHgyqCO4j2HG4ZKnu/pZv23tGvHwDkZIUpyY8qEEQWsJSOMO6+E9g5ouzLw5Z7gVvH2PZB4MFRyv8U+NNzaexC1tzRx6pFuSnVzcuOcMHSAl6pb+HujyXLdtcnw2GsQABYXpxDo04ZiSxYelI5A3T1xejuj094y+lwV1eU8OqR1qEnlncfaiEvGqa88Oz3MQ9aVpxDa1e/Zj4VWaAUCBkg1YfShttUWUJnX4z9Te0A7K4/RUVp/hnPH4xUGrxgp1Wv4RRZkFI/wkjapPpQ2nBXV5QA8Ep9CwebO2lo7eFTly0ad5vS/OToIZX3KYjI/KNAyAAnOpLn9VO9ywiSzxWsWpzLky/X09jWw6bKEj5y3uJxtxl8ynmi2VJFZH7SKaMMMDhCKJpgYruRNlWU8MHpHjZfuIRnPreJ7Eh43Pp50TA5WSFOTfA+BRGZnzRCyAAnOvrIChu50fEP6CP93sfWcdHyIn7n+ooJn3CG5At2UnmfgojMTwqEDNDc0Ud5QfaoD5SNZ92SAtYtKTinbUrys2nSswgiC5JOGWWAEx19494uOp1K86O0dvcT062nIguOAiEDNHf0UV44O+8PKs2PknDNaSSyECkQMsCJ9t5ZGyGUFCTvNDp86uzps0VkflMgzHG9A3FOdfWzctFsjRCSwTPWG9dEZP5SIMxxx4JTN8uLU5vHaKoKcyJEQsYRjRBEFhwFwhw3OPvoihQntpuqUHDrqUYIIguPAmGO+2AoEGbnlBGgQBBZoBQIc9zg3T7LimcvEErzo7zf0k3yHUcislAoEOa4xtM9lBVkTzjtxHQqKcimZyA+NGWGiCwMCoQ5rrGtd1ZPFwFD71w+rNNGIguKAmGOazzdM/S+49nyYSDoTiORhSSlQDCzLWZ2wMzqzOy+UT7PNrNng893m1nFsM/uD8oPmNlNw8oXmdkOM3vHzPab2XXT0aH5xN1pOt3D8lkeISzKi5IVNupPKhBEFpIJA8HMwsBjwM1AFXCbmVWNqHYn0Oru64CHgYeCbauAbcDFwBbgG8H+AB4BnnP3C4HLgf1T78780t4To6s/zspZuuV0UDhkrCnJo75ZgSCykKQyQtgE1Ln7IXfvB7YDW0fU2Qo8HSzvADZbcmrOrcB2d+9z93qgDthkZkXALwNPArh7v7ufnnp35pfGtuQtp7P1UNpwlWUFGiGILDCpBMJK4Oiw9YagbNQ67h4D2oDScbZdCzQDf2Nmr5nZE2aWP6kezGONaXgGYdDa8nzqT3WRSOjWU5GFIpVAGG0S/pFHibHqjFUeAa4CvunuVwJdwFnXJgDM7C4zqzGzmubm5hSaO380Bs8gzNZTysNVluXTH0sMjVJEZP5LJRAagNXD1lcBjWPVMbMIUAy0jLNtA9Dg7ruD8h0kA+Is7v64u290943l5eUpNHf+aDzdQyRklBXMzkynw1WWJQdsOm0ksnCkEgh7gPVmVmlmUZIXiatH1KkG7giWbwFe8ORjrtXAtuAupEpgPfCKux8DjprZhmCbzcC+KfZl3mk63cOy4hzCoXN7U9p0WKtAEFlwJnyFprvHzOweYBcQBp5y91ozewCocfdqkheHv21mdSRHBtuCbWvN7HskD/Yx4G53jwe7/n3gb4OQOQT87jT3LeM1nu6d9WcQBpUXZpMfDXNIdxqJLBgpvVPZ3XcCO0eUfXnYci9w6xjbPgg8OEr568DGc2nsQtPY1sPG8xan5XubGZXl+RohiCwgelJ5joonnGNtvSxPwwXlQbr1VGRhUSDMUSc7+4glPC13GA2qLMunobWbvlh84soikvEUCHPU0HsQZnHa65HWluWTcDjaoknuRBYCBcIcVXeiE4DzSvPS1obBW091YVlkYUjporLMnO/sfv+sstuvWUPN4RYW5WWxtqwgDa1KqtCtpyILikYIc9Sew61sPG8xoTQ8gzCoODeLsoKoAkFkgVAgzEHNHX3Un+zi6oqSdDeFtWUFQ6evRGR+UyDMQTWHWwDYOAcCoWpFEfua2olrkjuReU+BMAftOdxKdiTEpSuL090ULltVTHd/nEPNGiWIzHcKhDloz+EWrli9iGgk/f88l61KhtKbDW1pbomIzLT0H3HkDH0DcWob29hUmf7TRZB8Wjk/GuatDxQIIvOdAmGOOdraQ8LnxvUDSL5O8+IVxbzZoBfaicx3CoQ5pv5kFyGDq9YsSndThly6qpjaxnZi8US6myIiM0gPpqXR0ZZufvpeM0uLcliUm8XPDp6k5nArGysWU5iTle7mDblsVTF9sQTvnejkouVF6W6OiMwQBUKaJBLOvc++zqtHWofKwmZcd34pj94+6svj0mbwbqe3GtoUCCLzmAIhTXbsbeDVI6382mXLWVqUw4mOPtYvKaC0IJuS/Gi6m3eGitJ8CrMjvPVBG79x9eqJNxCRjKRAmCXD5yzq7o/x18+/y5qSPK5ZW0rIjLXl6ZuzaCKhkHHJymLe1J1GIvOaAiENnt93nN6BOFuvWEHI0jdX0XhGTroXCRv732+nP5aYE89HiMj0S+l/tpltMbMDZlZnZveN8nm2mT0bfL7bzCqGfXZ/UH7AzG4asV3YzF4zs59MtSOZIhZPsPf9Vq5as5jlaXpf8mSsWpxHfyzBG7r9VGTemjAQzCwMPAbcDFQBt5lZ1YhqdwKt7r4OeBh4KNi2CtgGXAxsAb4R7G/Q54H9U+1EJmlo7WEg7mxYVpjuppyT9UsKiIZD7Hr7WLqbIiIzJJURwiagzt0PuXs/sB3YOqLOVuDpYHkHsNnMLCjf7u597l4P1AX7w8xWAf8X8MTUu5E56k8lp5KuKM1Pc0vOTU5WmOvXlbJr3zHcJz/R3Xd2v3/Wl4jMDakEwkrg6LD1hqBs1DruHgPagNIJtv0q8EVgQT3tVH+yi6VF2eRnZ97lmy2XLONoSw/7mtrT3RQRmQGpBMJoVz1H/oo4Vp1Ry83sU8AJd391wm9udpeZ1ZhZTXNz88StncPiCef9U91Dr6bMNJ+4aCkhQ6eNROapVAKhARh+8/kqoHGsOmYWAYqBlnG2vR74tJkdJnkK6uNm9r9G++bu/ri7b3T3jeXl5Sk0d+764HQP/fEElWl8LeZUlBZkc3VFCc/VKhBE5qNUAmEPsN7MKs0sSvIicfWIOtXAHcHyLcALnjzRXA1sC+5CqgTWA6+4+/3uvsrdK4L9veDuvzUN/ZnTBl9FmakjBEieNnr3eKfejyAyD00YCME1gXuAXSTvCPqeu9ea2QNm9umg2pNAqZnVAX8I3BdsWwt8D9gHPAfc7e7x6e9GZqg/2Ul5YTYFGXj9YNCNFy8D4CdvNqW5JSIy3VI6Mrn7TmDniLIvD1vuBW4dY9sHgQfH2fdLwEuptCOTxRPOkVPdXL567sxiOhkrF+XyKxeU8+TL9dzxSxUU586dSfhEZGr0yOksaWrroS+WyOjTRYO+uGUDbT0D/H//52C6myIi00iBMEsaWnsAWFOSl+aWTN3FK4r5zBUreOrleo619aa7OSIyTRQIs6SprYfcrDCL5skpli/cuAF3+OvnD6S7KSIyTRQIs6TxdC/LF+Vgc3Qyu3O1uiSPO37pPL5X06CnjUXmicy93SWDDMQTHG/v5dq1peluypSMPPCvKclnw9JCvvS/36IwJ8KvXb4iTS0TkemgQJgFB5s7iSWcFYty0t2UaRUOGbdtWsPOt5r4T8++zrG2Xn7n+gqywiGNGkQykE4ZzYLaD5Jz/2TSdNepikZCPPE7G/nohnIe3LmfX33kp/z9m030DizYx01EMpZGCLOgtrGdrLBRXpid7qbMiKKcLJ6442r+ad9x/vwntdz9nb2ELPkOhZL8KEU5EQpzsijKzWJpUTZLCufXSElkvlAgzILaxjaWFeXM2bejTZdPVC3lVzaUs/dIK9946SCHT3Zx5FQX7b0x4okP50NcW5bP9evKuHBZ4by5yC4yHygQZpi7s6+pnarlReluyqzICoe4Zm0pB5u7hsrcne7+OO29A7x3vJOfHzrFt39xhE2VJXxaF6JF5gwFwgw72tJDR2+MFfPw+kGqzIz87Aj52RGWF+dy/boynt93jH957ySJhHP7pjWEQhopiKSbLirPsNrGNgCWz7M7jKYiHDJuungZH9uwhJojrfzZ39Wmu0kiggJhxtU2thMOGUuLFAjDmRmfrFrK9eeX8szPj/BP+46nu0kiC54CYYa93djG+iUFZIX1Vz2amy5ZxkXLi7jvh29ysrMv3c0RWdB0lJpB7s4bR09z+arMnvJ6JkVCIb762Sto74lx/w/fIvleJRFJBwXCDDra0kNr90DGvwNhpm1YVsh/vmkDz+87TvUbI9/OKiKzRXcZpWi0qRhuv2bNuNu83nAagMtXF/PG0bYZaddYMm3qiM/dUMlP3mrigb/bx69cUM6ivGi6mySy4GiEMIPeOHqanKwQFywtTHdT5rxwyPjKr19KW88A/3XnfiAZaiO/RGTmpDRCMLMtwCNAGHjC3b8y4vNs4BngI8Ap4LPufjj47H7gTiAO/IG77zKz1UH9ZUACeNzdH5mWHs0hrx89zSUriuf9BeXpOlBftLyIf//La/nmSwf5zBUrp2WfIpK6CY9UZhYGHgNuBqqA28ysakS1O4FWd18HPAw8FGxbBWwDLga2AN8I9hcDvuDuFwHXAnePss+MNhBP8PYHbbp+cI4+v3k9FaV5fPEHb9KnCfJEZlUqv7puAurc/ZC79wPbga0j6mwFng6WdwCbLTlJzVZgu7v3uXs9UAdscvcmd98L4O4dwH5gXv1KeOBYB32xhALhHOVkhfmr37icxtM97Hy7Kd3NEVlQUgmElcDRYesNnH3wHqrj7jGgDShNZVszqwCuBHan3uy5743ggvIVuuX0nH3kvBL+/S+vZc/hVg4c60h3c0QWjFQCYbRJZkbeLD5WnXG3NbMC4AfAve7ePuo3N7vLzGrMrKa5uTmF5s4Nbxw9zeK8LFaXLNw5jKbiDz95AUsKs/nh3gY6+2Lpbo7IgpBKIDQAq4etrwJG3iw+VMfMIkAx0DLetmaWRTIM/tbdfzjWN3f3x919o7tvLC8vT6G56fed3e/zf95tprwwm+++clR3x0xCdiTMZ69eTc9AnB2vHiWhB9ZEZlwqgbAHWG9mlWYWJXmRuHpEnWrgjmD5FuAFTz5yWg1sM7NsM6sE1gOvBNcXngT2u/tfT0dH5pLegTgn2vtYtTgv3U3JaMuLc/nVS5fz7vFO/rXuZLqbIzLvTXjbqbvHzOweYBfJ206fcvdaM3sAqHH3apIH92+bWR3JkcG2YNtaM/sesI/knUV3u3vczG4Afht4y8xeD77V/+PuO6e7g+nw7vEOHDi/vCDdTcl411SWUHeik121x6koy093c0TmtZSeQwgO1DtHlH152HIvcOsY2z4IPDii7GVGv74wL+xraicvGua8Uo0QpsrM+PWrVvL1F+rYvuco//Gj51OYk5XuZonMS5q6Ypr1xxIcONbBJSuL5/0rM6fLRNdY8qIRtl29mv/500N86Udv88i2K/TqTZEZML8foU2D3fWn6IslFswrM2fLeaX5fPzCpVS/0cj3X21Id3NE5iUFwjT7x9rjZIWNdUt0/WC6fXRDOdetLeVPf1xL3YnOdDdHZN5RIEwjd+f5fcdZv6Rw3s9flA4hM7667Qpyo2Hu+c5eejW1hci00lFrGr31QRvH2nt1umgGLS3K4a9uvZx3jnUMzYoqItNDgTCNnny5nkjIuHCZprueSR+7cAn/7oZKnvn5EX78+gfpbo7IvKFAmCbPvd3Ej19v5J6PryMvWzdvzbQ/vvlCNlWU8Mc/eJN9jaPOeiIi50hHrhS0dvXz3NtNxBNOYU4Wy4pzzrhofLKzjy/96G0uWVnE3R9bx/drdBfMTBl+i+rmi5bwzrF2/sP/quHv7rlBb1kTmSIFwgSe33ec+3/4Fi1dfUTCIfpjCQAW5WXReLqHnoE4vzjUQkdvjO/+xhW6mDyLCnOy+M1rzuPJl+v53W/t4ZnPbdJDayJToEAYx//8l0M8uHM/Fy0Mk44yAAAL8klEQVQv4rZNq1lenEvfQJx3T3Syu/4U33jpIHnRMKsX5/GVf3OpXpWZBqtL8vj67Vdy99/u5Xf+Zg9Pf24TBTplJzIp+p8zht2HTvGV595hy8XL+NptV7IjeBgqOyvMpSuLuXRlMZ+5cgW5WWE9NZtmN128jK/fdiX3fPc1fvvJ3XzjN69iebGmHRc5Vzq/MYrmjj5+/7uvsaYkj/9+62VEI6P/NeVFIwqDOeLmS5fz2O1X8e6xDm5+5Kf8077j6W6SSMbRCGGERMK599nXaOsZ4Ok0nZPW+xMmZ8sly7hg6Q38/ndf4989U8MnLlrCvZ+4gEtWFqe7aSIZQSOEEZ76WT0/qzvFn336Yi7SA2YZZ215AT/8vV/iC5+8gFfqW/jU11/mt5/czY9ea6C7X29eExmPRgjDvHu8g/931wE+cdEStl29euINZE4YbURVWpDNvZ+4gH89eIpXj7Tw0/dOkhV+k49tWMKNFy/j4xcuoSRft6mKDKdACPTF4ty7/XUKsyP8t1+/TNcG5oGcrDAfv3AJH91QzpFT3bzZcJq3PmjjH/cdJ2SwsaKEG6uWcmPVMtbo3RUiCgRIXjf44o432dfUzuO//RHKC7PT3SSZRiEzKsvyqSzLx91pPN3LvqZ29je18xd/v5+/+Pv9XLiskE9WLeWTVUu5dGWxfiGQSRttxHr7NWvS0JJzp0AAHnruHX78eiP/+aYN3HjxsnQ3R2aQmbFycS4rF+fyyaqltHT1D4XDoy/U8fUX6ijOzeLCZYX8h19Zy4ZlRSwvyiEUOjMgBuIJWrv7ae0aoKWrn+o3Gunqi9HVH6O7P04i4ZjB5asWUVaQzZKibC5YWsi6JQV6eFHmrJQCwcy2AI+QfKfyE+7+lRGfZwPPAB8BTgGfdffDwWf3A3cCceAP3H1XKvucDbF4gq+9UMf/+JdD/Na1a/i9j54/202QNCvJj3LDujJuWFdGV1+MA8c62NfUzt73W/nct2oAyM0Ksygvi9ysMHF3jrf30juQGHOf2ZEQ4ZDhDnuPnKY//mHdaDjEsuIczi8v4Pwl+axZnEckHMqY3yAlNQl3Tncnf1lo6xmgICdCYXaE1SV5rC3LP+sXjLliwkAwszDwGPBJoAHYY2bV7r5vWLU7gVZ3X2dm24CHgM+aWRWwDbgYWAH8k5ldEGwz0T5nVN2JDr7w/Td54+hp/u8rV/Lnn75EpwkWuPzsCFedt5irzlvMQDzBhmWFHGzu5FBzF+09A/TGEhjQ3NlHfjRMXjRCXjRMfnYk+RWUhYf9Z3d3egcStPUOcKytl6a2Hg6f7OKlAyd48QBkhY2K0nw6ege4fl0ZVcuLUj5YxBNOa3c/pzr7OdnZx49fT45SYgkHIGyw+aKllBREWbkol1WLc8mL6qTATHB3DjZ38q8HT7H9laPUn+yiZ9j7On6w98P5zYpyIly+ehHXri3l2rWlXLaqeM6MGlP56dgE1Ln7IQAz2w5sBYYfvLcCfxYs7wAeteTRdSuw3d37gHozqwv2Rwr7nDa9A3EaT/cE547b2FV7nL3vt7IoN4uv33Yln7psucJAzpAVDg39hx3pXJ4TMTNyo2Fyo2GWFeVwxepFAPT0x6k/2cXB5k7qmjv5b//wDpAcjZxXmsd5pXkU5mSRFw0zEHc6+2J09g7Q0RujozfGqa5+Wrr6CI79Y9r59rEz1ssKoqwuyWPlolxK86MU50XJi4bJCoeIho2scCj5FRmxHg4RjZy5nhU2IuEQkZAFXyES7vQMxOkdiNM7kKA3FqenPz50Oq2rL7neH08wEE8QizsDieSfsXiCgUTyz2R5UBZ3+oL9DO6vL5YgZEY4ZIQseZ0oKxxK/l1nhcnJCgfLoeR6NExhdoSCILwLcyIUZGdRkJMsK8iOUJATIRocmM1g8IhgZhgQSzjd/TE6+2Icb+/jWFsv753ooLaxnTeOnuZERx+QnOesakURa0rykn/HuVncfOky2ntj1B3v5LWjp3n1SAv/fdeBoX/zjRWLuXL1IirK8jmvNI/FeVEW5UXJzQoTDhlZYZuVY1QqgbASODpsvQG4Zqw67h4zszagNCj/xYhtVwbLE+1z2tz01X/hyKnuofWq5UXcu/kCbr9mzZQuIOsBMpms3GiYqhVFVK1IPuuy+aIl/OvBk7z9QTuHT3ZxqLmLrr4Y3QNxIqEQhTmDB7HkCKSyLI9LVxaRP+xgNnhgG/xtMxb/8AB2unuA1u5+Wrr6g2sf/bR2D9DeO4BPECozyYBQyAibEQpBfjRCJJwMl8HA6eyNkRW2IKRC5EUjFOUYTvLUjHvyz3jCaeseoDnex0AQOANxpz+WIJ7wM07dTVv7DSrL8rnu/FKuW1vK9evK+Ol7J8+qt25Jcp6zq9Ys5jeCW9pPdfbxSn0Lvzh0il8cauHRF+vGDfj9D2whNxqe9j4Ml0ogjBZLI5s9Vp2xykcbH436V2FmdwF3BaudZnZgjHam7AjwD8C9U91R6sqAs39KMsuC68NvzmBDpmA+/DvA/OhHGXDyMPAi8LVxKk7Hz1LeQ1Pa/LxUKqUSCA3A8Ke0VgGNY9RpMLMIUAy0TLDtRPsEwN0fBx5PoZ1zlpnVuPvGdLdjKtSHuWE+9AHmRz/mQx9GSuVKxh5gvZlVmlmU5EXi6hF1qoE7guVbgBfc3YPybWaWbWaVwHrglRT3KSIis2jCEUJwTeAeYBfJW0SfcvdaM3sAqHH3auBJ4NvBReMWkgd4gnrfI3mxOAbc7e5xgNH2Of3dExGRVJmn84rSAmFmdwWnvjKW+jA3zIc+wPzox3zow0gKBBERATT9tYiIBBQIU2RmT5nZCTN7e1hZiZk9b2bvBX8uDsrNzL5mZnVm9qaZXZW+ln/IzFab2Ytmtt/Mas3s80F5pvUjx8xeMbM3gn78eVBeaWa7g348G9zIQHCzw7NBP3abWUU62z+cmYXN7DUz+0mwnlF9MLPDZvaWmb1uZjVBWab9PC0ysx1m9k7wf+O6TOvDuVIgTN23gC0jyu4D/tnd1wP/HKwD3EzyTqv1JJ+t+OYstXEiMeAL7n4RcC1wtyWnHcm0fvQBH3f3y4ErgC1mdi3JqVQeDvrRSnKqFRg25QrwcFBvrvg8sH/Yeib24WPufsWwWzMz7efpEeA5d78QuJzkv0em9eHcuLu+pvgFVABvD1s/ACwPlpcDB4Ll/wHcNlq9ufQF/JjkPFMZ2w8gD9hL8gn4k0AkKL8O2BUs7wKuC5YjQT2bA21fRfJg83HgJyQf8My0PhwGykaUZczPE1AE1I/8u8ykPkzmSyOEmbHU3ZsAgj+XBOWjTQOykjkkOOVwJbCbDOxHcKrldeAE8DxwEDjt7oPvzxze1jOmXAEGp1xJt68CXwQG51ooJfP64MA/mtmrlpxtADLr52kt0Az8TXDq7gkzyyez+nDOFAizK5VpQNLGzAqAHwD3unv7eFVHKZsT/XD3uLtfQfK37E3ARaNVC/6cc/0ws08BJ9z91eHFo1Sds30IXO/uV5E8lXK3mf3yOHXnYh8iwFXAN939SqCLD08PjWYu9uGcKRBmxnEzWw4Q/HkiKE9lGpC0MLMskmHwt+7+w6A44/oxyN1PAy+RvCayyJJTqsCZbR3qh5055Uo6XQ982swOA9tJnjb6KpnVB9y9MfjzBPAjkuGcST9PDUCDu+8O1neQDIhM6sM5UyDMjOFTedxB8pz8YPm/De5IuBZoGxx+ppOZGcmnzfe7+18P+yjT+lFuZouC5VzgEyQvBL5IckoVOLsfo025kjbufr+7r3L3CpJP/L/g7r9JBvXBzPLNrHBwGbgReJsM+nly92PAUTPbEBRtJjnjQsb0YVLSfREj07+A7wJNwADJ3xLuJHkO95+B94I/S4K6RvLFQAeBt4CN6W5/0K4bSA5v3wReD75+NQP7cRnwWtCPt4EvB+VrSc6hVQd8H8gOynOC9brg87Xp7sOI/nwU+Emm9SFo6xvBVy3wpaA8036ergBqgp+n/w0szrQ+nOuXnlQWERFAp4xERCSgQBAREUCBICIiAQWCiIgACgQREQkoEEREBFAgiIhIQIEgIiIA/P8jf95YJKQ64wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(mgwr_bw1)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(B2, extent=[0,25, 0, 25], origin='lower',cmap='RdBu_r')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "514.968" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw2)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(mgwr_bw2)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(538.887, 179.233, 514.968)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw0),np.mean(mgwr_bw1),np.mean(mgwr_bw2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### AIC, AICc, BIC check" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_aicc=[]\n", + "gwr_aicc=[]\n", + "mgwr_bic=[]\n", + "gwr_bic=[]\n", + "mgwr_aic=[]\n", + "gwr_aic=[]\n", + "mgwr_params=[]\n", + "gwr_params=[]\n", + "mgwr_predy=[]\n", + "gwr_predy=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,1000,50):\n", + " p1 = pickle.load( open( \"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Binomial_MC_script_2/pkls/results-{}-{}.pkl\".format(str(i), str(i+50)),\"rb\") )\n", + " for j in range(50):\n", + " mgwr_aicc.append(p1[j].mgwr_aicc[0])\n", + " gwr_aicc.append(p1[j].gwr_aicc[0])\n", + " \n", + " mgwr_bic.append(p1[j].mgwr_bic[0])\n", + " gwr_bic.append(p1[j].gwr_bic[0])\n", + " \n", + " mgwr_aic.append(p1[j].mgwr_aic[0])\n", + " gwr_aic.append(p1[j].gwr_aic[0])\n", + " \n", + " mgwr_params.append(p1[j].mgwr_params[0])\n", + " gwr_params.append(p1[j].gwr_params[0])\n", + " \n", + " mgwr_predy.append(p1[j].mgwr_predy[0])\n", + " gwr_predy.append(p1[j].gwr_predy[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(np.mean(gwr_predy,axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(np.mean(mgwr_predy,axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, axes = plt.subplots(1, 2, figsize=(4, 4), sharex=True)\n", + "sns.despine(left=True)\n", + "sns.distplot(mgwr_bic,ax=axes[0])\n", + "sns.distplot(gwr_bic,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, axes = plt.subplots(1, 2, figsize=(4, 4), sharex=True)\n", + "sns.despine(left=True)\n", + "sns.distplot(mgwr_aic,ax=axes[0])\n", + "sns.distplot(gwr_aic,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, axes = plt.subplots(1, 2, figsize=(4, 4), sharex=True)\n", + "sns.despine(left=True)\n", + "sns.distplot(mgwr_aicc,ax=axes[0])\n", + "sns.distplot(gwr_aicc,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(555.2930310559196, 565.2171303944737)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_aicc), np.mean(gwr_aicc)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(555.2543525109128, 563.542676896326)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_aic), np.mean(gwr_aic)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(568.5736137906213, 657.6378243512686)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bic), np.mean(gwr_bic)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### AIC, AICc, BIC Boxplots for comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "aic=[]\n", + "aic=gwr_aic\n", + "aic=aic+mgwr_aic" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "aicc=[]\n", + "aicc=gwr_aicc\n", + "aicc=aicc+mgwr_aicc" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "bic=[]\n", + "bic=gwr_bic\n", + "bic=bic+mgwr_bic" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "d = {'aic':aic,'bic':bic,'aicc':aicc,'model':model}" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "df=pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['aic'],x=df['model'])" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['aicc'],x=df['model'])" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['bic'],x=df['model'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter comparison from MGWR and GWR" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_params_mean=np.mean(mgwr_params,axis=0)\n", + "gwr_params_mean=np.mean(gwr_params,axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.2846917 , 1.60675938, 0.25596671],\n", + " [0.28371941, 1.60712877, 0.26163037],\n", + " [0.28254898, 1.60802699, 0.26836111],\n", + " ...,\n", + " [0.28030459, 1.7171863 , 0.64758872],\n", + " [0.27994884, 1.68247975, 0.6534747 ],\n", + " [0.27958057, 1.65168921, 0.65852034]])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_params_mean" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "B0_mgwr=np.hsplit(mgwr_params_mean,3)[0]\n", + "B1_mgwr=np.hsplit(mgwr_params_mean,3)[1]\n", + "B2_mgwr=np.hsplit(mgwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "B0_gwr=np.hsplit(gwr_params_mean,3)[0]\n", + "B1_gwr=np.hsplit(gwr_params_mean,3)[1]\n", + "B2_gwr=np.hsplit(gwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "B0_mgwr=B0_mgwr.reshape(25,25)\n", + "B1_mgwr=B1_mgwr.reshape(25,25)\n", + "B2_mgwr=B2_mgwr.reshape(25,25)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2.5987313746451686, 2.452124883320957, 1.147104517676957)" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(B1_mgwr),np.mean(B1_gwr),np.mean(B1)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "B0_gwr=B0_gwr.reshape(25,25)\n", + "B1_gwr=B1_gwr.reshape(25,25)\n", + "B2_gwr=B2_gwr.reshape(25,25)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax, ax2,ax3, cax) = plt.subplots(ncols=4,figsize=(10,6), \n", + " gridspec_kw={\"width_ratios\":[1,1,1, 0.1],\"height_ratios\":[1]})\n", + "fig.subplots_adjust(wspace=0.3)\n", + "im = ax.imshow(B0, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "ax.text(3, -2, 'Original B0')\n", + "im2 = ax2.imshow(B0_mgwr, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "ax2.text(3, -2, 'MGWR B0')\n", + "im3 = ax3.imshow(B0_gwr, extent=[0,10, 0, 10], origin='lower',cmap='Blues')\n", + "ax3.text(3, -2, 'GWR B0')\n", + "\n", + "divider = make_axes_locatable(ax3)\n", + "\n", + "fig.colorbar(im, cax=cax)\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "\n", + "ax2.set_xticks([])\n", + "ax2.set_yticks([])\n", + "\n", + "ax3.set_xticks([])\n", + "ax3.set_yticks([])\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax, ax2,ax3, cax) = plt.subplots(ncols=4,figsize=(10,6), \n", + " gridspec_kw={\"width_ratios\":[1,1,1, 0.1],\"height_ratios\":[1]})\n", + "fig.subplots_adjust(wspace=0.3)\n", + "im = ax.imshow(B1, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax.text(3, -2, 'Original B1')\n", + "im2 = ax2.imshow(B1_mgwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax2.text(3, -2, 'MGWR B1')\n", + "im3 = ax3.imshow(B1_gwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax3.text(3, -2, 'GWR B1')\n", + "\n", + "divider = make_axes_locatable(ax3)\n", + "\n", + "fig.colorbar(im, cax=cax)\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "\n", + "ax2.set_xticks([])\n", + "ax2.set_yticks([])\n", + "\n", + "ax3.set_xticks([])\n", + "ax3.set_yticks([])\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsQAAAGkCAYAAAA2STNEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XuUHHWd//9XVXX33CeThEwGRfkiAW8hyq6uMSpgEAJIIKwotyWseLIKG5CsoIiALOi67npAl1UXOF6QTQSUWwKcGDmsooaDG90V4uXHYfV4AZJMMrnOrS9Vvz/CtAxMvT8zVTXTnenn45w+OT2f/ny6pruq855Pf+pVXhRFkQAAAIAG5dd6AwAAAIBaoiAGAABAQ6MgBgAAQEOjIAYAAEBDoyAGAABAQ6MgBgAAQEOjIAYAAEBDoyAGAABAQ8vVegMAAACA8Vq3bp2++tWvqlwu64ILLtB5551Xbfv1r3+tK6+8snq/r69PM2bM0IMPPmiO6XGlOgAAABwItm7dqnPOOUf33nuvCoWCzj77bN14442aN2/eyx47ODio97///bruuuv0lre8xRyXJRMAAAA4IGzcuFELFy5UV1eXWltbtWTJEq1fv37Mx95yyy1661vf6iyGJZZMAAAAIIFyuaxKpZLJWAMDA+rv73/Zzzs7O9XZ2Vm9v23bNs2ZM6d6v7u7W08++eTL+u3du1d333231q1bN67npyAGAADAhJTLZT3x2I/VPKMjk/FKpZIuvvjilxXFK1eu1CWXXFK9H4ahPM+r3o+iaNT9EWvXrtV73vMezZ49e1zPT0EMAACACalUKmqe0aG1H/qU+rftSDVWW/dsnfa1z+q+++5TEASj2l48OyxJPT092rRpU/V+b2+vuru7XzbmI488og9/+MPj3gYKYgAAACQy1LtDg1t6U40RvDDB29PTo6amJvOxixYt0s0336y+vj61tLRow4YNuuGGG0Y9Jooi/fKXv9TRRx897m3gpDoAAAAk4nuegpQ3f4wlD3Hmzp2rVatWafny5Vq2bJlOPfVULViwQCtWrNBTTz0laX/UWj6fdxbXL0bsGgAAACZkeHhYmzdv1ndPv0j9z6ebIW47eI7OfOCrmj9//oSK2CyxZAIAAACJBN6flzykGaPWKIgBAACQyMiyh7Rj1BpriAEAANDQmCEGAABAIr7SL3moh9lZCmIAAAAkwpIJAAAAYBpghhgAAACJTJeUCWaIAQAA0NCYIQYAAEAifgZriCdypbrJQkEMAACARHylX25QD8sV6mEbAAAAgJphhhgAAACJTJfYNQpiAAAAJOJnkDLh174eZskEAAAAGhszxAAAAEhkfw5x2iUTGW1MChTEAAAASIQlEwAAAMA0wAwxAAAAEgmUQcqEaj9FTEEMAACARIIMlkzUwxpilkwAAACgoTFDDAAAgET8DC7M4XNhDgAAAByoWDIBAAAATAPMEAMAACCR6TJDTEEMAACARKbLGmKWTAAAAKChMUMMAACARAJPCqfBkglmiAEAANDQmCEGAABAItNlDTEFMQAAABIJJEVpl0xksiXpsGQCAAAADY0ZYgAAACQSeJ6ilEse0i65yAIFMQAAABLxM7gwh1/7epglEwAAAGhszBADAAAgkcDzJJZMAAAAoFH5GawhrofYNZZMAAAAoKExQwwAAIBEvEDyUp5V59VBEDEFMQAAABLxfE9+2oK4DmImWDIBAACAhsYMMQAAABLxAl9ekG5+NW3/LFAQAwAAIBHP99KvIWbJBAAAAFBbzBADAAAgET9If+3mtCflZYGCGAAAAIl4vi/PT7mGOGX/LNR+CwAAAIAaYoYYAAAAiXh++iUPXh1Mz9bBJgAAAAC1wwwxAAAAEvEyOKkubWxbFiiIAQAAkIgX+NI0uDBH7bcAAAAAqCFmiAEAAJCI73uKpsGV6iiIAQAAkIjne1LKgrYeCmKWTAAAAKChMUMMAACARPzAVzQNTqqjIAYAAEAyfgaxabWvh+thEwAAAIDaYYYYAAAAiWRxYY7U/TNAQQwAAIBE/AwuzJG6fwZqvwUAAABADTFDDAAAgEQ8P4MlE3WQQ0xBDAAAgET8DC7MUQ8FMUsmAAAA0NCYIQYAAEAi3jQ5qY6CGAAAAIl4GVyYI/KlKKPtSar2JTkAAABQQ8wQAwAAIBEv8NJfujnwmCEGAAAAaokZYgAAACTi+f7+E+vS8Gs/P0tBDAAAgET8DJZMRIGnSkbbk1TtS3IAAABgnNatW6dTTjlFJ554olavXv2y9t/+9rc6//zzddppp+lDH/qQdu/e7RyTghgAAACJeL6XyW28tm7dqptuuklr1qzR/fffr7vuukvPPPNMtT2KIl100UVasWKF1q5dq9e//vW69dZbneOyZAIAAACJeL4vP+Ua4nACa4g3btyohQsXqqurS5K0ZMkSrV+/XitXrpQk/fKXv1Rra6uOOeYYSdJHPvIR7dmzxzkuBTEAAABqbsuWLQqCYNTPOjs71dnZWb2/bds2zZkzp3q/u7tbTz75ZPX+H/7wBx100EG66qqr9Otf/1qvec1rdM011zifmyUTAAAASMQL/pxFnPy2f6xzzz1Xxx9//Kjb7bffPur5wjCU5/15iUUURaPul8tl/fSnP9U555yj++67T6961av0z//8z87fgxliAAAAJOIF6WPXRvqvWbNmzBniF+vp6dGmTZuq93t7e9Xd3V29P2fOHB166KE66qijJEmnnnqqLr30Uuc2MEMMAACAmuvp6dEhhxwy6vbSgnjRokV6/PHH1dfXp8HBQW3YsKG6XliSjj76aPX19ek3v/mNJOnRRx/VG9/4RudzM0MMAACARDzPl5fywhqeN/7+c+fO1apVq7R8+XKVSiWdeeaZWrBggVasWKFLL71URx11lL785S/r6quv1uDgoHp6evQv//Iv7m2IoqjWl48GAADAAWR4eFibN29W+51fkb/PnfNrCdtnaN/ZF2v+/PlqamrKaAsnhiUTAAAAaGgsmQAAAEAi+1Mi0p5Ul+7Sz1mgIAYAAEAyfvqUCaVcg5yF2m8BAAAAUEPMEAMAACARz88gZYIZYgAAAKC2mCEGAABAIl4QyHvJ1eWSjFFrFMQAAABIxPMzSJnwa58ywZIJAAAANDRmiAEAAJCI7/vyU54UF9XBSXUUxAAAAEjEC9LnEKfOMc5A7bcAAAAAqCFmiAEAAJCIl8GV6uohh5iCGAAAAMn4XvqClpQJAAAAoLaYIQYAAEAi0+WkOgpiAAAAJNKwa4jDMFR/f7/y+bw8r/ZrPoCpEEWRSqWS2traUuctxuHYQiPi2AKyNxXH1XQz4YK4v79fTz/99GRsC1D3jjzySHV0dEzK2BxbaGQcW0D2JvO4GuEHvvyUM8Rp+2dhwgVxPp+XJP3dP9+j3p39mW9Qvfr/vnJOrTehrlxz3CW13oQp1dY9W6d97bPV/X8yjIz96Ye3qm+gMuZjcrn4D40gF5jjFwrx7bkmu29Ti/17d7TGt89uL5h953Q2x7a9YkZ8myR1t9pjz+1oim2b2WR//HU1x7/W+cE+s6+/d5vZHvY+G9tW2vZHs+/w1h2xbQO9O82+g727zPahnUPxffvi2yRp0Og7vK8Y2xbMnqnuL1wzJcfWp+5/Vn39McdW3jg+jGNHkgrN8fuS1SZJzY59eJaxD7/6oBaz76Gz2mLb/l9Xq9n3kE7HcdscP9Oe22nvw+Hzv41tK/3R/sNlz++3mO39z8UfH/3b7JplYPtAbNvQ7mG7b3/J3q5KGNs2WInMvkNhfPtQTN/mObO06KvXT+pxNcLLIGXCq4OUiQkXxCNfN/Xu7NeWHXsz36B61VT7P17qyr7ne2u9CTUxmV+3jozdN1DR9n1x/2nHfzDmHJ97hUr8tudD+/dq9u0P7ND4JGkq22O3h/EHV1F2IVLx7Y8wL4h/UYK83TdvFEGFkr1dgd2sSlSObfPKduFZGY7/Tz0YsD+T/b277Q3bFV8QRH2DZtdwe3x7Za9dTEhTdGz1V9S7d+zXPmfUf/n4mlSS1GTsw01RfCEkSS2BfWzljL8JByr2f0zW8RMF9v4fOAqpQiH+uXOB/V6Git//VbL3s9zgPrPd3Md32cdHtCP+2AqNP/gkqWz80SdJpXL8fjDsKohTFNMsERo/TqoDAABAIg17Uh0AAAAgTZ/YtdpvAQAAAFBDzBADAAAgGd/P4NLNtZ+frf0WAAAAADXEDDFQZyrFUOXi2CkTafhGrI0r8qZcsrdn0NjeAcfvMliMP+N8wPG8ado7jLPkJalkJAcUAjuSSo70C2s2xPMdERWGyDgbfTwqxfj+Fcf7GBrPXTRio3JGW9bCcklheex4rIrxngSO9Y3W8WHFubn6SlLRSCew2iQpjCbxtbXSMxzJGlHMeyC59+FKyUiocLSXB11949+LsGRvl7WPS1LJaHb1tdrj2qbyuPJ9X74rWmccY9QaBTEAAAAS4aQ6AAAAYBpghhgAAACJTJcZYgpiAAAAJOJ5GVy6uQ6uqFf7khwAAACoIWaIAQAAkIgX+PKMVJ7xjlFrFMRAnamUhlUpxsUSNacYOT5yyBW7Vhq224eND7N9Q3Ycz+6B+Aim9ub4NknqKNgfYfuMSLeZLXbfYiU+tqg1yJt9I0csm5c32nP22Gn+47Ci0VztkSPGyYqlsmKjosmMBnuJSmlI5WJxwv3KfovZ7hlvSTlvx6pVyvbxkSZ2LU0Kny/HV9hR/O/lOWLXFMb3dcWqhcYxLdnRalasmmTHDrri8YyPC0n2MVBxHAPW2HF9XWNmaboUxLXfAgAAAKCGmCEGAABAMl4Gl262vmaZIhTEAAAASMTz/VRX2BwZo9ZqvwUAAABADTFDDAAAgGT8YP8t7Rg1RkEMAACAZHx//y3tGDVW+y0AAAAAaogZYqDORJWiwrKdvzu25BnFnm9newaOjMhiEN9/X8H+KqzFyCneN2S/DnuLdmbv3mL8R9ygkZsrScWCkZ3b0mr2jQqO3Nrmtvi2nCPDOEVeZ+QIS7XaK0U7h9XKaTVziB35xlkKy0WF5bFziEPjK9ty0d6H/Vz8sefKr3W1F40w4cokvnauK+l6FeMzI7Q/TyLj8y105RA72ivGcW1lFEtSeSi+fdBx7Aw53gvrGLDakvbNT2UOse/LCw78k+ooiAEAAJCMH0jRgb+GuPYlOQAAAFBDzBADAAAgGWaIAQAAgAMfM8QAAABIxPO81CfFea6zOKcABTEAAACS8QNJB/6SCQpioM6Ui0MqF8eOhvJDO6LJFh8NFQT2X+fFYTuuyM/F9y8aUUaStNuIEWtxRLa1N9uxax2F+I+43Y7tajeee7Bgz4a05e1YNr+1Pb6tJT6STZJyzfGxbL7x+6YVOmKnrGioktHVm7p0KFWKw6oMD2c+bjkXvx+6jq2wbL8AlfLkxK7lfXu7HJttRqt5js+paHgoftiiKxpt7M/GarsRrWbFqklSyWhPE43mak/TN+6wdByuGAMFMQAAAJJhhhgAAACNzPM9eSkzGjzHNxZTgZQJAAAANDRmiAEAAJCMF0h+/Fr3cY9RYxTEAAAASMYPpOjAL4hZMgEAAICGxgwxAAAAEvECX17KSzd7Xu3nZymIgToTlssKS6UJ97MTNiXPiLUpDdtn+Po5+8OqXIr/uqzkyDAeNMbePWC/Dr174vNMJanVyBK2coYlqb0pvr01b78eLc0dZrtfiM8h9lrtvkFzU3xbPt1HehQambdFO1s2ac6qlyJLd6KiSklh2c6xHYt17EiSX4zfDysFO1e6UrG/ao7SZA0bYcLNjmO64Agi9ow853Cw3+wbGa9Xqd8+piuOHOJif3x7sd/+PNlnZD73O96nycwhrkRWDvHYbaHRJ3O+L0UpC9o6KIhrvwUAAABADTFDDAAAgGS8IINLTtb+pDoKYgAAACTi+b68lAVt2gt7ZKH2WwAAAADUEDPEAAAASMb3JaVdMlH7+VkKYgAAACTi+YHsTJJxjFEHa4hrX5IDAAAANcQMMVBnwtKQKjE5nVEYnwVrZchKku/IUjX7OjJL0/D8+LmFnUabJAWO9oKx3S15Vw5x/MdjR8H+6Gx3tLcZOcV+R5fZ18op9vN5s2/gyF4OK/Ffe7rycI2udg7xFOalhuVkOcSVYft1s3KKg2KzPbaRfStJofHaufb/VmMfb3FlaTuOeX9PfNZwuHuH2be8qy+2rbjXzjAe2h2ffyxJw3vi2/sdueb9xk48aO3gkgZT5BQ7hjbb49pcY2bK85V6ijjy06+6SIkZYgAAADQ0ZogBAACQjJ/RDLF9McxJR0EMAACAZIJAnpeyIq6DgpglEwAAAGhozBADAAAgGc+XHCd4OoVp11ykR0EMAACAZPxA8tNGREysIF63bp2++tWvqlwu64ILLtB55503qv3f//3fdc8996izs1OS9IEPfOBlj3kpCmKgziSNhnKxA4ds7q2xo6Umy3ZHuxVL1eKMTouPrJphRLLt72uvRms1Yte81k6zr9/SFtuWb7PfB893RGkF8a9X5MhxsmKlrDbfTqvKVKVSUmUSji0viN9XwrJ95FUqBbM9MmLprFhBSWoy2psCu2+uMnb04wh/aHdsW2nnNrPvwLZdsW2DRpskDe4YMNuHdsbHru1zRNxZ7dY+PJ72ivE+Wm2u9rgtnsLDaspt3bpVN910k+69914VCgWdffbZetvb3qZ58+ZVH7N582bdeOONOvroo8c9LgUxAAAAEvF8X17KGWLvhRniLVu2KHjJH5idnZ3VmV5J2rhxoxYuXKiurv2Z7UuWLNH69eu1cuXK6mM2b96sW265Rc8++6ze+ta36hOf+ISamprMbeCkOgAAACTj+y8sm0hz21+OnnvuuTr++ONH3W6//fZRT7dt2zbNmTOner+7u1tbt26t3u/v79frX/96XXHFFbrvvvu0Z88efeUrX3H+GswQAwAAoObWrFkz5gzxi4VhOCrmLYqiUffb2tp02223Ve9feOGFuuqqq7Rq1SrzuSmIAQAAkFAGF+Z4QU9Pj3NpQ09PjzZt2lS939vbq+7u7ur95557Ths3btSZZ54paX/BnMu5y12WTAAAACAZz8/mNk6LFi3S448/rr6+Pg0ODmrDhg065phjqu3Nzc3613/9V/3xj39UFEVavXq1TjjhBOe4FMQAAAA4IMydO1erVq3S8uXLtWzZMp166qlasGCBVqxYoaeeekqzZs3S9ddfr4suukgnnXSSoijSBz/4Qee4LJkAAABAIpHnKUp56ebIm1hKxdKlS7V06dJRP3vxuuElS5ZoyZIlExqTghioM2FYURjGXNTdyFCN4vqMoz2q2H0DR3arlZtcbo7Pzd3fNz4x02qTpLBit28xskFdGa4dzfEfjzNb8mbfWY72mc3xecFBvtXs6xmvp+/IVvYc2bNpWO+EldEaOPJbsxSVigpLY++r1jHg+o8ybkxJqhQHzb6VYovdbhwDFcdrFxhFSt5xZTGvFJ/nK0mVvTvj23bvMPsO7YjPMB5w5AwP7rTzkYeL8e9jybGrpcsKdo09OX3rgudLKQtieZFqnZ7MkgkAAAA0NGaIAQAAkIznZTBDnM2mpEFBDAAAgGR8X3IswXGKIkn20r3JxpIJAAAANDRmiAEAAJCM5ymaQI7w2GPU9oQ6iRliAAAANDhmiIE6E5ZL8dFQL7nG+0QERuyaFZs2nvbKcHwUUtkRO1Ueio+dKg23m31LJXvNWWjEUj3riF3rao2PTuvpsC8tOuDYrqFy/PvYlLfH9grxkW2eb/9OaWLXXBF3VrSa1Zabwti1sFKK3Zf9XCG2X8Wx/3vGPl4uxr9fklRxvK6R8fq4YtcsznOgyna8WTTYH9tW6rf7Wu3FfY7PmqL9erni0SwFYx2sK/oscOToBnVw0tjkmdiV5uoVBTEAAACSmeCll8ceI5tNSePAL+kBAACAFJghBgAAQDLTZIaYghgAAACJRBmkTESONdhTgSUTAAAAaGjMEAMAACCZTJZM1H6GmIIYAAAAyXjeOHL8xjFGjVEQA/UmrCiKyQyO+/m4ho3JNpYkz0+ebyxJfj4+w9UfsMe28l+LA44c4qGZZnsUdsS25fL2dm3bMxzbtnu4bPbdW7Tfp6IRahoF8a+HJHlGFnWanGFJCo3tsjKdJTv/1cwhTpEbO1FhOT6HOI3I2Iej0JGbW3a0GznFw66+k/naGr9XWLKPD+s18R37sO8I9A2MwirvqLmKRt+C49CqRPbgVo5xmgzjKYzxnvYoiAEAAJAMSyYAAADQyCLPJ2UCAAAAONAxQwwAAIBkPE/y0y6ZsNfDTwUKYgAAACSTyRri2i9YqP0WAAAAADXEDDEAAACSmSYzxBTEQJ0JK5OTlWpx5Ru72q0cY1fGsdUeDO0z+1rZyq6xC032x19fZ/zY+4bsnNXhsv16WZmkzv8YjN8pMjJrx9NeMfKTrSxhV7vVlp/CINUois/4to451z5cMfq69tGwXDLby6X496zoyCG2coqdGcW+ozzI5eO75u2+VnvgCPwNCvZ7YWX2WhnFkp017Hq9Cr49tnUMuPpanxelKczxjjVNCuLabwEAAABQQ8wQAwAAIJHI8zLIIa79pZuZIQYAAEBDY4YYAAAAyUyTNcQUxAAAAEjG8/bf0o5RY7UvyQEAAIAaYoYYmCZc0WgWV8xbmrFdrEgr1/MGuYLZXhzYHd823Gr2LRkRZQNGPNn+vnYUkpmUFDkuYZrivXDFrlkcv5LZbkVWhVMYGxWWy7ExZ1bKmOv48I390LUPu8YOjei0Qed+GN+37NpH8/GxapIUtLTFthU649skKd/WHNuWa3ZFttnzeLm8EePoiKmzRk4Tjebq7+obePEPiNvmqZ3tzGDJRB3Mz1IQAwAAIBFSJgAAAIBpgBliAAAAJEPKBAAAABrZ/iUT6ZY8sGQCAAAAqDFmiAEAAJBIFDmSc8Y5Rq1REAMAACCRKIpSxydGdVARUxADdcbzg9hsXivT1MrzdfVNKwqT59tafV2/U6VG+cmBI5M0H9jtgbVYrVQ2+0al+N85dPV1vE+REYhqZQm72u2MYnPYKWPtK679yGpPm/FdMbKEi45c3WGjb8lxyEb5+KxgSfLbOmPbvNYOs2+hIz6nONdilyVBwf5M8IxjL3CsU7XyfkMl7+t67sno6/gIwhgoiAEAAJBI9MIt7Ri1RkEMAACARMJo/y3tGLVGygQAAAAaGjPEAAAASCRSlPqkuKgOFk1QEAMAACARlkwAAAAA0wAzxECd8YK8/FxhzLY0MWKT2TdNZJUVrRYUWsy+OUd7vrk9tq3QZH/8Nefjt6vVEf3UlLPbC0Ymkjdox3SFxaH4NkfsWqXoiPgqxbfXSzxaPUqz/4fOdiPOzjGtVjLetLKjb8Uf+zOoul2F+Oi0oGOm2bfQ2Rrf1hHfJkm55n1me2ActwXfPj6KYfxx6YodTBPpdqCbLikTzBADAACgoTFDDAAAgESiDNYQ18GF6iiIAQAAkEwUZZAyUQcVMUsmAAAA0NCYIQYAAEAi4Qu3tGPUGgUxAAAAEomi9GuA62DFBEsmAAAA0NiYIQbqjJ/Ly8/bGaBJWHmocbnH4+k7nnaLlUOcb4nPEZakgiPvtKm9I7atuS1v9p3VHv+azGy1+85wZBw3BfFzEV552OwbGTnEZUeGsTOHuBj/xaUrh9XKKba+Dq2Hr0rTsvZhqy0tVw6x9Z4Nlu19YdgRPF1ois8h9mfMNvs2z54R29Y00z7mW2buMduHdhrHx5Ajp9t4vdw5xGazo2/yDOO4vr5jzCxNlyvVURADAAAgmSiDlIg6KIhZMgEAAICGxgwxAAAAEgklpV2gUQ9LpyiIAQAAkAgpEwAAAMA0wAwxAAAAEgkVyUs5xRvWwVl1FMQAAABIJFL6kIjal8MUxEDdyRWa5YgFzlyaHOG0rAzkfFun2be58yCzvb2rObZtxsxWs+8hs1pi27rbmsy+bQV7NVohis8L9ov9Zt9w767YtuJeu2+xv2S2WznFJcf/WK6c1nrg+b48f+z3xtoPXTndaXKI/RQ5xa7XfNB4PwdK9mlMg2W7va0pPuM778ghDmZ2x7a1ztlp9h3euc9u3xN/bLlyiMOd8b9z0RGU6zo+Cn78aWeusa2c4riM4jS5yI2KghgAAACJRBlcmKMe/p7mpDoAAAA0NGaIAQAAkMh0iV2jIAYAAEAiYQan1dVDygRLJgAAANDQmCEGAABAIiyZADApguY25Vrq69CMi6oaD1dkVa4QH29WaLWj0axYNUnqmtMW23ZET7vZ9/A58e2v7LRj12Y2O6K2Bnpj2yo7t5l9y3t2x7YV9wzYfQft2CkrlsoV8VWpg//QXPwgH7s/pold8/OTE9nmUnFEo+013s/dQ3YEX3/J3u6u9vjjw2/pMvsGs3ti21peYceuFffa+7jVXnb8zqGxE7fvGrKf1xFdWTSj0+yMtLhoNauv7xgzS2EGQcRpUyqywJIJAAAANDQKYgAAACQysmQi7W0i1q1bp1NOOUUnnniiVq9eHfu4H/zgB1q8ePG4xqyv72UBAABwwIgUpU6JiCbQf+vWrbrpppt07733qlAo6Oyzz9bb3vY2zZs3b9Tjtm/frs9//vPjHpcZYgAAANTcli1b9Kc//WnUbc+ePaMes3HjRi1cuFBdXV1qbW3VkiVLtH79+peNdfXVV2vlypXjfm5miAEAAJBIlMFJdSNLJs4991xt3759VNvKlSt1ySWXVO9v27ZNc+bMqd7v7u7Wk08+OarPt771Lb3hDW/Qm970pnFvAwUxAAAAEgmjSF7K3LTohf5r1qxREIxOXuns7Bz9fGEo70UpGlEUjbr/9NNPa8OGDfrmN7+pLVu2jHsbKIgBAABQcz09PWpqsmMte3p6tGnTpur93t5edXd3V++vX79evb29et/73qdSqaRt27bp3HPP1Zo1a8xxKYiBOhPkmxQUYrIljczSNHmmrr5p2nMF+2OmYGQut7bbH4wds+IzjCVp3tz4rNTXHdwZ2yZJ/68rfuw5rXl7u3w77zfo3xHbVnLkEA/u2BPb5sxo7S+a7aERBurKGXblFNcDP5cwh9jIGZakIEUNrVMTAAAagUlEQVRfZ8axnzxPdrAYvx8OlOzc3OGy/X4OGhnI+Wb72ApmzY1ty+3dZfZtmWO3D+/cG9+2x97/S0ZOt5XRLUktjgOkFMW/XgXHe1wMrQzjsZ83+f8GExdGkuxIbLcJfHwsWrRIN998s/r6+tTS0qINGzbohhtuqLZfeumluvTSSyVJf/rTn7R8+XJnMSxxUh0AAAASCqMok9t4zZ07V6tWrdLy5cu1bNkynXrqqVqwYIFWrFihp556KvHvwQwxAAAADhhLly7V0qVLR/3stttue9njDjnkED366KPjGpOCGAAAAIlUklxZ46WiqOZLFiiIAQAAkEiYUUFca7UuyAEAAICaYoYYAAAAiYShFCUPQ5EkeWlTKjJAQQzUmVxTq/LNY0cxWfFmnm9/4WPFN/k5u28Q2J92Vv9Ck/0x02xEmLXNaDb7vmZOm9n+ulfExz9ZsWqS9GrjuWcbUXGSFOz+o9kebn82tq28Lb5NkoZ27I5tc8VKuaKjimbsWu2/0kzLzzcrKIz9P68Vj2bFqklSrjk+3i8o2PtwruCIdAuSf5FbMd7PstEmScWKXaEUjZixqGAfW1Eu/jXxmlvNvoVO+5jPtcWP3dRpv9ZDO+OP61yzIz7SiGyTpLzxEer4eDXbA2/sxrifIx4FMQAAABIJoz9faS6pmDjlKUVBDAAAgEQqitIXxBO5Msck4aQ6AAAANDRmiAEAAJBIFL1w+eYU/NpPEFMQAwAAIJlKGClMueQhSltRZ4AlEwAAAGhozBADAAAgkTCK9l+tLo06iHWkIAbqTL6poHxp7LxhK5PUc3zfY2UFu7JOc4X4/GNJyuXj+ze1xOcMS1JHe1Ns26EH2Zmkr+mOz3+VpMNmxvc/1JFDPKsl/nduHo7PApakYKDPbC/u2BLbNrRjj9l3eNe++HH32TnElaIjW9bMITa7mqy9ayq/pswVmpVrGvsX8Y2s4cCRqxs0xWff5o2MYknKN9nHVt7I8Q5c+eFG9riVUSxJJccbbjVHvqO0sNqNrHVJUs7+PMk1x3+eBHl7u/x8/HMHBfu1zjvChINyfHvBeJ9c7XHHrGPITIVRus8HSaqDkAmWTAAAAKCxMUMMAACARLJYMuGxZAIAAAAHqkoUOZfgONVBQcySCQAAADQ0ZogBAACQSBSlzyH262CGmIIYAAAAiVQiqZJyDK/29TBLJgAAANDYmCEG6kyuECgfE6Vp5Y66soStHGIrR3h/u50NamUNz2iLz3eVpIO74jNcDz2ozex7yIz4vpL0ys74TNKuZvt36gjiM3v93TvMvuXtz5vtFaP/8K69Zt9S/1BsW1iy52kqxbTzOPECbwqDTxMK8s0KYnZHM4fYyBmW7KzhvJGLK9k5w5J9bLY4jksrh7gReY7PyMDIWw9cr7Ujq71Qiv88GQodGcbGsRWXUezKNs5SmMGSidQX9sgABTEAAAASCUMpTLnmIW1IRRZYMgEAAICGxgwxAAAAEgkzOKnOZ4YYAAAAqC1miAEAAJBIqPSXbk57Ul4WKIgBAACQSCWKVEl7YQ5FUo1DUSiIgTqTLwQqlMf+ZLCi01yxa1Z8kyv6qdBst88wYte6jegzSTpkVmtsW0+H3ffgDjsOq8vY7s6CI6ZusC+2zRvYZfYN99ixbMVde2LbrFg1SSoPlmPbKsX4aCdJihyncldqP0kzqbxcXn5u7NfIilazYtX2t7fEtzU54rgcx551bLa4or5yRoyYI5bLdyyoNLtH9n7obLeEyfu6Ytf8IP6X8ow2SfIcr6fVPe8oBK0ItWJMZJt/AMQg1hsKYgAAACQShelziCNFkv333aSjIAYAAEAiWVy6efIuGTR+pEwAAACgoTFDDAAAgEQyuXQzKRMAAAA4UIUZpEzUQ0HMkgkAAAA0NGaIAQAAkEglilRJeWGOilf7GWIKYqDO5As55SsxWam5+GzJIG9n1uSN9iZHFuqM1vicYUma3V6IbZvTaWcFH2T0Pag1vk2SZhn5x5LUbmQvN6lk9vUHd8e2hfscOcT9e832ylAxvm8pPmdYkkIjLDiM2W+y4IhhNduTtmUtKDQpaBr7CXOF+CzhoGDvwznj2HLlDOccedg5I2vYlUPcarTnnLm5yd8YL00OcZgub8DKGvYc4cpWX9+RYRy4MqGN19v1WgdGsRg3rvHRl7lKOD0KYpZMAAAAoKExQwwAAIBEwlCpZ4hjLrg3pSiIAQAAkAhLJgAAAIBpgBliAAAAJBJGkSphyiUTfu1niCmIAQAAkEglTF8Qp72wRxYoiIE6kysEysecYRDk4lc5WdFPktRixD+5YtW6HO2z2pti27o74tskaWZz/NgzHbFqbY5sIavdH95j9vVKA7FtlX67bzTUb7aXjdi1StERu1ZKF0tlmawINCtWyk8R7zXh7cg3x8aYBUbsmhV9Jkn5ZiPezHFcuuISm412K1ZNkgrG50XeESPmel/q4ByozHlWNJojHs93HDy+MbYVySZJReOMs2LM2lt7z8BYKIgBAACQyHSZIeakOgAAADQ0ZogBAACQSJjBDHFYBzPEFMQAAABIpJJBygQ5xAAAAECNMUMMAACARDI5qa4OZognXBBHL1yeb87Mtsw3pp4Nh7XegvrSfvCcWm/ClGrrni3pz/v/ZBgZu6vJU9yXN0HOiAUy2iSpuRDf1mGnm6k9Z//erX78AdIkOyYsF8XHjHmVktm3UrZ/55IRURaU7Hgz39jsimd/dJZz8RFeklRubo9tC9sHzb7qin8vvJIdcedH9nbl2+Jf76ai/T62lOL3gXI5vq21e5akqTm2ZrfHv29BIb4t12SHWDUZ7YUm+4vYQrO9D3cYx63ruGz24l9367iTpMhx7JVL8c9djOy+QSW+b+goS0q5Znu7Uhxb0QzjvQjt5/U1ZLYH+eHYtpxxfEhSwWgvV8ZuK8yZ/ONqRCWUyqkL4ow2JgUvmuCrtXfvXj399NOTtT1AXTvyyCPV0dExKWNzbKGRcWwB2ZvM42p4eFibN2/W/c8X1J+yom0LIi07uKj58+erqcn+w36yTHiGuK2tTUceeaTy+by8KQxUB2opiiKVSiW1tU3eNyMcW2hEHFtA9qbiuBqxf8lEyjEOxCUTvu9P2l8bQD1rbra/MkuLYwuNimMLyN5kH1cjwih9QRz6tS+ISZkAAABAQyNlAgAAAIlUokjGeZLjHqPWKIgBAACQSCZriFOmVGSBJRMAAABoaMwQAwAAIJEwgxnisA5miCmIAQAAkAhLJgAAAIBpgBliAAAAJLI/hzjdDO/+7rW9aA4FMQAAABLJZsmEVOuCmCUTAAAAaGjMEAMAACCR7GaIa4sZYgAAADQ0ZogBAACQSCWMVJ4GM8QUxAAAAEikEmWwZKL2McQsmQAAAEBjY4YYAAAAiWRz6eZstiUNZogBAACQyP6UifS3iVi3bp1OOeUUnXjiiVq9evXL2r///e9r6dKleu9736srr7xSxWLROSYFMQAAAA4IW7du1U033aQ1a9bo/vvv11133aVnnnmm2j4wMKDrr79e3/jGN/TQQw9peHhY9913n3NcCmIAAAAkUgmzmCUe//Nt3LhRCxcuVFdXl1pbW7VkyRKtX7++2t7a2qpHH31UBx10kAYHB7Vjxw51dnY6x2UNMQAAABIJo4kveXj5GPv/3bJli4IgGNXW2dk5qqDdtm2b5syZU73f3d2tJ598clSffD6vH/7wh/r4xz+u7u5uvfOd73RuAzPEAAAAqLlzzz1Xxx9//Kjb7bffPuoxYRjK87zq/SiKRt0fceyxx+qJJ57Qu9/9bl133XXO52aGGAAAAIlEYaQo5Qxx9MKSiTVr1ow5Q/xiPT092rRpU/V+b2+vuru7q/d37dqlzZs3V2eFly5dqlWrVjm3gRliAAAAJBKGUSY3aX+xe8ghh4y6vbQgXrRokR5//HH19fVpcHBQGzZs0DHHHFNtj6JIV1xxhZ577jlJ0vr16/UXf/EXzt+DGWIAAAAcEObOnatVq1Zp+fLlKpVKOvPMM7VgwQKtWLFCl156qY466ijdcMMN+vCHPyzP8zRv3jz94z/+o3NcL4qiOrhgHgAAAA4Uw8PD2rx5sz7zRL92DqcrJWc2ebr6bW2aP3++mpqaMtrCiWGGGAAAAIlEUQZriOtgapY1xAAAAGhozBA7fPvb39a3v/1tlctleZ6nN7zhDVq1apVe8YpXjPn4FStW6BOf+ITmzZsXO+aXvvQlHXrooVq2bFmibTr//PN13nnn6aSTThr18yuvvFI/+clPNGvWLEVRpGKxqHe84x365Cc/qVwup76+Pl177bX6/e9/r0qlomOPPVZXXHGFfJ+/izB1/vSnP+n444/XW9/6Vv3nf/7nqLYrr7xS9913nx5//HHNmjVLkvTd735Xd911l/r7+1UsFvWqV71Kl112md70pjfpoYce0m233ab777+/OsZZZ52l5557To899lg1imfFihV697vfrcMPP1wrVqzQYYcdVn18f3+/5s2bp8997nOaOXPmqO154oknRj2+Uqlo5syZuu6663T44YdLkr7+9a/rnnvuURAEmjVrlq6//nq9+tWvzv6FA8aJYwZTKXrRSXHJx8hoY1KgEjJ8/vOf14YNG3TLLbfo4Ycf1rp16/SOd7xDZ511lrZs2TJmn9tuu80shiXpox/9aOJi2OVv//Zv9cADD2jt2rV64IEH9POf/1wPP/ywJOmf/umfdPjhh2vdunW677779OSTT+ree++dlO0ALE1NTfrd736nZ599tvqzgYEB/fznPx/1uBtvvFH33HOPvvjFL+rhhx/WI488or/7u7/Thz/8YT333HN6xzveoWeeeUa7du2SJPX19Wnbtm2aPXu2nnrqKUlSuVzWz372Mx177LGSpFe/+tV64IEHqrfvfe978n1fX//618fc1hc//sEHH9Qxxxyjz3zmM5L2XzFppPhYu3atTjjhBH3yk5/M/PUCxotjBlMtCrO51RoFcYwtW7bozjvv1Be/+EUdfPDBkiTf97Vs2TItWbJEt9xyiyRp8eLFuuyyy3TyySfr+9//vhYvXlz9ULn11lt14okn6owzztBnP/tZLV68WNL+WbCvfe1rkqSjjjpKN998s84++2wtXrxYa9askbS/OPj4xz+us846S0uWLNFf//Vf67e//e2EfoeBgQEVi8XqFV1OOOEE/c3f/I2k/QXJEUccUY0lAaZSEAQ6+eSTtW7duurPNmzYoOOPP756f/v27br99tv1pS99Sa985SurP3/729+uK6+8UoODg+rq6tL8+fOrmZQ/+MEP9M53vlPHHXecHn30UUnSL37xC73yla8cNcaL7du3T319fZoxY4Zzu6Mo0u7du6vH1EEHHaTrrrtO7e3tkvYfzxxTqBWOGSA5lkzE+MUvfqHXvOY1Yx7wixYt0he/+MXq/SOOOKJ6/3Of+5wk6Uc/+pHuvfdeffe731VHR4c+9alPjfk8xWJRM2fO1J133qnNmzfrnHPO0fve9z499thj6uzs1F133SVJuvbaa7V69Wpdc8015nZ/85vf1Nq1axWGof7whz/o6KOP1l/+5V9KkpYsWVJ93K9+9Ss9+OCDuuOOOybwqgDZWbZsma644gp95CMfkSTdf//9uuqqq6qzTv/7v/+rww8/fFTg+ov7jnjXu96lJ554Qu95z3v0X//1X1q2bJlmz56ta6+9Vpdddpkef/zx6kyXJP3hD3/Q6aefrnK5rL6+PvX09Ojkk0/WBRdcMOZ2jjxeknbs2KHBwUF961vfkiQdeeSR1ccVi0V94QtfeNlSJmCqcMygFqIoUtrAMk6qq3PlcnnMnxeLxVGXCXzLW97yssf88Ic/1EknnaTOzk55nqfzzjsv9nlGZsXe+MY3qlgsamBgQCeddJLOOOMM3XHHHfrMZz6jn/70pxoYGHBu88iSiXXr1unxxx9XU1NT9auqET/60Y904YUX6uqrr9brX/9655jAZJg/f76CINDmzZv1/PPPq7+/f9R/li/9gN23b59OP/10nX766TrhhBN04403SpKOOeYY/fSnP1WxWNSmTZu0aNEiLViwQNu3b9f27dv1xBNP6LjjjquOM/J17kMPPaTLL79cvb29Ovnkk5XP58fczhd//fvjH/9Y11xzjS688ELt27ev+pi+vj5deOGFam1tHdcVkYDJwDEDJEdBHOPNb36zfv/736u3t/dlbU888YSOPvro6v3W1taXPSaXy436cHrppQhfbCRzb6TIjqJIa9as0ac+9Sk1Nzdr6dKlOvXUUyf8F1hra6ve//7367//+7+rP/vGN76hj3/847rxxhsnbR0zMF6nnXZadb37yIzSiAULFuh3v/uddu7cKUlqb2+v/id72mmnVf9znT9/vnbs2KFHHnlE8+fPV0tLi3zf17ve9S795Cc/0e9+9zu9+c1vHvP53/e+92nx4sX66Ec/GvsH8EstW7ZMlUpF//d//ydJ+s1vfqMzzzxTb3jDG/TlL39ZhUIh6csBpMIxg1oIwyyuVlfr34KCONbcuXN1/vnn6x/+4R+0devW6s/vuecebdiwQStWrDD7H3vssdqwYYP27t0raf9ZvxPx4x//WGeccYbe//7367DDDtOjjz6qSqUyoTHCMNRjjz2mBQsWSJJWr16t1atX6+6779aiRYsmNBYwGU4//XStX79eDz/8sE499dRRbXPnztXy5cv10Y9+dNQaw2effVY///nPq+konudp0aJF+o//+I9Rs1rHHXecvv71r+uv/uqvlMvFrw67/PLL9fzzz2v16tXj2uaf/exnkqTDDjtMW7Zs0QUXXKCLL75YV111lfmHLzDZOGZQCyM5xKludbBmgjXEho997GP6zne+o4suukjFYlHFYlFHHXWU7rzzztiTDUa8/e1v1wc+8AGdddZZam5u1hFHHKGWlpZxP/eFF16oa6+9tlpIv/nNb9bTTz/t7DeyhtjzPA0ODuqNb3yjPv3pT1fXarW3t2vlypXVx5900km66KKLxr1dQJbmzp2rww8/XB0dHerq6npZ+6pVq7R27Vp97GMf0+DgoPbu3asZM2bolFNOGbUM6ZhjjtEDDzygd7/73dWfvfOd79QVV1yhD37wg+Y2dHZ26vLLL9fnPvc5vfe979VBBx00qv3F6yHDMFShUNDNN9+szs5OfeELX9Dg4KDuuOOO6nr8QqGg73znO4lfEyANjhkgGS7dPEmeeuop/c///I+WL18uaf9ShV/84hejTsYDAAA4EI1cuvnqR3epbzDdmodZLb4+s7iLSzdPR4cddphuu+023X333fI8TwcffLBuuOGGWm8WAABAZqIoUpg6ZaL2c7MUxJOkvb1d//Zv/1brzQAAAIADBTEAAAASGTkxLu0YtUZBDAAAgERGUibSjlFrxK4BAACgoTFDDAAAgERGLq6RdoxaoyAGAABAIlGU/sIaLJkAAAAAaowZYgAAACQShftvaceoNQpiAAAAJBKF6dcA10NBzJIJAAAANDRmiAEAAJDIdMkhpiAGAABAItPlSnUsmQAAAEBDY4YYAAAAiYRRpDDlkoe0/bPADDEAAAAaGjPEAAAASGS6rCGmIAYAAEAi0yVlgiUTAAAAaGjMEAMAACCRKIwyuFJd7WeIKYgBAACQSBRFqZc8sGQCAAAAqDFmiAEAAJBIFKZf8hCFGW1MChTEAAAASCTMYA1x2v5ZYMkEAAAAGhozxAAAAEgkiiqKwkrKMbyMtiY5CmIAAAAkEoUZFMRh7QtilkwAAACgoTFDDAAAgESiMMxghrj287MUxAAAAEgmrCiqpCuIVQcFce23AAAAAKghZogBAACQSDZLJoKMtiY5ZogBAADQ0JghBgAAQCLZxK6lXIOcAQpiAAAAJDJdCmKWTAAAAKChMUMMAACARKIog5PqojCjrUmOghgAAACJsGQCAAAAmAaYIQYAAEAiYVhRmHKGN23/LFAQAwAAIJkMLsyhsPZriFkyAQAAgIbGDDEAAAASiaIMTqqLWDIBAACAA1RUCRVVUhbEFZZMAAAAADXFDDEAAAASmS45xBTEAAAASGS6FMQsmQAAAEBDY4YYAAAAiURR+hziKKr9SXUUxAAAAEgkCkNFKS+skbZ/FlgyAQAAgIbGDDEAAAAS4aQ6AAAAYBpghhgAAADJhOlPqlMdrCGmIAYAAEAiYVRRmLIgDiOWTAAAAAA1xQwxAAAAEokqFUWVlCfVpeyfBQpiAAAAJBJlsIaYHGIAAACgxiiIAQAAkEgUVapZxIlvEzypbt26dTrllFN04oknavXq1S9rf+SRR3T66afrtNNO08UXX6zdu3c7x6QgBgAAQCIjSybS3ca/ZGLr1q266aabtGbNGt1///2666679Mwzz1Tb9+3bp+uuu0633nqr1q5dq9e+9rW6+eabneNSEAMAAOCAsHHjRi1cuFBdXV1qbW3VkiVLtH79+mp7qVTSpz/9ac2dO1eS9NrXvlbPP/+8c1xOqgMAAEAic2a0pD6pbs6MFknSli1bFATBqLbOzk51dnZW72/btk1z5syp3u/u7taTTz5ZvT9z5kydcMIJkqShoSHdeuutOv/8853bQEEMAACACQmCQEEQ6JYr/zqT8Uqlks444wz19/eP+vnKlSt1ySWXVO+HYSjP86r3oygadX/E3r179fd///d63etepzPOOMP5/BTEAAAAmJBcLqf58+erklGG8MDAgNauXfuyn794dliSenp6tGnTpur93t5edXd3j3rMtm3b9KEPfUgLFy7UVVddNa7npyAGAADAhOVyOeVy2ZSSTU1NmjlzpvNxixYt0s0336y+vj61tLRow4YNuuGGG6rtlUpFH/nIR3TyySfr4osvHvfzUxADAADggDB37lytWrVKy5cvV6lU0plnnqkFCxZoxYoVuvTSS7Vlyxb96le/UqVS0fe+9z1J0vz58/XZz37WHNeLoiiail8AAAAAqEfErgEAAKChURADAACgoVEQAwAAoKFREAMAAKChURADAACgoVEQAwAAoKFREAMAAKChURADAACgof3/QWqXJynmzTAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax, ax2,ax3, cax) = plt.subplots(ncols=4,figsize=(10,6), \n", + " gridspec_kw={\"width_ratios\":[1,1,1, 0.1],\"height_ratios\":[1]})\n", + "fig.subplots_adjust(wspace=0.3)\n", + "im = ax.imshow(B2, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax.text(3, -2, 'Original B2')\n", + "im2 = ax2.imshow(B2_mgwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax2.text(3, -2, 'MGWR B2')\n", + "im3 = ax3.imshow(B2_gwr, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "ax3.text(3, -2, 'GWR B2')\n", + "\n", + "divider = make_axes_locatable(ax3)\n", + "\n", + "fig.colorbar(im, cax=cax)\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "\n", + "ax2.set_xticks([])\n", + "ax2.set_yticks([])\n", + "\n", + "ax3.set_xticks([])\n", + "ax3.set_yticks([])\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing parameters (MGWR and GWR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$RMSE_j$ = $\\sqrt{1/n \\sum{(\\beta_j (u_i, v_i) - \\hat{\\beta}(u_i, v_i))^2}}$" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "B0_g=np.hsplit(gwr_params_mean,3)[0]\n", + "B1_g=np.hsplit(gwr_params_mean,3)[1]\n", + "B2_g=np.hsplit(gwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "B0_m=np.hsplit(mgwr_params_mean,3)[0]\n", + "B1_m=np.hsplit(mgwr_params_mean,3)[1]\n", + "B2_m=np.hsplit(mgwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "b0 = B0.reshape(-1,1)\n", + "b1 = B1.reshape(-1,1)\n", + "b2 = B2.reshape(-1,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_0$" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b0_m=[]\n", + "for i in range(1000):\n", + " rmse_b0_m.append(np.sqrt((np.sum((b0 - (np.hsplit(mgwr_params[i],3)[0]))**2))/625))\n", + " \n", + "rmse_b0_g=[]\n", + "for i in range(1000):\n", + " rmse_b0_g.append(np.sqrt((np.sum((b0 - (np.hsplit(gwr_params[i],3)[0]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2\n", + "\n", + "rmse_b0 = rmse_b0_g+rmse_b0_m\n", + "d = {\"model\":model,\"rmse_b0\":rmse_b0}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEPCAYAAABcA4N7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XtcVHXCBvBnuDuIwSjDeElX8s0wGBcpYdnCG8LKQmGxyWriJ2syq2WjTcNLZZpiZtJmmwluurmw0EdJnbblYubWCunCVjBi+RqWmjozNWqAgMCc9w9eZpvM4zByPAPzfP/yN+fAeUYGnnM/CkEQBBAREV2Bh9wBiIjItbEoiIhIFIuCiIhEsSiIiEgUi4KIiESxKIiISBSLgoiIRLEoiIhIFIuCiIhEsSiIiEgUi4KIiER5yR3AGVarFc3NzfD29oZCoZA7DhFRnyAIAtrb2+Hv7w8PD8e3E/pkUTQ3N+Po0aNyxyAi6pNuvvlmBAQEODx/nywKb29vAF1v1sfHR+Y0RER9w6VLl3D06FHb31BH9cmi6N7d5OPjA19fX5nTEBH1LT3dZc+D2UREJErSotDr9UhKSkJCQgIKCgoum3748GHce++9uOuuu7BgwQJ8//33UsYhIiInSFYURqMRubm5KCwsxK5du1BcXIxjx47ZzbN69WpkZmZiz549GD16NP785z9LFYeIiJwkWVFUVlYiJiYGgYGBUCqVSExMRGlpqd083ae5AkBLSwv8/PykikNEfZDFYkF2djbOnTsndxS3JllRmEwmBAcH28ZqtRpGo9FunuzsbCxfvhx33HEHKisrkZ6eLlUcIuqDioqKUF9fj6KiIrmjuDXJznqyWq12R9YFQbAbt7a2YtmyZdi2bRu0Wi22bt2Kp59+Gnl5eQ4vw2Aw9GpmInIdjY2NqKiogCAIKC8vR1hYWI/O/afeI1lRaDQaVFdX28Zmsxlqtdo2Pnr0KHx9faHVagEAs2bNwh//+MceLSM8PJynxxL1U6+//rrd+MiRI1i4cKFMafqHtrY2p1awJdv1FBsbi6qqKlgsFrS0tKC8vBxxcXG26aNGjcLZs2fR0NAAAHj//fcREREhVRwi6mP279+Pjo4OAEBHRwc++OADmRO5L8m2KEJCQpCVlYWMjAy0t7cjLS0NWq0WOp0OmZmZiIiIQE5ODp544gkIgoDBgwdjzZo1UsUhoj5m8uTJqKioQEdHB7y8vDBlyhS5I7kthSAIgtwheqp784m7noj6L4vFAp1Oh0uXLsHHxwdbtmxBUFCQ3LH6NGf/dvLKbCJySSqVCtOmTYNCoUB8fDxLQkZ98l5PROQe0tPTceLECZ46LzMWBRG5LJVKhbVr18odw+1x1xMREYliURARkSgWBRERiWJREBGRKBYFERGJYlEQEZEoFgUREYliURARkSgWBRERiWJREBGRKBYFERGJYlEQEZEoFgUREYmS9O6xer0emzZtQkdHB+bNm4c5c+bYph05cgTZ2dm2scViwQ033IB3331XykhERNRDkhWF0WhEbm4uSkpK4OPjg/T0dERHR2PMmDEAgLCwMOzevRsA0NLSgt/85jdYsWKFVHGIiMhJku16qqysRExMDAIDA6FUKpGYmIjS0tKfnHfz5s24/fbbcdttt0kVh4iInCTZFoXJZEJwcLBtrFarUVtbe9l8jY2NePvtt6HX66WKQkRE10CyorBarVAoFLaxIAh242579uxBfHw8Bg8e3ONlGAyGa8pIRERXJ1lRaDQaVFdX28Zmsxlqtfqy+fbu3YsFCxY4tYzw8HD4+vo6nZGIyJ20tbU5tYIt2TGK2NhYVFVVwWKxoKWlBeXl5YiLi7ObRxAEHD58GJGRkVLFICKiayRZUYSEhCArKwsZGRlITU1FcnIytFotdDod6urqAHSdEuvt7c2tAiIiF6YQBEGQO0RPdW8+cdcTEZHjnP3bySuziYhIFIuCiIhEsSiIiEgUi4KIiESxKIiISBSLgoiIRLEoiIhIFIuCiIhEsSiIiEgUi4KIiESxKIiISBSLgoiIRLEoiIhIFIuCiIhEsSiIiEgUi4KIiESxKIiISJSkRaHX65GUlISEhAQUFBRcNr2hoQFz587FXXfdhQcffBAXLlyQMg4RETlBsqIwGo3Izc1FYWEhdu3aheLiYhw7dsw2XRAELFy4EDqdDnv27EFYWBjy8vKkikNERE6SrCgqKysRExODwMBAKJVKJCYmorS01Db98OHDUCqViIuLAwA88sgjmDNnjlRxiIjISV5SfWOTyYTg4GDbWK1Wo7a21jY+ceIEhgwZgqVLl+LIkSMIDQ3FM88806NlGAyGXstLREQ/TbKisFqtUCgUtrEgCHbjjo4OHDp0CH/9618RERGBV155BWvXrsXatWsdXkZ4eDh8fX17Nbc7amhowJIlS7B27VqMHj1a7jhEJJG2tjanVrAl2/Wk0WhgNpttY7PZDLVabRsHBwdj1KhRiIiIAAAkJyfbbXHQ9bN+/XpcvHgR69evlzsKEbkgyYoiNjYWVVVVsFgsaGlpQXl5ue14BABERkbCYrHg888/BwDs27cPt956q1Rx6AoaGhpw8uRJAF27A48fPy5zIiJyNZIVRUhICLKyspCRkYHU1FQkJydDq9VCp9Ohrq4Ofn5++NOf/oTly5fj17/+NQ4ePIjs7Gyp4tAV/HgrglsVRPRjCkEQBLlD9FT3fjYeo7h2KSkpl72m1+tlSEJEUnP2byevzHZzN954o9145MiRMiUhIlfFonBzTz31lOiYiIhF4eZCQ0Ph7+8PABg4cCBPjyWiy7Ao3JzFYsGlS5cAdO2/PHfunMyJiMjVsCjcXFFREbrPZxAEAUVFRTInIvovi8WC7OxsrsDIjEXh5vbv34+Ojg4AXVfLf/DBBzInIvqvoqIi1NfXcwVGZiwKNzd58mR4eXXdycXLywtTpkyRORFRF4vFgvfffx+CIGDv3r3cqpARi8LNpaenw2q1Aui6P1d6errMiYi6FBUV2X02uVUhHxYFEbkk7hZ1HSwKN1dUVGS7q69CoeBaG7kM7hZ1HSwKN7d//350dnYCADo7O7nWRi4jPT3dbiWGu0Xlw6Jwc1xrI1elUqmg0WgAAEOHDkVQUJDMidwXi8LNpaenw8Oj62Pg4eHBtTZyGRaLBWfOnAEAnD59mmc9yYhF4eZUKhWmTZsGhUKB+Ph4rrWRyygqKrLbLcrjZ/JhURDS09Mxbtw4bk2QS/nggw/s7hrA42fyYVEQvv76axw5cgQnTpyQOwqRTXBwsOiYrh9Ji0Kv1yMpKQkJCQkoKCi4bPprr72GKVOm4O6778bdd9/9k/OQ9F588UVYrVasXbtW7ihENiaTyW5sNBplSkJeUn1jo9GI3NxclJSUwMfHB+np6YiOjsaYMWNs8xgMBmzYsAGRkZFSxaCr+OSTT9Dc3AwAaGpqwmeffYbx48fLnIoIUKvVtue5A12PVyZ5SLZFUVlZiZiYGAQGBkKpVCIxMRGlpaV28xgMBmzevBkpKSlYuXIl2trapIpDV/Diiy/ajblVQa7CbDbbjX+8hUHXj2RbFCaTyW6folqtRm1trW3c3NyMsLAwLFq0CKNGjUJ2djZef/11ZGVlObwMg8HQq5ndUffWRLempibU1NTIlIbovwICAtDa2mo35mdTHpIVhdVqtV1VCXSdtfDDsb+/P/Lz823j+fPnY+nSpT0qip4+IJwcExUVJXcEIjQ2Nl425mfz2rS1tTm1gi1ZUWg0GlRXV9vGZrMZarXaNj59+jQqKyuRlpYGoKtIuq8QJiL57du3DxUVFbItX6lU2m1RKJVKLFmyRLY806dPx9SpU2VbvpwkO0YRGxuLqqoqWCwWtLS0oLy8HHFxcbbpfn5+eOmll3Dy5EkIgoCCggJMnz5dqjhE1Mfw9FjX0aNV+ObmZnh6esLPz++q84aEhCArKwsZGRlob29HWloatFotdDodMjMzERERgZUrV2LhwoVob2/HhAkT8MADDzj9Roiod02dOlX2Neh58+bBYrEgKSkJCxculDWLO7tqUTQ3N2P9+vXQ6/W2A5+DBg3CtGnTkJ2djUGDBl3xa1NSUpCSkmL32g+PSyQmJiIxMdHZ7ETUzwUHB6O1tZV3DZDZVXc9LVu2DP7+/ti9ezcMBgMMBgNKSkowZMgQLF68+HpkJAl13xCwm6enp0xJiC7n7e2N0NBQ3oNMZlctii+++AJPPfUUhg8fDk9PT3h6emL48OF48skn7S6Gob6J+4GJ6GquWhTe3t4/WQgnTpzgWUr9wI8vYuJFTUT0Y1f9S//kk09i1qxZ0Gq10Gg0UCgUMBqNqK2txZo1a65HRpJQ9905u3U/zJ6IqNtVi2Ly5Ml49913ceDAAZw5cwaCICAyMhIvvPACVCrV9chIREQycug6CpVKhZSUFEybNg3+/v64ePEimpqapM5GREQuwOEL7nbu3ImMjAzU1dWhuroas2fPRllZmZTZ6Dr45S9/aTe+4447ZEpCRK7K4aPR27ZtwzvvvGO7Dcfp06exYMECXgfRxz388MM4cOCA3ZiI6IccLgpvb2+7ezUNGzYM3t7ekoRyF3LfS6fbgAED0NLSgoCAAKxbt062HO58Lx0iV3bVojh8+DAAYOzYsVi5ciVmzZoFT09PlJSUYMKECZIHpOvDw8MDw4YNkzsGEbmgqxbF7373O7vx/v37bf9WKBRYvnx5r4dyF65wLx0Atjty5uTkyJyEiFzRVYti3759V/0mb775JubPn98rgYiIyLX0ym3G9Xp9b3wbIiJyQb1SFD++upeIiPqPXimKHz7ilIiI+hfJnnBHRET9g6RFodfrkZSUhISEBBQUFFxxvv3797vE2T9ERHS5XrlP+E8dozAajcjNzUVJSQl8fHyQnp6O6OhojBkzxm6+b7/9Fi+++GJvxCAiIgn0aIuitbUVX3zxBQRBQEtLi+31Bx988LJ5KysrERMTg8DAQCiVSiQmJqK0tPSy+ZYvX47HH3/ciehERHQ9OFwUn376KeLj47FgwQIYjUZMnjwZ//nPfwDgsudiA10PwPnh09LUajWMRqPdPG+99RbGjRuH8ePHO5ufiIgk5vCup3Xr1mHbtm146qmnoNFosG7dOqxevRo7d+78yfmtVqvd2VCCINiNjx49ivLycmzbtg1nz551KrzBYHDq68heY2MjAKCmpkbmJET2+Nl0DQ4XRWtrq93xhUmTJiE3N/eK82s0GlRXV9vGZrPZ7qaCpaWlMJvNuPfee9He3g6TyYTZs2ejsLDQ4fDh4eHw9fV1eH76aTt27AAAREVFyZyEyB4/m72rra3NqRVsh3c9eXl54cKFC7atgoaGBtH5Y2NjUVVVBYvFgpaWFpSXlyMuLs42PTMzE2VlZdi9ezfy8vKgVqt7VBJERHR9OFwUCxcuxP3334+zZ8/iySefxG9/+1ssXLjwivOHhIQgKysLGRkZSE1NRXJyMrRaLXQ6Herq6nolPBERSc/hXU9TpkxBaGgoDhw4AKvVisceeww33XST6NekpKRcdqA7Pz//svlGjBjh0M0HiYjo+uvR6bEeHh6YPXs2hg8fjtLSUtuBJiIi6r8cLopnn30W+fn5+PLLL/HMM8/g1KlTWLp0qZTZiIjIBThcFAaDAStWrEBFRQVmzpyJnJwcfPPNN1JmIyIiF+BwUQiCAA8PDxw4cAAxMTEAuk6ZJSKi/s3hohg5ciR0Oh1OnTqFiRMn4g9/+APGjh0rZTYiInIBDp/1lJOTg4qKCkRFRcHb2xu33XYbUlNTpcxGREQuwOEtCqVSidjYWLS2tuLYsWO4/fbbeYyCiMgN9GiLoqCgAAMHDrS9plAoUFVVJUkwIiJyDQ4XRUVFBT766CMEBQVJmYeIiFyMw7uefvazn2HQoEFSZiEiIhfk8BbF3Llzcf/99yM6OhpeXv/9Mj50iIiof3O4KPLy8jBw4EDetoOIyM04XBQtLS3429/+JmUWIiJyQQ4foxg9ejQ+//xzKbMQEZELcniL4syZM0hLS8Pw4cPh4+Nje12v10sSjIiIXIPDRXHx4kW8+eabUmYhIiIX5HBRKJVKjBw5EhqNxuFvrtfrsWnTJnR0dGDevHmYM2eO3fSKigq8+uqrsFqtiIiIwMqVK+22VoiISH49Opg9bdo0aDQaKJVK2+tX2vVkNBqRm5uLkpIS+Pj4ID09HdHR0RgzZgyAri2UlStX4p133sGQIUOQlZWFd955B7NmzbrGt0RERL3J4aJYtmxZj75xZWUlYmJiEBgYCABITExEaWmp7boLpVKJffv2wdvbGy0tLfjuu+94QR8RkQtyuCgmTpzYo29sMpkQHBxsG6vVatTW1trN4+3tjX/+859YvHgx1Go17rjjjh4tg4iIpOdwUfSU1WqFQqGwjQVBsBt3mzRpEg4ePIgNGzZgxYoVePnllx1ehsFgcDrfP/7xD5w9e9bpr+9Puv8feJV9F41GgxkzZsgdgwDbBb41NTUyJ3FvkhWFRqNBdXW1bWw2m6FWq23j8+fPw2Aw2LYiUlJSkJWV1aNlhIeHw9fX16l8O3bswNcnT8PTL9Cpr+9PrELXCQSnzBdlTiK/ztbzCAgIQFRUlNxRCF2/pwD48+glbW1tTq1gS1YUsbGx2LhxIywWCwYMGIDy8nKsWrXKNl0QBCxatAg7d+7EsGHDUFpaigkTJkgV5yd5+gVCOWradV0mubaLX78vdwQilyNZUYSEhCArKwsZGRlob29HWloatFotdDodMjMzERERgVWrVmHBggVQKBQYM2YMnn/+eaniEBGRkyQrCqBrd1JKSorda/n5+bZ/x8fHIz4+XsoIRER0jRy+1xMREbknFgUREYliURARkSgWBRERiWJREBGRKBYFERGJkvT0WCLqufz8fDQ0NMgdwyV0/z8sWbJE5iSuITQ0FDqd7rovl0VB5GIaGhrwv0cOQzOQv54DBCsAoPHkFzInkd/Zpg7Zls1PIpEL0gz0wgNaldwxyIVsrbXItmy3LYpz586hs/U87+1Ddjpbz+PcOT5lkeiHeDCbiIhEue0WRVBQEM6eu8S7x5Kdi1+/j6CgILljELkUblEQEZEoFgUREYliURARkSgWBRERiZK0KPR6PZKSkpCQkICCgoLLpu/duxd333037rrrLjz66KO4cOGClHGIiMgJkhWF0WhEbm4uCgsLsWvXLhQXF+PYsWO26U1NTVixYgXy8vKwZ88ejB07Fhs3bpQqDhEROUmyoqisrERMTAwCAwOhVCqRmJiI0tJS2/T29nY899xzCAkJAQCMHTsWZ86ckSoOERE5SbKiMJlMCA4Oto3VajWMRqNtHBQUhOnTpwMAWltbkZeXx+dnExG5IMkuuLNarVAoFLaxIAh2426NjY147LHHcMstt2DmzJk9WobBYHA6X2Njo9NfS/1bY2MjampqZF0+0U+R67MpWVFoNBpUV1fbxmazGWq12m4ek8mEBx98EDExMVi6dGmPlxEeHg5fX1+n8u3YsQMwX3Tqa6l/CwgIQFRUlGzL37FjBxrPy7Z4cmHX+tlsa2tzagVbsqKIjY3Fxo0bYbFYMGDAAJSXl2PVqlW26Z2dnXjkkUcwY8YMPProo1LFEMWbAnaxdrQCADy8/GROIr/O1vMAQuSOQeRSJCuKkJAQZGVlISMjA+3t7UhLS4NWq4VOp0NmZibOnj2L+vp6dHZ2oqysDEDXFsLq1aulimQnNDT0uiynL+h+OExoKP9AAiH8bBD9iKQ3BUxJSUFKSorda/n5+QCAiIgIfP7551IuXpQcT4lyVd1PD8vJyZE5CRG5Il6ZTUREolgUREQkikVBRESiWBRERCSKRUFERKLc9lGoRK7q3Llz+LapA1trLXJHIRdytqkDHefOybJsblEQEZEoblEQuZigoCB4NZnwgFYldxRyIVtrLQgICpJl2dyiICIiUSwKIiISxaIgIiJRLAoiIhLFoiAiIlEsCiIiEsWiICIiUSwKIiISxaIgIiJRkhaFXq9HUlISEhISUFBQcMX5Fi9ejJKSEimjEBGRkyQrCqPRiNzcXBQWFmLXrl0oLi7GsWPHLpvnkUcesT0zm4iIXI9kRVFZWYmYmBgEBgZCqVQiMTERpaWldvPo9XpMmzYNM2bMkCoGERFdI8luCmgymRAcHGwbq9Vq1NbW2s3z0EMPAQBqamqcWobBYHA+INk0NjYCcP7nQL2r++dB9GONjY2y/J5KVhRWqxUKhcI2FgTBbtwbwsPD4evr26vf0x3t2LEDABAVFSVzEgK6fh7/e4rPowCApktWAMBAH553c7apA/9zY8A1/Z62tbU5tYItWVFoNBpUV1fbxmazGWq1WqrFEfUboaGhckdwGeaGBgDA0Bv5fxIA+T4bkhVFbGwsNm7cCIvFggEDBqC8vByrVq2SanFE/YZOp5M7gstYsmQJACAnJ0fmJO5Nsu25kJAQZGVlISMjA6mpqUhOToZWq4VOp0NdXZ1UiyUiol4m6RPuUlJSkJKSYvdafn7+ZfOtXbtWyhhERHQNeISIiIhEsSiIiEgUi4KIiESxKIiISBSLgoiIREl61hOJ27dvHyoqKuSOgYb/v6ip+5x1uUyfPh1Tp06VNQMRXY5FQVCpVHJHICIXxqKQ0dSpU7kGTUQuj8coiIhIFIuCiIhEsSiIiEgUi4KIiESxKIiISBSLgoiIRLEoiIhIFIuCiIhESXrBnV6vx6ZNm9DR0YF58+Zhzpw5dtOPHDmCZcuWobm5Gbfddhuef/55eHnxGkAiV+AKt5hxldvLAO59ixnJtiiMRiNyc3NRWFiIXbt2obi4GMeOHbObZ9GiRXj22WdRVlYGQRDw9ttvSxWHiPoglUrFW8y4AMlW3ysrKxETE4PAwEAAQGJiIkpLS/H4448DAL755hu0trbi5z//OQDgnnvuwauvvorZs2dLFYmIeoC3mKFukhWFyWRCcHCwbaxWq1FbW3vF6cHBwTAajT1ahsFguPagREQkSrKisFqtUCgUtrEgCHbjq013RHh4OHx9fa89LBGRG2hra3NqBVuyYxQajQZms9k2NpvNUKvVV5z+7bff2k0nIiLXIFlRxMbGoqqqChaLBS0tLSgvL0dcXJxt+vDhw+Hr64uamhoAwO7du+2mExGRa5CsKEJCQpCVlYWMjAykpqYiOTkZWq0WOp0OdXV1AID169cjJycHv/rVr3Dx4kVkZGRIFYeIiJykEARBkDtET3XvZ+MxCiIixzn7t5NXZhMRkag+eRl090bQpUuXZE5CRNR3dP/N7OmOpD5ZFO3t7QCAo0ePypyEiKjvaW9vh5+fn8Pz98ljFFarFc3NzfD29u7xtRdERO5KEAS0t7fD398fHh6OH3nok0VBRETXDw9mExGRKBYFERGJYlEQEZEoFgUREYliURARkSgWBRERiWJREBGRKBYFERGJYlEQEZGoPnmvJ+q5l19+GWVlZQgKCkJwcDAOHDiAV155BZMmTcKGDRtQX1+PLVu2wGQyYf78+XjjjTfw0EMPISgoCH5+fti6davcb4H6gYMHD+KNN96At7c3Tp06halTp0KpVGLv3r0AgLy8PBw6dAivvvoqlEolwsLC0NnZiZtvvhnfffcdFi1ahH/961/IzMzEoUOH4OXlhRkzZmD79u247777oNVqceTIERQWFmLw4MEyv9v+g1sUbmDfvn2oqanBu+++i7y8PNTX12Px4sX4+OOPAQDV1dVoaGhAZ2cnPvroI0yaNAkAcPz4cbz00kssCepVn332GZ5//nns3LkTBQUFUKlUKCkpwdixY1FUVIQ1a9bgL3/5C3bs2IELFy4AACZNmoSqqioAwMcffww/Pz/U19fj5MmTCAgIwJAhQwAAcXFxKCsrY0n0MhaFG6isrMSMGTPg4+ODG264AfHx8bBYLKiqqkJTUxMAYOzYsTh8+DA+/PBDTJkyBQAwePBgjBgxQs7o1A/dfPPNGDp0KAYMGICgoCD84he/AAAMGzYMZWVliIyMREhICDw8PJCamgoAuOmmm9DU1IQLFy6guroas2fPxqFDh/Dhhx/aVmwAYPz48bK8p/6OReEGPDw8YLVa7V4bOnQorFYrysvLMWHCBERHR+Pjjz/G4cOHERkZCQA9ug0xkaO8vb3txp6ennb//vFntdudd96JiooKKBQKTJ06Ff/+97/x0Ucf2VZsAPCJlxJhUbiB2NhYlJeX49KlS2hqasL+/fuhUCgQFxeHTZs2YeLEiYiJicH27dsxfvx4u19couspMjISdXV1MJlMEAQB7733nu1RApMmTcLmzZsRFRWFsLAwfPnllzh+/DjGjRsnc+r+jwez3cDkyZPxySefYObMmbjhhhugVqvh6+uLyZMnY+vWrYiKioJSqUR7e7vd2hnR9aZSqbB8+XLMnz8fPj4+GDFiBAYNGgQAiI6OhtlsxsSJE6FQKBAWFoagoCCZE7sHPo/CDXzyySf46quvMHPmTLS3t2PWrFlYs2YNbrnlFrmjEdk5d+4ctm/fjscffxweHh544YUXMGrUKMydO1fuaG6NWxRuYPTo0XjttdewdetWCIKA1NRUlgS5pMDAQHz//fdITk6Gp6cnbr31Vtx3331yx3J73KIgIiJRPJhNRESiWBRERCSKRUFERKJYFETXwYIFC1BSUiI6z8GDB5GcnHydEhE5jkVBRESieHos0U84ePAgNmzYgKFDh+L48eMYMGAAHn74YWzfvh3Hjx9HQkICli5diuLiYmzfvh0eHh4YMmQInnnmGYwePRpGoxHZ2dkwmUwYNmwYvvvuO9v3/vLLL7F69WqcP38enZ2dmDt3LtLS0mR8t0TiWBREV1BXV4fnnnsO48aNw0MPPYS8vDy89dZbaGpqQlxcHCIiIrBlyxYUFxfb7oD62GOP4e9//ztWrlyJ8ePH44knnsDXX39tu7ldR0cHMjMzsW7dOtx6661obGzErFmzMGbMGJnfLdGVsSiIrmDEiBG2+wiNHDkSAQEB8PHxgUqlgr+/P8rKypCUlASVSgUAuOeee7B69WqcOnUKlZWVePrppwEAo0aNQnR0NADgq6++wokTJ7B06VLbclpbW1FfwD4iAAABFklEQVRfX4+bbrrpOr9DIsewKIiuwMfHx27s5WX/69J9s7ofEgQBHR0dUCgU+OG1rN1f29nZiYCAAOzevds27dtvv0VAQAA+/fTT3oxP1Gt4MJvISRMnTsR7770Hi8UCANi5cycCAwMxatQo3HnnnSguLgYAnD59GgcPHgTQdTsVPz8/W1GcOXMGycnJMBgM8rwJIgdwi4LISdHR0fDw8MC8efNgtVqhUqmwefNmeHh44LnnnsOSJUswY8YMaDQa2721fHx88Prrr2P16tXYsmULOjo68Pvf/x5RUVG2MiFyNbzXExERieKuJyIiEsWiICIiUSwKIiISxaIgIiJRLAoiIhLFoiAiIlEsCiIiEsWiICIiUf8Hn7hX86VBqmAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['rmse_b0'],x=df['model'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_1$" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b1_m=[]\n", + "for i in range(1000):\n", + " rmse_b1_m.append(np.sqrt((np.sum((b1 - (np.hsplit(mgwr_params[i],3)[1]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b1_g=[]\n", + "for i in range(1000):\n", + " rmse_b1_g.append(np.sqrt((np.sum((b1 - (np.hsplit(gwr_params[i],3)[1]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2\n", + "rmse_b1=[]\n", + "rmse_b1 = rmse_b1_g+rmse_b1_m\n", + "d = {\"model\":model,\"rmse_b1\":rmse_b1}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEPCAYAAABcA4N7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHTRJREFUeJzt3X9Q1HXix/HXriwgpskaiuk3Sysj9RK5sJoSJFESmzPOUcqy9OLMqbjrOhSRdM4501HPqcbxUisrx44cyay7klDyzPDHyfXDFc860UtAQV0yUPm93z8891rRjyuxfFb3+fiL936W3dfiuq99f35aXC6XSwAAXITV7AAAAP9GUQAADFEUAABDFAUAwBBFAQAwRFEAAAxRFAAAQxQFAMAQRQEAMERRAAAMBfnywV9++WXl5eXJYrFo3Lhxmjx5ssfypUuXKjc3V126dJEkjR8/XhMnTvRlJADAZfJZUezatUs7duzQBx98oMbGRo0ePVpxcXHq27ev+z4Oh0NLlixRdHT0ZT12c3OzTp06JZvNJovF0tbRAeCq5HK51NDQoE6dOslq9X6Fks+KIjY2Vm+//baCgoJUUVGhpqYmhYWFedzH4XBo+fLlKisr05133qkZM2YoJCTkko996tQpffPNN76KDgBXtVtvvVWdO3f2+v4+XfVks9n0yiuv6I033lBSUpJ69OjhXnbq1ClFRUUpIyNDffr0UWZmppYtW6bnnnvOq8eVzr7Y4OBgn+UHgKtJfX29vvnmG/dnqLcs7XGa8TNnzuipp57S6NGjNWHChAvep7i4WFlZWXr//fcv+Xh1dXVyOBxtHRMAAsLAgQO9Wntzjs9mFAcOHFB9fb2ioqLUsWNHjRw5Uvv373cvLy8vV2FhocaNGyfp7LqzoKDLi3O5LxYAAllrv2T7bPfY0tJSZWdnq76+XvX19dq8ebNiYmLcy0NDQ7Vo0SIdPnxYLpdLa9asUWJioq/iAABayWcziri4OH399dcaO3asOnTooJEjRyo5OVlpaWlKT0/XoEGDNHfuXE2bNk0NDQ0aMmRIi91nAQDma5dtFG3t3PSJVU9tw+l0auHChZoxY4bCw8PNjgPAR1r72cmR2VBOTo6Ki4uVk5NjdhQAfoiiCHBOp1ObN2+Wy+XSpk2bVFVVZXYkAH6GoghwOTk5am5ulnT2iHdmFQDOR1EEuC1btqixsVGS1NjYqE8//dTkRAD8DUUR4OLj493HrwQFBWn48OEmJwLgbyiKAJeamuo+OZjValVqaqrJiQD4G4oiwNntdt1///2yWCwaMWIEu8cCaMGnJwXElSE1NVXfffcdswkAF0RRQHa7XQsWLDA7BgA/xaonAIAhigIAYIiiAAAYoigAAIYoCgCAIYoCAGCIogAAGKIoAACGKAoAgCGKAgBgiKIAABiiKAAAhigKAIAhigIAYIiiAAAYoigAAIYoCgCAIYoCAGCIogAAGKIoAACGfFoUL7/8skaPHq3k5GStWrWqxfJ9+/YpJSVFo0aN0qxZs9TY2OjLOLgIp9OpzMxMVVVVmR0FgB/yWVHs2rVLO3bs0AcffKDc3FytXr1aJSUlHvfJyMjQ7NmzlZeXJ5fLpbVr1/oqDgzk5OSouLhYOTk5ZkcB4Id8VhSxsbF6++23FRQUpBMnTqipqUlhYWHu5WVlZaqtrdXgwYMlSSkpKdq4caOv4uAinE6nNm3aJJfLpfz8fGYVAFrw6aonm82mV155RcnJybr77rvVo0cP97LKykpFRES4xxEREaqoqPBlHFxATk6Oe5VfY2MjswoALQT5+gnS09OVlpamp556SmvXrtWECRMkSc3NzbJYLO77uVwuj7E3HA5Hm2YNRJs3b5bL5ZJ09t9g06ZNio2NNTkVAH/is6I4cOCA6uvrFRUVpY4dO2rkyJHav3+/e3lkZKSOHTvmHh8/flzdu3e/rOcYOHCgQkJC2ixzIOrRo4cOHz7sHkdGRiomJsbERAB8pa6urlVfsH226qm0tFTZ2dmqr69XfX29Nm/e7PEB1KtXL4WEhKioqEiStGHDBg0bNsxXcXARPy7rC40BwGdFERcXp/j4eI0dO1a//OUvFR0dreTkZKWlpWnPnj2SpMWLF2v+/PlKSkrS6dOnNWnSJF/FwUUMHz7cvcrPYrFo+PDhJicC4G8srnMrqK8g56ZPrHr66ZxOpyZPnqzm5mZZrVa9+eabCg8PNzsWAB9o7WcnR2bDY2M2AJyPoghwOTk5HkXB7rEAzkdRBLhPP/3UcAwAFEWA+/FBjxcaAwBFEeDO3x22srLSpCQA/BVFEeDO3z02ISHB5EQA/A1FEeBSU1MVFHT2AP2goCClpqaanAiAv6EoApzdbteIESNksViUmJjIMRQAWqAooKSkJHXs2FFJSUlmRwHghygKaOPGjTpz5gzXAwFwQRRFgHM6ne5TjW/atIkLFwFogaIIcDk5OWpubpZ09hohHJkN4HwURYDbsmWLxxXuODIbwPkoigAXHx/vsXsspxkHcD6KIsClpqbKaj37NrBarRxHAaAFiiLA2e123X///bJYLBoxYgTHUQBowWfXzMaVIzU1Vd999x2zCQAXRFFAdrtdCxYsMDsGAD/FqifI6XQqMzOTYygAXBBFAeXk5Ki4uJhjKABcEEUR4DgyG8ClUBQBjiOzAVwKRRHgODIbwKVQFAEuPj7e4wp3HJkN4HwURYBLSkqSy+WSJLlcLq5JAaAFiiLAbdy40WNGwTUpAJyPoghwW7Zs8ZhRsI0CwPkoigDH2WMBXApFEeBSU1M9Vj1xvicA5/PpuZ6WLl2qjz/+WJIUFxen6dOnt1iem5urLl26SJLGjx+viRMn+jISzmO329WtWzcdPXpU3bp14+yxAFrwWVEUFhZq27ZtWr9+vSwWi5588knl5+crMTHRfR+Hw6ElS5YoOjraVzFwCU6nU0ePHpUkHT16VFVVVZQFAA8+W/UUERGhzMxMBQcHy2azqV+/fiovL/e4j8Ph0PLly/Xggw9q7ty5qqur81UcXMSKFSsMxwDgs6K45ZZbNHjwYEnSoUOH9PHHHysuLs69/NSpU4qKilJGRobWr1+vH374QcuWLfNVHFzE559/7jHetm2bSUkA+CufX4/i22+/1dSpUzV9+nTdeOON7ts7deqklStXusdTpkxRVlaWnnvuOa8f2+FwtGVU/FdRUZHZEQD4EZ8WRVFRkdLT05WVlaXk5GSPZeXl5SosLNS4ceMknd2H/9xumt4aOHCgQkJC2iwvzoqJiTE7AgAfqKura9UXbJ+tejpy5IiefvppLV68uEVJSFJoaKgWLVqkw4cPy+Vyac2aNR4bugEA/sFnM4rXX39ddXV1HpfYTE1NVUFBgdLT0zVo0CDNnTtX06ZNU0NDg4YMGaLJkyf7Kg4uomPHjjpz5ox7HBYWZmIaAP7I4jp3/oYryLnpE6uefrqtW7dq0aJF7vGMGTN07733mpgIgK+09rOTI7MD3Pkbrnfv3m1SEgD+iqIIcFu3bvUY//3vfzcpCQB/RVEEuHOXQb3YGAAoigAXGRnpMe7Zs6dJSQD4K4oiwJ04ccJwDAAURYDr3r274RgALnkcxapVqwyXc+xD6xUUFCg/P9/UDGVlZR7j0tJSzZw505QsiYmJSkhIMOW5AVzcJYti//79ysvLU1JSUnvkQTvr2rWrnE6nxxgAfuySRbFgwQIdOXJE99577wVPxYHWS0hIMP0btNPp1BNPPCGXyyWbzaaXXnqJ61EA8ODVNorZs2frn//8p6+zwAR2u91dDImJiZQEgBa8OtdTv3799MILL/g6C0wSERGh2tparpcN4IIu66SABw4c0Pbt2xUUFKS7775bffr08VUutCObzaa+ffsymwBwQV7vHpubm6tJkybp66+/1u7duzVx4kTl5eX5MhsAwA94PaN48803tX79evd+9uXl5Zo6dapGjRrls3AAAPN5PaOw2WweB2Ndf/31stlsPgkFAPAfl5xR7N27V5LUv39/zZ07VxMmTFCHDh303nvvaciQIT4PCAAw1yWL4tlnn/UYb9myxf2zxWJRdnZ2m4cCAPiPSxZFQUHBJR/kjTfe0JQpU9okEADAv7TJSQE//PDDtngYAIAfapOiuAIvuw0A8FKbFIXFYmmLhwEAD06nU5mZmaqqqjI7SkDjehQA/FZOTo6Ki4uVk5NjdpSARlEA8EtOp1ObN2+Wy+XSpk2bmFWYiG0UAPxSTk6OmpqaJElNTU3MKkx0WUVRW1ur/fv3y+Vy6cyZM+7bf/WrX7V5MACBbcuWLR5F8emnn5qcKHB5XRRffvmlRowYoalTp6qiokLx8fHua1Q8+OCDPgsIIDDdddddHuN77rnHpCTwuigWLlyoN998U127dlVkZKQWLlyoefPm+TIbgABWX1/vMa6rqzMpCbwuitraWt18883ucVxcnHtaCABtbefOnR7jHTt2mJQEXhdFUFCQTp486T5moqSkxGehAOD8nWTYacY8XhfFtGnT9Oijj+ro0aP63e9+p4cffljTpk0z/J2lS5cqOTlZycnJWrhwYYvl+/btU0pKikaNGqVZs2apsbHx8l8BgKvSsGHDPMbx8fHmBIH3RTF8+HAtXbpUzz77rIYMGaJ33nnH8KJFhYWF2rZtm9avX6/3339fe/fuVX5+vsd9MjIyNHv2bOXl5cnlcmnt2rWtfyUAripjx471GP/iF78wKQkua/dYq9WqRx55RL169dLGjRtVXV190ftGREQoMzNTwcHBstls6tevn8rLy93Ly8rKVFtbq8GDB0uSUlJStHHjxla+DABXm/M/D/h8MI/XRTF79mytXLlSBw4c0AsvvKDS0lJlZWVd9P633HKLuwQOHTqkjz/+WHFxce7llZWVioiIcI8jIiJUUVHRmtcA4Cr042vfSOI4ChN5fc1sh8OhdevWacWKFXrooYf0/PPPKyUl5ZK/9+2332rq1KmaPn26brzxRvftzc3NHicTdLlcl31yQYfDcVn3x4WdmxkWFRWZnAT4nwEDBuiLL75QU1OTOnTooAEDBvAeNYnXReFyuWS1WvX555/rqaeeknR2l1kjRUVFSk9PV1ZWlpKTkz2WRUZG6tixY+7x8ePHPa7J7Y2BAwcqJCTksn4HLa1bt06SFBMTY3IS+JOCgoIW2xXbU0NDg3sX/ObmZlVXV7vfq2ZITExUQkKCac/fFurq6lr1BdvrVU833HCD0tLSVFpaqtjYWD3//PPq37//Re9/5MgRPf3001q8eHGLkpCkXr16KSQkxP0NYcOGDS32cgAQuGw2mzp06CBJCg8Pl81mMzlR4PJ6RjF//nzl5+crJiZGNptNP//5z1vslfBjr7/+uurq6rRgwQL3bampqSooKFB6eroGDRqkxYsXKzs7WzU1NRowYIAmTZr0014NgDaTkJBg+jfo3//+9zp8+LBeeuklhYeHm5olkHldFGFhYbrnnnt08uRJ/fvf/9add96psrIyj6O1fyw7O1vZ2dktbn/44YfdP992222mTiUB+Debzaa+fftSEia7rBnFmjVrdM0117hvs1gs2r59u0+CAQD8g9dFkZ+fr88++4xmB4AA4/XG7BtvvFFdunTxZRYAgB/yekbx2GOP6dFHH9XQoUMVFPS/X3vmmWd8EgwA4B+8LooVK1bommuuMTxtBwDg6uN1UZw5c0Z/+ctffJkFAOCHvN5GcdNNN+lf//qXL7MAAPyQ1zOKI0eOaNy4cerVq5eCg4Pdt3/44Yc+CQYA8A9eF8Xp06f1xhtv+DILAMAPXdaR2TfccIMiIyN9mQcA4Gcua2P2/fffr8jISIWFhblvZ9UTAFzdvC6KWbNm+TIHAMBPeV0UsbGxvswBAPBTl3XNbABA4PF6RnG1WblypUpKSsyO4RfO/R1mzpxpchL/0LdvX6WlpZkdA/AbAVsUJSUlchTvV4fQrmZHMV1z49mriO0rqTA5ifmaar83OwLgdwK2KCSpQ2hXhfW53+wY8COn/7PZ7AiA32EbBQDAUEDPKAB/xPaz/2H7mSeztp9RFICfKSkp0bf79iryGv57dnQ1S5KqD+83OYn5jtY0mvbcvBMBPxR5TZAm/8xudgz4kVVfO017brZRAAAMURQAAEMUBQDAEEUBADBEUQAADLHXE+BnqqqqdLym0dS9XOB/jtY0qrGqypTnZkYBADDEjALwM+Hh4QqqqeQ4CnhY9bVTncPDTXluZhQAAEM+n1HU1NQoNTVVr776qnr37u2xbOnSpcrNzVWXLl0kSePHj9fEiRN9HUnS2fXATbXfc7ZQeGiq/V5VVcFmxwD8ik+L4quvvlJ2drYOHTp0weUOh0NLlixRdHS0L2MAAH4CnxbF2rVrNWfOHE2fPv2Cyx0Oh5YvX66ysjLdeeedmjFjhkJCQnwZyS08PFxHq+q5HgU8nP7PZoWbtB4Y8Fc+LYp58+ZddNmpU6cUFRWljIwM9enTR5mZmVq2bJmee+45rx/f4XC0Olt1dXWrfxdXt+rqahUVFZn6/MCFmPXeNG2vp06dOmnlypXu8ZQpU5SVlXVZRTFw4MBWz0DWrVsnHTvdqt/F1a1z586KiYkx7fnXrVunb0s5jkKSaurPnmb8mmD2uzla06hb/u+nvTfr6upa9QXbtKIoLy9XYWGhxo0bJ0lyuVwKCmJvXaBv375mR/Abx/574aKe/8ffpLPMe2+Y9skcGhqqRYsWaejQoerdu7fWrFmjxMREs+IAfsOMK5j5q3NXtps/f77JSQJbu8/n0tLStGfPHtntds2dO1fTpk1TUlKSXC6XJk+e3N5xAACX0C4zioKCAvfPP94uMWrUKI0aNao9IgAAWoktRAAAQxQFAMAQRQEAMERRAAAMURQAAEMUBQDAUEAfCs1pxs9qbqyVJFmDQk1OYr6m2u8l9TA7BuBXArYoOE3C/5T89zQJffvyASn14L0BnCdgi4LTJPwPp0kAYIRtFAAAQxQFAMAQRQEAMERRAAAMURQAAEMUBQDAEEUBADBEUQDwWw0NDSopKVFVVZXZUQIaRQHAb1VUVOj06dN66623zI4S0AL2yGwAxgoKCpSfn2/a8zc0NOj777+XJG3evFmlpaWy2Wym5UlMTFRCQoJpz28mZhQA/FJFRYXhGO2HGQWAC0pISDD1G/TYsWM9xtXV1ZyPzCTMKAD4pebmZsMx2g9FAcAvWa1WwzHaD395AH5p2LBhHuP4+HhzgoCiAOCfnnjiCVksFkmSxWLR448/bnKiwEVRAPBLdrvdPYtISEhQeHi4uYECGHs9AfBbTzzxhCorK5lNmIyiAOC37Ha7FixYYHaMgMeqJwCAIZ8WRU1NjcaMGaPS0tIWy/bt26eUlBSNGjVKs2bNUmNjoy+jAABayWdF8dVXX+nhhx/WoUOHLrg8IyNDs2fPVl5enlwul9auXeurKACAn8BnRbF27VrNmTNH3bt3b7GsrKxMtbW1Gjx4sCQpJSVFGzdu9FUUAMBP4LON2fPmzbvossrKSkVERLjHERERrTrhl8PhaFU2eKqurpYkFRUVmZwEgD8yZa+n5uZm94E0kuRyuTzG3ho4cKBCQkLaMlpAWrdunSQpJibG5CQAfKmurq5VX7BN2espMjJSx44dc4+PHz9+wVVUAADzmVIUvXr1UkhIiHtVx4YNG1qc1wUA4B/atSjS0tK0Z88eSdLixYs1f/58JSUl6fTp05o0aVJ7RgEAeMnn2ygKCgrcP69cudL982233eZeNw4A8F8cmQ0AMERRAAAMURQAAEMUBQDAEEUBADBEUQAADFEUAABDFAUAwBCXQjVRQUGB8vPzzY6hkpISSdLMmTNNzZGYmKiEhARTMwBoiaKA7Ha72REA+DGKwkQJCQl8gwbg99hGAQAwRFEAAAxRFAAAQxQFAMAQRQEAMERRAAAMURQAAENX5HEULpdLklRfX29yEgC4cpz7zDz3GeqtK7IoGhoaJEnffPONyUkA4MrT0NCg0NBQr+9vcV1utfiB5uZmnTp1SjabTRaLxew4AHBFcLlcamhoUKdOnWS1er/l4YosCgBA+2FjNgDAEEUBADBEUQAADFEUAABDFAUAwBBFAQAwRFEAAAxRFAAAQxQFAMDQFXmuJ1y+P/3pT8rLy1N4eLgiIiL0+eef66WXXlJcXJyWLFmi4uJivfbaa6qsrNSUKVP06quv6sknn1R4eLhCQ0O1atUqs18CrgI7d+7Uq6++KpvNptLSUiUkJCgsLEybNm2SJK1YsUK7du3SK6+8orCwMEVFRampqUm33nqrTpw4oYyMDG3btk3p6enatWuXgoKC9MADD2j16tUaP368fvazn2nfvn1655131K1bN5Nf7dWDGUUAKCgoUFFRkf76179qxYoVKi4u1vTp07Vjxw5J0u7du1VSUqKmpiZ99tlniouLkyQdPHhQixYtoiTQpr766iv94Q9/UG5urtasWSO73a733ntP/fv3V05Ojl588UW99dZbWrdunU6ePClJiouL0/bt2yVJO3bsUGhoqIqLi3X48GF17txZ1113nSRp2LBhysvLoyTaGEURAAoLC/XAAw8oODhY1157rUaMGCGn06nt27erpqZGktS/f3/t3btXW7du1fDhwyVJ3bp1U+/evc2MjqvQrbfeqp49e6pjx44KDw/X3XffLUm6/vrrlZeXp+joaPXo0UNWq1Vjx46VJPXr1081NTU6efKkdu/erUceeUS7du3S1q1b3V9sJOmOO+4w5TVd7SiKAGC1WtXc3OxxW8+ePdXc3KxPPvlEQ4YM0dChQ7Vjxw7t3btX0dHRknRZpyEGvGWz2TzGHTp08Pj5/PfqOffdd5/y8/NlsViUkJCgf/zjH/rss8/cX2wkKSQkxDehAxxFEQDuueceffLJJ6qvr1dNTY22bNkii8WiYcOG6c9//rNiY2N11113afXq1brjjjs8/uMC7Sk6Olp79uxRZWWlXC6XPvroI/elBOLi4rR8+XLFxMQoKipKBw4c0MGDB3X77bebnPrqx8bsABAfH68vvvhCDz30kK699lp1795dISEhio+P16pVqxQTE6OwsDA1NDR4fDsD2pvdbld2dramTJmi4OBg9e7dW126dJEkDR06VMeOHVNsbKwsFouioqIUHh5ucuLAwPUoAsAXX3yhQ4cO6aGHHlJDQ4MmTJigF198UbfddpvZ0QAPVVVVWr16tZ555hlZrVb98Y9/VJ8+ffTYY4+ZHS2gMaMIADfddJOWLl2qVatWyeVyaezYsZQE/FLXrl31ww8/aMyYMerQoYMGDBig8ePHmx0r4DGjAAAYYmM2AMAQRQEAMERRAAAMURRAO5g6daree+89w/vs3LlTY8aMaadEgPcoCgCAIXaPBS5g586dWrJkiXr27KmDBw+qY8eO+vWvf63Vq1fr4MGDGjlypLKysvTuu+9q9erVslqtuu666/TCCy/opptuUkVFhTIzM1VZWanrr79eJ06ccD/2gQMHNG/ePH3//fdqamrSY489pnHjxpn4agFjFAVwEXv27NGcOXN0++2368knn9SKFSv09ttvq6amRsOGDdOgQYP02muv6d1333WfAfXpp5/W3/72N82dO1d33HGHfvvb3+o///mP++R2jY2NSk9P18KFCzVgwABVV1drwoQJuvnmm01+tcDFURTARfTu3dt9HqEbbrhBnTt3VnBwsOx2uzp16qS8vDyNHj1adrtdkpSSkqJ58+aptLRUhYWFmjFjhiSpT58+Gjp0qCTp0KFD+u6775SVleV+ntraWhUXF6tfv37t/AoB71AUwEUEBwd7jIOCPP+7nDtZ3Y+5XC41NjbKYrHox8eynvvdpqYmde7cWRs2bHAvO378uDp37qwvv/yyLeMDbYaN2UArxcbG6qOPPpLT6ZQk5ebmqmvXrurTp4/uu+8+vfvuu5Kk8vJy7dy5U9LZ06mEhoa6i+LIkSMaM2aMHA6HOS8C8AIzCqCVhg4dKqvVqscff1zNzc2y2+1avny5rFar5syZo5kzZ+qBBx5QZGSk+9xawcHBWrZsmebNm6fXXntNjY2N+s1vfqOYmBh3mQD+hnM9AQAMseoJAGCIogAAGKIoAACGKAoAgCGKAgBgiKIAABiiKAAAhigKAICh/wex6wuTfIzaPgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(x=df['model'],y=df['rmse_b1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.5218558005607021" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b1 - (np.hsplit(mgwr_params_mean,3)[1]))**2))/625)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.487375751104697" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b1 - (np.hsplit(gwr_params_mean,3)[1]))**2))/625)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_2$" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b2_m=[]\n", + "for i in range(1000):\n", + " rmse_b2_m.append(np.sqrt((np.sum((b2 - np.hsplit(mgwr_params[i],3)[2])**2))/625))\n", + " \n", + "rmse_b2_g=[]\n", + "for i in range(1000):\n", + " rmse_b2_g.append(np.sqrt((np.sum((b2 - np.hsplit(gwr_params[i],3)[2])**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2\n", + "rmse_b2=[]\n", + "rmse_b2 = rmse_b2_g+rmse_b2_m\n", + "d = {\"model\":model,\"rmse_b2\":rmse_b2}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['rmse_b2'],x=df['model'])" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.16342922217077274" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b2 - (np.hsplit(mgwr_params_mean,3)[2]))**2))/625)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.07374405903986679" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b2 - (np.hsplit(gwr_params_mean,3)[2]))**2))/625)" + ] + } + ], + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Binomial_MGWR_univariate_check.ipynb b/notebooks/Binomial_MGWR_univariate_check.ipynb index e0d84b0..dd02a8c 100644 --- a/notebooks/Binomial_MGWR_univariate_check.ipynb +++ b/notebooks/Binomial_MGWR_univariate_check.ipynb @@ -232,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -243,7 +243,7 @@ "SinAspct = np.array(data_p['SinAspct']).reshape(-1,1)\n", "CosAspct = np.array(data_p['CosAspct']).reshape(-1,1)\n", "X = np.hstack([elev,slope,SinAspct,CosAspct])\n", - "x = elev\n", + "x = slope\n", "\n", "X_std = (X-X.mean(axis=0))/X.std(axis=0)\n", "x_std = (x-x.mean(axis=0))/x.std(axis=0)\n", @@ -322,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -331,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -340,16 +340,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "235.0" + "198.0" ] }, - "execution_count": 14, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -374,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -509,16 +509,15 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "here\n", "iters = 1\n", - "opt_bws = [235.]\n" + "opt_bws = [198.]\n" ] } ], diff --git a/notebooks/Poisson_MGWR_MonteCarlo_Results.ipynb b/notebooks/Poisson_MGWR_MonteCarlo_Results.ipynb index c9fcc6e..74bfc44 100644 --- a/notebooks/Poisson_MGWR_MonteCarlo_Results.ipynb +++ b/notebooks/Poisson_MGWR_MonteCarlo_Results.ipynb @@ -32,12 +32,21 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\msachde1\\AppData\\Local\\Continuum\\anaconda3\\envs\\gwrenv\\lib\\site-packages\\libpysal\\io\\iohandlers\\__init__.py:25: UserWarning: SQLAlchemy and Geomet not installed, database I/O disabled\n", + " warnings.warn('SQLAlchemy and Geomet not installed, database I/O disabled')\n" + ] + } + ], "source": [ "import warnings\n", - "warnin`gs.filterwarnings(\"ignore\")\n", + "warnings.filterwarnings(\"ignore\")\n", "import pickle\n", "import sys\n", "import seaborn as sns\n", @@ -58,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -70,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -92,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -121,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -135,6 +144,74 @@ "B2=med(X,Y)" ] }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 1.04166667, 2.08333333, 3.125 , 4.16666667,\n", + " 5.20833333, 6.25 , 7.29166667, 8.33333333, 9.375 ,\n", + " 10.41666667, 11.45833333, 12.5 , 13.54166667, 14.58333333,\n", + " 15.625 , 16.66666667, 17.70833333, 18.75 , 19.79166667,\n", + " 20.83333333, 21.875 , 22.91666667, 23.95833333, 25. ])" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 1.04166667, 2.08333333, 3.125 , 4.16666667,\n", + " 5.20833333, 6.25 , 7.29166667, 8.33333333, 9.375 ,\n", + " 10.41666667, 11.45833333, 12.5 , 13.54166667, 14.58333333,\n", + " 15.625 , 16.66666667, 17.70833333, 18.75 , 19.79166667,\n", + " 20.83333333, 21.875 , 22.91666667, 23.95833333, 25. ])" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -144,16 +221,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, @@ -176,7 +253,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -185,7 +262,7 @@ "170.074" ] }, - "execution_count": 24, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -203,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -212,7 +289,7 @@ "([], )" ] }, - "execution_count": 25, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -239,16 +316,16 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 26, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, @@ -271,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -280,7 +357,7 @@ "546.083" ] }, - "execution_count": 27, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -291,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -300,7 +377,7 @@ "([], )" ] }, - "execution_count": 28, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, @@ -327,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -336,7 +413,7 @@ "91.753" ] }, - "execution_count": 29, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -347,16 +424,16 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 30, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -379,7 +456,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -388,7 +465,7 @@ "([], )" ] }, - "execution_count": 31, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, @@ -415,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -424,7 +501,7 @@ "209.398" ] }, - "execution_count": 32, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -435,16 +512,16 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 33, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -467,7 +544,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -476,7 +553,7 @@ "(546.083, 91.753, 209.398)" ] }, - "execution_count": 34, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -494,7 +571,7 @@ }, { "cell_type": "code", - "execution_count": 160, + "execution_count": 145, "metadata": {}, "outputs": [], "source": [ @@ -505,12 +582,14 @@ "mgwr_aic=[]\n", "gwr_aic=[]\n", "mgwr_params=[]\n", - "gwr_params=[]" + "gwr_params=[]\n", + "mgwr_predy=[]\n", + "gwr_predy=[]" ] }, { "cell_type": "code", - "execution_count": 161, + "execution_count": 146, "metadata": {}, "outputs": [], "source": [ @@ -527,12 +606,105 @@ " gwr_aic.append(p1[j].gwr_aic[0])\n", " \n", " mgwr_params.append(p1[j].mgwr_params[0])\n", - " gwr_params.append(p1[j].gwr_params[0])" + " gwr_params.append(p1[j].gwr_params[0])\n", + " \n", + " mgwr_predy.append(p1[j].mgwr_predy[0])\n", + " gwr_predy.append(p1[j].gwr_predy[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(np.mean(gwr_predy,axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(np.mean(mgwr_predy,axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(y)" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -560,7 +732,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -588,7 +760,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -616,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -625,7 +797,7 @@ "(640.2736332530651, 696.9264487767485)" ] }, - "execution_count": 49, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -636,7 +808,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -645,7 +817,7 @@ "(640.2353688823071, 693.79977380067)" ] }, - "execution_count": 50, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -656,7 +828,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -665,7 +837,7 @@ "(653.4726886933404, 823.1916659552306)" ] }, - "execution_count": 51, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -683,7 +855,7 @@ }, { "cell_type": "code", - "execution_count": 149, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -695,7 +867,7 @@ }, { "cell_type": "code", - "execution_count": 163, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -706,7 +878,7 @@ }, { "cell_type": "code", - "execution_count": 168, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -717,7 +889,7 @@ }, { "cell_type": "code", - "execution_count": 169, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -728,7 +900,7 @@ }, { "cell_type": "code", - "execution_count": 170, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -737,7 +909,7 @@ }, { "cell_type": "code", - "execution_count": 172, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -746,7 +918,7 @@ }, { "cell_type": "code", - "execution_count": 174, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -767,7 +939,7 @@ }, { "cell_type": "code", - "execution_count": 175, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -788,7 +960,7 @@ }, { "cell_type": "code", - "execution_count": 176, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -816,7 +988,7 @@ }, { "cell_type": "code", - "execution_count": 182, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -826,7 +998,33 @@ }, { "cell_type": "code", - "execution_count": 207, + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.29918256, 1.08091908, 0.24303902],\n", + " [0.29986681, 1.08191172, 0.25072761],\n", + " [0.30086733, 1.08323714, 0.26047537],\n", + " ...,\n", + " [0.30379225, 1.08046329, 0.66564584],\n", + " [0.30356667, 1.07606719, 0.67132769],\n", + " [0.30334916, 1.07243615, 0.67578556]])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_params_mean" + ] + }, + { + "cell_type": "code", + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -837,7 +1035,7 @@ }, { "cell_type": "code", - "execution_count": 208, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -848,7 +1046,7 @@ }, { "cell_type": "code", - "execution_count": 211, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -859,7 +1057,18 @@ }, { "cell_type": "code", - "execution_count": 315, + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "B0_gwr=B0_gwr.reshape(25,25)\n", + "B1_gwr=B1_gwr.reshape(25,25)\n", + "B2_gwr=B2_gwr.reshape(25,25)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -902,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": 314, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -945,7 +1154,7 @@ }, { "cell_type": "code", - "execution_count": 316, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -985,6 +1194,317 @@ "\n", "plt.tight_layout()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing parameters (MGWR and GWR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$RMSE_j$ = $\\sqrt{1/n \\sum{(\\beta_j (u_i, v_i) - \\hat{\\beta}(u_i, v_i))^2}}$" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "B0_g=np.hsplit(gwr_params_mean,3)[0]\n", + "B1_g=np.hsplit(gwr_params_mean,3)[1]\n", + "B2_g=np.hsplit(gwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "B0_m=np.hsplit(mgwr_params_mean,3)[0]\n", + "B1_m=np.hsplit(mgwr_params_mean,3)[1]\n", + "B2_m=np.hsplit(mgwr_params_mean,3)[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "b0 = B0.reshape(-1,1)\n", + "b1 = B1.reshape(-1,1)\n", + "b2 = B2.reshape(-1,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_0$" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b0_m=[]\n", + "for i in range(1000):\n", + " rmse_b0_m.append(np.sqrt((np.sum((b0 - (np.hsplit(mgwr_params[i],3)[0]))**2))/625))\n", + " \n", + "rmse_b0_g=[]\n", + "for i in range(1000):\n", + " rmse_b0_g.append(np.sqrt((np.sum((b0 - (np.hsplit(gwr_params[i],3)[0]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2\n", + "\n", + "rmse_b0 = rmse_b0_g+rmse_b0_m\n", + "d = {\"model\":model,\"rmse_b0\":rmse_b0}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['rmse_b0'],x=df['model'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_1$" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b1_m=[]\n", + "for i in range(1000):\n", + " rmse_b1_m.append(np.sqrt((np.sum((b1 - (np.hsplit(mgwr_params[i],3)[1]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b1_g=[]\n", + "for i in range(1000):\n", + " rmse_b1_g.append(np.sqrt((np.sum((b1 - (np.hsplit(gwr_params[i],3)[1]))**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2\n", + "rmse_b1=[]\n", + "rmse_b1 = rmse_b1_g+rmse_b1_m\n", + "d = {\"model\":model,\"rmse_b1\":rmse_b1}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(x=df['model'],y=df['rmse_b1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.026800799078238548" + ] + }, + "execution_count": 166, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b1 - (np.hsplit(mgwr_params_mean,3)[1]))**2))/625)" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06548680846620793" + ] + }, + "execution_count": 167, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b1 - (np.hsplit(gwr_params_mean,3)[1]))**2))/625)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $B_2$" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [], + "source": [ + "rmse_b2_m=[]\n", + "for i in range(1000):\n", + " rmse_b2_m.append(np.sqrt((np.sum((b2 - np.hsplit(mgwr_params[i],3)[2])**2))/625))\n", + " \n", + "rmse_b2_g=[]\n", + "for i in range(1000):\n", + " rmse_b2_g.append(np.sqrt((np.sum((b2 - np.hsplit(gwr_params[i],3)[2])**2))/625))" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2\n", + "rmse_b2=[]\n", + "rmse_b2 = rmse_b2_g+rmse_b2_m\n", + "d = {\"model\":model,\"rmse_b2\":rmse_b2}\n", + "df = pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style=\"whitegrid\")\n", + "ax = sns.boxplot(y=df['rmse_b2'],x=df['model'])" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0524967462543234" + ] + }, + "execution_count": 172, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b2 - (np.hsplit(mgwr_params_mean,3)[2]))**2))/625)" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06392889088066671" + ] + }, + "execution_count": 173, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt((np.sum((b2 - (np.hsplit(gwr_params_mean,3)[2]))**2))/625)" + ] } ], "metadata": { diff --git a/notebooks/Real_data_example_Binomial-MGWR.ipynb b/notebooks/Real_data_example_Binomial-MGWR.ipynb index 131204b..131cab3 100644 --- a/notebooks/Real_data_example_Binomial-MGWR.ipynb +++ b/notebooks/Real_data_example_Binomial-MGWR.ipynb @@ -220,7 +220,7 @@ "SinAspct = np.array(data_p['SinAspct']).reshape(-1,1)\n", "CosAspct = np.array(data_p['CosAspct']).reshape(-1,1)\n", "X = np.hstack([elev,slope,SinAspct,CosAspct])\n", - "x = SinAspct\n", + "x = CosAspct\n", "\n", "X_std = (X-X.mean(axis=0))/X.std(axis=0)\n", "x_std = (x-x.mean(axis=0))/x.std(axis=0)\n", @@ -235,7 +235,7 @@ { "data": { "text/plain": [ - "100.0" + "108.0" ] }, "execution_count": 6, @@ -265,42 +265,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "(239, 1)\n", - "Current iteration: 1 ,SOC: 0.0018522\n", - "Bandwidths: 50.0\n", - "(239, 1)\n", - "Current iteration: 2 ,SOC: 0.0090539\n", - "Bandwidths: 43.0\n", - "(239, 1)\n", - "Current iteration: 3 ,SOC: 0.0164077\n", - "Bandwidths: 43.0\n", - "(239, 1)\n", - "Current iteration: 4 ,SOC: 0.0277893\n", - "Bandwidths: 53.0\n", - "(239, 1)\n" + "Current iteration: 1 ,SOC: 0.0752521\n", + "Bandwidths: 108.0\n", + "Current iteration: 2 ,SOC: 0.0213201\n", + "Bandwidths: 184.0\n", + "Current iteration: 3 ,SOC: 5.8e-05\n", + "Bandwidths: 184.0\n", + "Current iteration: 4 ,SOC: 1e-06\n", + "Bandwidths: 184.0\n" ] }, { - "ename": "Exception", - "evalue": "one or more input arrays have missing/NaN values", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mException\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mselector\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSel_BW\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mx_std\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mfamily\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mBinomial\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmulti\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mconstant\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mselector\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msearch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mverbose\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\sel_bw.py\u001b[0m in \u001b[0;36msearch\u001b[1;34m(self, search_method, criterion, bw_min, bw_max, interval, tol, max_iter, init_multi, tol_multi, rss_score, max_iter_multi, multi_bw_min, multi_bw_max, bws_same_times, pool, verbose)\u001b[0m\n\u001b[0;32m 308\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 309\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmulti\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 310\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mbw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 311\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mparams\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbw\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;31m#params n by k\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 312\u001b[0m self.bw_init = self.bw[\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\sel_bw.py\u001b[0m in \u001b[0;36m_mbw\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 417\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmax_iter_multi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrss_score\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgwr_func\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mgwr_func_g\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 418\u001b[0m \u001b[0mbw_func\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mbw_func_g\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msel_func\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmulti_bw_min\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmulti_bw_max\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 419\u001b[1;33m bws_same_times, verbose=self.verbose)\n\u001b[0m\u001b[0;32m 420\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 421\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m_init_section\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_glob\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_loc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcoords\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconstant\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\search.py\u001b[0m in \u001b[0;36mmulti_bw\u001b[1;34m(init, y, X, n, k, family, offset, tol, max_iter, rss_score, gwr_func, gwr_func_g, bw_func, bw_func_g, sel_func, multi_bw_min, multi_bw_max, bws_same_times, verbose)\u001b[0m\n\u001b[0;32m 245\u001b[0m \u001b[0mbw\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbws\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 246\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 247\u001b[1;33m \u001b[0mbw\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msel_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbw_class\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmulti_bw_min\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmulti_bw_max\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 248\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mbw\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mbws\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 249\u001b[0m \u001b[0mbw_stable_counter\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\sel_bw.py\u001b[0m in \u001b[0;36msel_func\u001b[1;34m(bw_func, bw_min, bw_max)\u001b[0m\n\u001b[0;32m 412\u001b[0m \u001b[0msearch_method\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msearch_method\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcriterion\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 413\u001b[0m \u001b[0mbw_min\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mbw_min\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbw_max\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mbw_max\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minterval\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minterval\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtol\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtol\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 414\u001b[1;33m max_iter=max_iter, pool=self.pool, verbose=False)\n\u001b[0m\u001b[0;32m 415\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 416\u001b[0m self.bw = multi_bw(self.init_multi, y, X, n, k, family, offset, self.tol_multi,\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\sel_bw.py\u001b[0m in \u001b[0;36msearch\u001b[1;34m(self, search_method, criterion, bw_min, bw_max, interval, tol, max_iter, init_multi, tol_multi, rss_score, max_iter_multi, multi_bw_min, multi_bw_max, bws_same_times, pool, verbose)\u001b[0m\n\u001b[0;32m 313\u001b[0m -1] #scalar, optimal bw from initial gwr model\n\u001b[0;32m 314\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 315\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_bw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 316\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 317\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpool\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\sel_bw.py\u001b[0m in \u001b[0;36m_bw\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 332\u001b[0m self.bw = golden_section(a, c, delta, gwr_func, self.tol,\n\u001b[0;32m 333\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mint_score\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 334\u001b[1;33m self.verbose)\n\u001b[0m\u001b[0;32m 335\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msearch_method\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'interval'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 336\u001b[0m self.bw = equal_interval(self.bw_min, self.bw_max, self.interval,\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\search.py\u001b[0m in \u001b[0;36mgolden_section\u001b[1;34m(a, c, delta, function, tol, max_iter, int_score, verbose)\u001b[0m\n\u001b[0;32m 59\u001b[0m \u001b[0mscore_b\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 60\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 61\u001b[1;33m \u001b[0mscore_b\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfunction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 62\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mscore_b\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 63\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mverbose\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\sel_bw.py\u001b[0m in \u001b[0;36m\u001b[1;34m(bw)\u001b[0m\n\u001b[0;32m 322\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mX_loc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbw\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfamily\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfamily\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkernel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 323\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkernel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfixed\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfixed\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconstant\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconstant\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moffset\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 324\u001b[1;33m offset, spherical=self.spherical).fit(lite=True, pool=self.pool))\n\u001b[0m\u001b[0;32m 325\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 326\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_optimized_function\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgwr_func\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mC:/Users/msachde1/Downloads/Research/Development/mgwr\\mgwr\\gwr.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, coords, y, X, bw, family, offset, sigma2_v1, kernel, fixed, constant, spherical, hat_matrix)\u001b[0m\n\u001b[0;32m 211\u001b[0m \u001b[0mInitialize\u001b[0m \u001b[1;32mclass\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 212\u001b[0m \"\"\"\n\u001b[1;32m--> 213\u001b[1;33m \u001b[0mGLM\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfamily\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconstant\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mconstant\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 214\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconstant\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mconstant\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 215\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msigma2_v1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msigma2_v1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\AppData\\Local\\Continuum\\anaconda3\\envs\\gwrenv\\lib\\site-packages\\spglm\\glm.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, y, X, family, offset, y_fix, constant)\u001b[0m\n\u001b[0;32m 86\u001b[0m \u001b[0mInitialize\u001b[0m \u001b[1;32mclass\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 87\u001b[0m \"\"\"\n\u001b[1;32m---> 88\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mUSER\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcheck_arrays\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 89\u001b[0m \u001b[0mUSER\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcheck_y\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 90\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\AppData\\Local\\Continuum\\anaconda3\\envs\\gwrenv\\lib\\site-packages\\spreg\\user_output.py\u001b[0m in \u001b[0;36mcheck_arrays\u001b[1;34m(*arrays)\u001b[0m\n\u001b[0;32m 356\u001b[0m \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"one or more input arrays have more columns than rows\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 357\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mspu\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mspisfinite\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 358\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"one or more input arrays have missing/NaN values\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 359\u001b[0m \u001b[0mrows\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 360\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrows\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mException\u001b[0m: one or more input arrays have missing/NaN values" - ] + "data": { + "text/plain": [ + "array([184.])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -316,7 +299,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2407b03df92b40298374f9a8d56027b2", + "model_id": "39f8c9c179984bccb8ddf09964983951", "version_major": 2, "version_minor": 0 }, @@ -339,32 +322,15 @@ "mgwr_mod = MGWR(coords, y,x_std,selector,family=Binomial(),constant=False).fit()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Testing with random bw initialization" - ] - }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Current iteration: 1 ,SOC: 0.0070803\n", - "Bandwidths: 100.0\n", - "Current iteration: 2 ,SOC: 0.0\n", - "Bandwidths: 100.0\n" - ] - }, { "data": { "text/plain": [ - "array([100.])" + "325.23949237389036" ] }, "execution_count": 9, @@ -373,14 +339,7 @@ } ], "source": [ - "selector.search(verbose=True,init_multi=200)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Parameter check" + "mgwr_mod.bic" ] }, { @@ -391,7 +350,7 @@ { "data": { "text/plain": [ - "(319.4645202072096, 330.2296364641693)" + "338.19722049287054" ] }, "execution_count": 10, @@ -400,7 +359,7 @@ } ], "source": [ - "mgwr_mod.aic, gwr_mod.aic" + "gwr_mod.bic" ] }, { @@ -411,7 +370,245 @@ { "data": { "text/plain": [ - "239" + "array([[-6.86421110e-02],\n", + " [-9.02377310e-03],\n", + " [-6.25927989e-02],\n", + " [-3.46325349e-02],\n", + " [-2.46608964e-02],\n", + " [-7.92934492e-02],\n", + " [-7.42296482e-03],\n", + " [-1.16179902e-02],\n", + " [-8.55163917e-03],\n", + " [ 6.69586863e-03],\n", + " [-1.34781343e-02],\n", + " [-4.69002263e-02],\n", + " [-4.27190305e-02],\n", + " [-1.96234952e-03],\n", + " [-3.45017324e-02],\n", + " [ 4.78018268e-03],\n", + " [ 2.35625148e-02],\n", + " [ 4.59257586e-03],\n", + " [ 2.67844779e-02],\n", + " [ 4.75083942e-03],\n", + " [-5.13130035e-02],\n", + " [-7.92681519e-02],\n", + " [ 7.52785701e-02],\n", + " [ 7.45723922e-02],\n", + " [-5.19817611e-02],\n", + " [-6.22604390e-02],\n", + " [-1.73378137e-02],\n", + " [-4.88622106e-02],\n", + " [ 9.15948348e-03],\n", + " [ 1.84910322e-02],\n", + " [ 3.15425672e-03],\n", + " [-6.48930429e-03],\n", + " [-1.93762371e-03],\n", + " [-4.34061793e-02],\n", + " [-5.28568280e-02],\n", + " [ 1.74571605e-02],\n", + " [-4.73594024e-03],\n", + " [-2.25230562e-03],\n", + " [-1.10529379e-02],\n", + " [-2.61542043e-02],\n", + " [-5.47613290e-02],\n", + " [-8.56136675e-02],\n", + " [ 6.11606014e-02],\n", + " [-7.96316019e-02],\n", + " [ 1.06137092e-01],\n", + " [-8.45634873e-02],\n", + " [-5.16056559e-02],\n", + " [-9.39907188e-02],\n", + " [ 5.08910015e-02],\n", + " [-1.11319637e-01],\n", + " [-2.80789755e-02],\n", + " [ 8.55069680e-02],\n", + " [-4.68078891e-02],\n", + " [-3.33390431e-03],\n", + " [-2.16235723e-02],\n", + " [ 2.49215314e-02],\n", + " [ 5.63334013e-03],\n", + " [ 4.03752737e-02],\n", + " [-1.43170358e-01],\n", + " [-1.59890083e-01],\n", + " [-7.42351180e-02],\n", + " [ 6.04559033e-02],\n", + " [ 3.33959925e-02],\n", + " [-8.40832151e-03],\n", + " [-2.65428632e-02],\n", + " [-8.67898410e-02],\n", + " [-8.66556038e-02],\n", + " [-6.84698662e-02],\n", + " [-5.61187590e-02],\n", + " [-5.67881208e-02],\n", + " [-6.63001614e-04],\n", + " [-1.06074298e-03],\n", + " [ 3.15268253e-02],\n", + " [-4.13201319e-02],\n", + " [-6.20969024e-02],\n", + " [-6.25418387e-02],\n", + " [-6.43731665e-02],\n", + " [ 5.05707341e-02],\n", + " [-1.81040565e-02],\n", + " [ 3.13435449e-02],\n", + " [-1.35797422e-02],\n", + " [-6.46775147e-02],\n", + " [-1.53156899e-01],\n", + " [ 8.11104441e-03],\n", + " [ 6.41924414e-03],\n", + " [ 6.74537680e-03],\n", + " [-2.59694029e-02],\n", + " [-6.08872689e-02],\n", + " [-5.76580369e-02],\n", + " [ 2.09339187e-02],\n", + " [-1.84105049e-03],\n", + " [ 3.22956968e-03],\n", + " [ 7.27477155e-02],\n", + " [-2.81118267e-02],\n", + " [-3.45626639e-02],\n", + " [-3.58294089e-02],\n", + " [-6.09426122e-02],\n", + " [ 5.17859563e-02],\n", + " [-7.14232795e-02],\n", + " [ 5.29332087e-02],\n", + " [-7.58861089e-03],\n", + " [-5.86114846e-03],\n", + " [-6.87044228e-02],\n", + " [ 1.28916049e-02],\n", + " [-6.67529531e-02],\n", + " [-6.69324628e-03],\n", + " [ 9.56438588e-03],\n", + " [-3.75737563e-03],\n", + " [-2.64118699e-03],\n", + " [ 1.35663378e-01],\n", + " [ 1.97104440e-02],\n", + " [-1.59758799e-01],\n", + " [-4.44888861e-02],\n", + " [ 4.20888604e-03],\n", + " [-3.99928268e-02],\n", + " [-4.68677717e-02],\n", + " [-1.84088221e-01],\n", + " [-1.08771012e-01],\n", + " [-1.03004376e-01],\n", + " [-7.20510889e-02],\n", + " [-6.90533144e-02],\n", + " [-7.37314396e-02],\n", + " [ 7.50691754e-02],\n", + " [ 3.53817571e-02],\n", + " [ 4.30473649e-02],\n", + " [ 1.94594454e-02],\n", + " [ 6.96279182e-02],\n", + " [-1.47661459e-02],\n", + " [-2.55449197e-02],\n", + " [-2.75477053e-02],\n", + " [-3.53445515e-02],\n", + " [ 4.28998056e-03],\n", + " [-2.97887303e-03],\n", + " [ 3.34820966e-02],\n", + " [ 1.53836989e-02],\n", + " [ 2.98504386e-02],\n", + " [-5.44861948e-02],\n", + " [-9.85317074e-02],\n", + " [ 1.90976659e-01],\n", + " [ 2.64677520e-02],\n", + " [ 1.40322828e-01],\n", + " [ 2.50343699e-01],\n", + " [-9.26960534e-03],\n", + " [ 3.09008565e-02],\n", + " [ 5.59670178e-02],\n", + " [ 1.02006130e-01],\n", + " [-2.35602286e-02],\n", + " [ 1.14163733e-01],\n", + " [ 3.47931823e-02],\n", + " [-1.11183101e-03],\n", + " [ 1.39762958e-01],\n", + " [-8.04828275e-02],\n", + " [-3.39115588e-02],\n", + " [-1.71467752e-02],\n", + " [ 5.72292660e-04],\n", + " [-2.16044180e-04],\n", + " [ 1.28949115e-01],\n", + " [ 1.26023648e-01],\n", + " [ 8.84030834e-02],\n", + " [ 2.99680764e-02],\n", + " [ 5.56646040e-02],\n", + " [-5.12025553e-02],\n", + " [ 9.47313130e-03],\n", + " [-5.36473598e-02],\n", + " [-7.29087711e-02],\n", + " [-6.92127110e-02],\n", + " [-8.95235041e-03],\n", + " [-1.21073353e-02],\n", + " [ 1.04199536e-01],\n", + " [-3.44823874e-02],\n", + " [-5.67763767e-02],\n", + " [ 1.13578616e-01],\n", + " [ 4.52178521e-02],\n", + " [ 1.24571646e-01],\n", + " [ 8.28563723e-02],\n", + " [ 2.42844475e-03],\n", + " [-7.96453685e-02],\n", + " [ 2.40809343e-02],\n", + " [-1.55982333e-02],\n", + " [ 7.46162805e-02],\n", + " [ 1.01380277e-01],\n", + " [ 1.20509132e-01],\n", + " [ 1.35523796e-01],\n", + " [-3.22828125e-02],\n", + " [-1.37241610e-02],\n", + " [-5.97213805e-02],\n", + " [ 1.10999448e-01],\n", + " [-3.62631169e-02],\n", + " [ 1.84431180e-02],\n", + " [ 1.01931343e-01],\n", + " [-6.84139926e-02],\n", + " [-3.45131451e-02],\n", + " [-9.75344201e-03],\n", + " [ 4.80032525e-02],\n", + " [ 2.34601191e-02],\n", + " [ 3.89468591e-02],\n", + " [ 1.65250383e-01],\n", + " [-2.02724746e-02],\n", + " [ 1.47208967e-01],\n", + " [ 5.84571936e-02],\n", + " [ 2.42283823e-02],\n", + " [ 2.42638484e-02],\n", + " [-6.78773201e-03],\n", + " [-1.20966266e-01],\n", + " [-1.62437523e-02],\n", + " [ 8.47043108e-02],\n", + " [-9.80263831e-02],\n", + " [-7.21865204e-02],\n", + " [-6.04470168e-02],\n", + " [-4.94343083e-03],\n", + " [-7.30471221e-03],\n", + " [ 1.01563662e-01],\n", + " [-3.45435004e-02],\n", + " [ 7.28656005e-02],\n", + " [-2.87797340e-02],\n", + " [ 1.16621688e-01],\n", + " [ 3.04019792e-02],\n", + " [-7.93027975e-02],\n", + " [ 3.86078732e-03],\n", + " [-5.30570863e-02],\n", + " [-5.48487906e-02],\n", + " [ 1.70763200e-01],\n", + " [-4.14052105e-02],\n", + " [ 1.31774383e-02],\n", + " [-3.06852068e-02],\n", + " [-8.35451055e-02],\n", + " [ 2.58827225e-02],\n", + " [-3.86634974e-02],\n", + " [ 4.27430398e-02],\n", + " [-2.89324464e-02],\n", + " [ 1.76638263e-01],\n", + " [ 1.03211895e-01],\n", + " [ 6.55672059e-02],\n", + " [-8.81854679e-02],\n", + " [ 8.49001037e-02],\n", + " [-8.95180777e-02],\n", + " [ 1.21071638e-01],\n", + " [ 1.27907248e-02],\n", + " [-3.23289914e-03]])" ] }, "execution_count": 11, @@ -420,7 +617,7 @@ } ], "source": [ - "np.sum(mgwr_mod.predy==gwr_mod.predy)" + "mgwr_mod.predy-gwr_mod.predy" ] }, { @@ -452,6 +649,13 @@ "bw" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Checking parameters" + ] + }, { "cell_type": "code", "execution_count": 13, @@ -461,20 +665,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "Current iteration: 1 ,SOC: 0.0031609\n", - "Bandwidths: 236.0, 235.0, 236.0, 238.0, 228.0\n", - "Current iteration: 2 ,SOC: 0.0004815\n", - "Bandwidths: 238.0, 235.0, 192.0, 238.0, 228.0\n", - "Current iteration: 3 ,SOC: 4.11e-05\n", - "Bandwidths: 238.0, 235.0, 192.0, 238.0, 228.0\n", - "Current iteration: 4 ,SOC: 3.4e-06\n", - "Bandwidths: 238.0, 235.0, 192.0, 238.0, 228.0\n" + "Current iteration: 1 ,SOC: 0.116124\n", + "Bandwidths: 43.0, 62.0, 191.0, 100.0, 108.0\n", + "Current iteration: 2 ,SOC: 0.0266811\n", + "Bandwidths: 43.0, 106.0, 210.0, 100.0, 184.0\n", + "Current iteration: 3 ,SOC: 0.0008147\n", + "Bandwidths: 43.0, 106.0, 210.0, 100.0, 184.0\n", + "Current iteration: 4 ,SOC: 5.28e-05\n", + "Bandwidths: 43.0, 106.0, 210.0, 100.0, 184.0\n", + "Current iteration: 5 ,SOC: 5.3e-06\n", + "Bandwidths: 43.0, 106.0, 210.0, 100.0, 184.0\n" ] }, { "data": { "text/plain": [ - "array([238., 235., 192., 238., 228.])" + "array([ 43., 106., 210., 100., 184.])" ] }, "execution_count": 13, @@ -495,7 +701,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4dcf5eae937048a384f48b1f8d8a479d", + "model_id": "82a7cf0857dc4a2184dbdcc383d0e6b2", "version_major": 2, "version_minor": 0 }, @@ -526,7 +732,7 @@ { "data": { "text/plain": [ - "(259.72499337648424, 261.98167514815555)" + "(264.9819711678866, 251.85376815296377)" ] }, "execution_count": 15, @@ -535,36 +741,7 @@ } ], "source": [ - "gwr_mod.aic, mgwr_mod.aic" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0.07645926],\n", - " [ 0.10775708],\n", - " [-0.01199206],\n", - " [ 0.04968317],\n", - " [ 0.05187675],\n", - " [ 0.04308866],\n", - " [ 0.05400206],\n", - " [ 0.03465849],\n", - " [ 0.05664243],\n", - " [ 0.12148732]])" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(gwr_mod.predy-mgwr_mod.predy)[:10]" + "gwr_mod.aicc, mgwr_mod.aicc" ] }, { @@ -576,20 +753,24 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Current iteration: 1 ,SOC: 0.0033277\n", + "Current iteration: 1 ,SOC: 0.6120513\n", + "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", + "Current iteration: 2 ,SOC: 0.0594775\n", + "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", + "Current iteration: 3 ,SOC: 0.0025897\n", "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", - "Current iteration: 2 ,SOC: 0.0003028\n", + "Current iteration: 4 ,SOC: 0.0001289\n", "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", - "Current iteration: 3 ,SOC: 1.82e-05\n", + "Current iteration: 5 ,SOC: 1.17e-05\n", "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", - "Current iteration: 4 ,SOC: 3.5e-06\n", + "Current iteration: 6 ,SOC: 1.2e-06\n", "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n" ] }, @@ -599,7 +780,7 @@ "array([239., 239., 239., 239., 239.])" ] }, - "execution_count": 17, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -611,13 +792,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a8757fddba524d6fa9cc0d17e8046593", + "model_id": "ef529125b27a490ba4999ccdefdcfac7", "version_major": 2, "version_minor": 0 }, @@ -642,7 +823,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -710,16 +891,16 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 0.39941768, -0.66123063, 0.59038645, 0.06518615, -0.32231525])" + "array([ 0.19936242, -0.3251776 , 0.32069312, 0.04295657, -0.20408904])" ] }, - "execution_count": 21, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -728,6 +909,26 @@ "np.mean(mgwr_mod.params,axis=0)" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(303.9521120546862, 340.5982180538755)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mgwr_mod.bic, gwr_mod.bic" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/notebooks/Simulated_data_example_Binomial-MGWR.ipynb b/notebooks/Simulated_data_example_Binomial-MGWR.ipynb index 8557141..6651bef 100644 --- a/notebooks/Simulated_data_example_Binomial-MGWR.ipynb +++ b/notebooks/Simulated_data_example_Binomial-MGWR.ipynb @@ -53,7 +53,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "##### Forming variables" + "### Global Example" ] }, { @@ -61,20 +61,233 @@ "execution_count": 3, "metadata": {}, "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)\n", + "X, Y = np.meshgrid(x, y)\n", + "\n", + "lon = X.reshape(-1,1)\n", + "lat = Y.reshape(-1,1)\n", + "\n", + "coords = np.array(list(zip(lon,lat)))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "x1=np.random.normal(0,1,625)\n", + "x2=np.random.normal(0,1,625)\n", + "error = np.random.normal(0,0.1,625)\n", + "\n", + "z = 1+2*x1+3*x2+error\n", + "\n", + "x1=x1.reshape(-1,1)\n", + "x2=x2.reshape(-1,1)\n", + "\n", + "pr = 1/(1+np.exp(-z))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "y = np.random.binomial(1,pr)\n", + "X = np.hstack([x1,x2])\n", + "y = np.array(y).reshape((-1,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "bw = Sel_BW(coords,y,X,family=Binomial())\n", + "bw=bw.search()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "gwr_mod = GWR(coords, y, X, bw,family=Binomial()).fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MGWR" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0450537\n", + "Bandwidths: 519.0, 624.0, 183.0\n", + "Current iteration: 2 ,SOC: 0.020152\n", + "Bandwidths: 519.0, 624.0, 624.0\n", + "Current iteration: 3 ,SOC: 0.0032721\n", + "Bandwidths: 519.0, 624.0, 624.0\n", + "Current iteration: 4 ,SOC: 8.01e-05\n", + "Bandwidths: 519.0, 624.0, 624.0\n", + "Current iteration: 5 ,SOC: 9.37e-05\n", + "Bandwidths: 519.0, 624.0, 624.0\n", + "Current iteration: 6 ,SOC: 3.74e-05\n", + "Bandwidths: 519.0, 624.0, 624.0\n", + "Current iteration: 7 ,SOC: 1.87e-05\n", + "Bandwidths: 519.0, 624.0, 624.0\n", + "Current iteration: 8 ,SOC: 9e-06\n", + "Bandwidths: 519.0, 624.0, 624.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([519., 624., 624.])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector = Sel_BW(coords,y,X,multi=True,family=Binomial())\n", + "selector.search(verbose=True,max_iter_multi=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "be4fed3d865d4d339f973ce0c833afb3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, description='Inference', max=1), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "mgwr_mod = MGWR(coords, y, X, selector,family=Binomial()).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([1.16604381, 2.24362744, 3.27846807]),\n", + " array([0.70461953, 1.78115408, 2.84722997]))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(gwr_mod.params,axis=0), np.mean(mgwr_mod.params,axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(357.9759977731823, 363.5967703986909)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_mod.aic, mgwr_mod.aic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Local surface example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Forming variables" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], "source": [ "def add(a,b):\n", " return 1+((1/12)*(a+b))\n", "\n", "def con(u,v):\n", - " return (0*(u)*(v))+3\n", + " return (0*(u)*(v))+1\n", "\n", "def sp(u,v):\n", - " return 1+1/324*(36-(6-u/2)**2)*(36-(6-v/2)**2)" + " return 1+1/324*(36-(6-u/2)**2)*(36-(6-v/2)**2)\n", + "\n", + "def med(u,v):\n", + " B = np.zeros((25,25))\n", + " for i in range(25):\n", + " for j in range(25):\n", + " \n", + " if u[i][j]<=8:\n", + " B[i][j]=0.2\n", + " elif u[i][j]>17:\n", + " B[i][j]=0.7\n", + " else:\n", + " B[i][j]=0.5\n", + " return B" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -85,28 +298,30 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "x1=np.random.normal(0,0.1,625)\n", - "x2=np.random.normal(0,0.25,625)" + "x1=np.random.normal(0,1,625)\n", + "x2=np.random.normal(0,1,625)\n", + "error = np.random.normal(0,0.1,625)\n", + "#error =error-min(error)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "B0=con(X,Y)\n", - "B1=add(X,Y)\n", - "B2=sp(X,Y)" + "B1=sp(X,Y)\n", + "B2=med(X,Y)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -115,13 +330,13 @@ "([], )" ] }, - "execution_count": 7, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARQAAADuCAYAAAD4DviyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAENpJREFUeJzt3UuI5FlWx/Hf+ccjI/JZ3ZXd09U9/WBAZjMLB3o3GxEXjTYuRUE3Ci5VEATduHYjOgsXhQ4qiiA+NuKDAWmGAR3okUHFZhCFflk91VVdlc+IjNdxkS2U0nXPjcqTE+3t7wcSOvt/8kbmP6IO93//53+uubsAIEO36V8AQDtIKADSkFAApCGhAEhDQgGQhoQCIA0JBUAaEgqANCQUAGn6awVvH/jw4Nnr+l2Az7zZ0V0tzo/sKmO8aGOfalUVe0+zv3P3167yeo9aK6EMD57VF3/2q1mvDeD/+O7XfuHKY1xopZ+wW1Wxv+NvH175BR+xVkIB8OlnknpWOclJfpSPhAI0qHeli6YnR0IBGrPWDCUZCQVojJk07EgoABJczlA289okFKA51s4lz2h7UD6+MwzH2B2Xx5Ck3VH8q+8FMeNhLxyjJmbYL8ds9eP6wV7FFLUmJrJcxcv6NTEXi3Kdw2yxDMeYBWNI0ul0EcacBDE1Y5xO5mHMRUXM9LwcMzm5KB73inMfMW2uYpUZCtCgZmYoADbLjDUUAElM3OUBkIQ6FACpuOQBkOJyDYUZCoAkzcxQojqTF25uh2O8fLgTxtw6GIUxN4OamINRXO+yV1GHsj0oxwx7cVVAv2IRLWOdrabMYVmxm2RUh3I+j+tQTmZxzNE0rv14MCnXmbz/cBKO8d5H52HMOx+ehTFRHcr0bFY8vkqoQ+lkLMoCyNPMDAXAZrGGAiANDwcCSMUMBUAKZigA0phJg24zzxuTUIDmmGxDUxQSCtAak7pWEkrUHKmmaO0HnoljXjoYhzHP7ZWL7GqK1nYG8dRx3C+/ed1iGo6hRbngSZKsouAs4jWLdf24CZb3y4WFk2X8u57O4gZLNcVvd8/KxWR7W/H7XOMoKFqTpKP75QK52flR8biv4r83YpKsopjyOjBDAVpj4pIHQBKzdi55AGyWmdQLni+7LiQUoEFc8gDIYcaiLIAcpoZuGwPYMJOMfigAUpipV1FjdR3yC9uC3fpqOq3VFK29dLAVxjyzXf5dRou4A1d3fD+OuTgpHvez43AMn8a/i8/j4rdIN4iL1mwUFxba9m7xeG90EI6xvf1UGLO/uxfGbCWsF5xcxAVlb9+L36PIYlIew1dxsV/EqEMBkKljURZACuPhQABJTFLHoiyAFMbDgQCymKk3JKEASGDMUABkolIWQI6WKmX3gsK2aHtQKe60JsVFa5I0ntwrHu8d3wnHWH7v3TBmdv+D8hhHcXHc7CTeCnM1K2+5WaMbxudtuBdvF9vt3Sge79+8FY4xeO6lMMYOng9jDseHxeOzZfx5ujOOz0v02a6xmJ4Wj+d0bLPUOhQz60l6U9L77v56KZYZCtCa/ErZX5T0lqT9KHAzKzcAro+ZukG/6iseyj4v6cck/W7NSzNDARpjtlbp/aGZvfnI97fd/fYj3/+WpF+RFD9UJRIK0KC1Gizdc/dXP3EUs9cl3XX3b5vZD9UMRkIBWpNXh/IVST9uZj8qaSRp38z+yN1/+nE/wBoK0ByTdV3VV4m7/6q7f97dX5H0k5L+vpRMJGYoQHPMTN0wLs+4DukJZRx0ijoYxX9ozY5+Nc2RojqTxdvfDceYvfsfYczp++V6l8mHD+LXOY7rUBbTeOe6SL/i/A/34zqU0c1yA6XdF8rnRJKGFU2lhq+EIRr1y8229rfihlFPBzteSvFnW5K6YGfG+SSqQ7l6gyWZ1CVvlu7ub0h6I4pjhgI0iGd5AORgGw0AWUwKF1yvCwkFaA0zFABpTOpVPAR6HUgoQGPMjEseAHm45AGQo6U1lKj4p6ZobWcQn4yaHf2i5kg1RWsP/j1usHTyzt3y8f8qFzNJ0sXxRRizmF69wVJvUFE0+FS8u+Pu546Kx+dnk3CMeN9AqavYxTDapXD7Rvyg7G7FmsM4YV1iOQvOiycUtom7PACSmJm6XiN7GwPYMKtr9XkdSChAc7jLAyAJ+/IAyNPSXR4Am8clD4AcZrJ+vBfRdSChAM0xqZUZyrBfvv+9XVFYNe7HmxR1FydhTLSjX9RpTYqL1iTpwX8+LI9RUdh2ejoLYyZLD2Miw4otKvfvx0Vp87Ord48b7IzDmP7T8e6OW7deLh4fV2x6VfO53K4oyoysFuX32f3q7/Flk2rqUACkMKkjoQDIYCKhAMhhFLYBSGMmcZcHQBZmKAByGIuyANI0lFC2+uWp1rDiGYNuMQ1j/Ow4jFkelZsw1ezoV1NDEsV88DD+ex7M48Y6k+XVm++MK85/xusMduKd+EY34/O/9/CjMMZPy82ebBbvyrjVj/8p9CpqeCJRHYpEHQqAT5WGKmUBbBjP8gBIxQwFQAozWSuLsgA2raG7PAA2zMQlD4AcZiYbsCgLIEVDlzxR8U+/pjgoLP6RfHoWxsxOygVNs+O44KlmR7+oOVJN0dqHF/GugBkNlsa9mqK1il30ggZL2w/iYr558P5I0vw8HmdrUv4s2DJuBtWzuBAvo7DNV8H5z2iwJJ7lAZCFZ3kApDJmKABSWEpCMbORpG9I2tJlrvgzd//10s+QUIDWmORdyj/tC0k/7O6nZjaQ9E0z+xt3/8fH/QAJBWiOXa6jXJFftuD/n0fpBx9/FVeNN3OhBeB6dV3dl3RoZm8+8vXzjw5jZj0z+46ku5K+7u7fKr0sMxSgMS7J69dQ7rn7q48dy30p6QfN7IakvzSzL7n7vz4unhkK0Br7eFG25quSuz+U9Iak10px3/fCtpraIKso7vF5XPy2mpWLxRbTuOBpMb16wVlNB7SaorXpKqfoKXK6uHr3uJrztpwt45hp/D5rEbyPHv89NUsOGYVt3x8mJSzKmtkzkubu/tDMxpJ+RNJvlH6GSx6gQWtc8pTckvQHZtbT5dXMn7r7X5V+gIQCtCghobj7P0v68jo/Q0IBWmM5t42fBAkFaBGl9wCyJK2hrI2EArTGTOpt5p82CQVoTs7DgU+ChAK0iIQCXJOKwrbWsIYCIIdxyQMgE3UoAHJYVoOltZFQgBZxyQMgg5vJueQBkMLTtvdZGwkFaI5rtaGMkp5QlkEToJoeQTXTta5i79ZuWP7z+qOK3eIG8YZJw6DxzrgXX8/W7eh3deNefG7rYsp/U38Uf7R6w/jcdoOKj2g/eB8rFig97vX0/4ZLSthk8okwQwEa5K3MUABslqvuSuA6kFCABm0on5BQgOY4MxQAiVhDAZCCuzwAUnHJAyCFe0OXPFFh27LmD+3HRWs22gljhnvb5eP75eOSNHpqFMbs358Uj9fsHFjzVtTs6BepKVo7rCg4298pF5Nt7W+FYwyC90eK30NJ6sblz8KyFxcwLmfx53KWcP6tC4ock57B2VRLKWYoQIN4lgdAisvCtkYueQBsHnd5AKThkgdACpdrtaHiexIK0BoaLAHIRGEbgBSXpfeNXPJcBMU/0XFJ8n5cTGbbu2FMt3ejeHx08yAcY/dzR2HM/GwexkTGFWPUFcgFr1PRPS4qWpOkvVvl87/3fPz+bD/7VBjTu/F0GGO75ffRB/HnaXG2CGOios0aXVi0mVPYxiUPgBTUoQDI41LCZPaJkFCAxjBDAZDI21mUBbBZ7tI8qfbezF6U9IeSntPlQ8y33f23HxdPQgEak3zJs5D0y+7+T2a2J+nbZvZ1d/+3TwomoQANyrrkcfc7ku58/N8nZvaWpBckkVCAz4Lr2pfHzF6R9GVJ33pcTHpCmS3Kezqez+M9HycV13+9UVyU1r95q3h894V74Rjzs3I3thqDikKx7QfTMGYxjYuvIjVbhNZ0W4sK1/ZeeiYcY/eFwzAmeg8lybf2i8cvVnGx2MlFfG7PZ1ffrzQqbLOMjm2+VhHeoZm9+cj3t9399if8XruS/lzSL7n78eMGY4YCNMbX2yz9nru/Wgows4Euk8kfu/tflGJJKEBjXNI86ZrHLqdMvyfpLXf/zSiehAK0Zr1LnshXJP2MpH8xs+98/P9+zd3/+pOCSShAYzJvG7v7N7XGE4skFKBB9JQFkIJneQCkcfe00vt1XUMdSvm56ZOKe/mns/jZ6+3tuDnP4LmXiseH07NwjPhVpMHOuHh8dPNBOMb85DyMWSbUQfQqdgWs2dEvao5UU2MyfPELYUw/eA8lab5TbsJ0Oo8/T6ezuA4lqrGq0RuWPyuyuAFWDWYoAFI01QISwIa5tNpQl2oSCtCYyxnKZl6bhAI0iDUUACncXbMNNZUloQCNcaWW3q+FhAI0xnOf5VkLCQVoUDMJ5TRoAnQ0jXfIqyl+29/dC2Ps4Pni8eEr4RDqRjthTP/pO8Xjew8/CseYn8cNlpbTWRgT6QbxWz6sKGyLdvSraYxUU7S22H8ujLkYlhssHZ/En7mjiuZV0WdbihdD+1vlwjbrrl7Y5vJ2EgqAzXKPK9avCwkFaAxrKABSkVAApGANBUAad2lBQgGQhRkKgBTuovQeQI6m1lBOguKfB5O4OOjuWVyItNWLC4AOx+WuYaN+vENezQ6FW7deLh7306N4jEncPU6L+LyE+vEuht04Luaz3fJ5iXbzk+JOa1JctCZJ94PP1PfO4oLAe+cVBZcpOzeWd1y0hI5t3DYGkIqEAiDF5dPGrKEAyOANraEA2KyVSxc8ywMgAw2WAOThLg+ALE3VoURNaN5/OAnH2NuKd7erMVsOi8f3t+J6i+0bcSOnca+8Ob3N4l0BbVlRY+IV18VRTBe/5cteXKvig1Hx+MWqfE6kuh39apojRXUm7x7Fn7kPjuMGVzUNliKDnXJdjfVyPvvNJBQAm+UuLViUBZDB2TkQQB6Xs9EXgCzODAVACi55AGRx1d0QvA4kFKA1Li1psAQgh7ezhnI6KRcivfdRXORV4+Qi3l3wzrj85z09jgu4dofxKdoelIuRtvrxGD2LfxeLa8VCHp82LWfxh3FxVi7yOrmo2IlvFsfU7OgXNUeqKVp7+17c4Oo4+GzXGG6XG1NZd/XCtstLnpyEYmZfk/S6pLvu/qUo/urtoQB8uvjllqg1XxV+X9JrtS/NJQ/QoKwZirt/w8xeqY0noQANWiOhHJrZm498f9vdbz/p65JQgMa4+zp3ee65+6tZr01CARpEHQqAFJt8OJC7PECDfOVVXxEz+xNJ/yDpi2b2npn9XCmeGQrQGk+9y/NT68SnJ5SLoPjnnQ/jAqKjil3cagqR9kblP288jIuIxjWFbcE4vS6uSMuKyTCraM4TdQQ7n8UVdLNFHFPTJS3a0a9mjJqitWnFDoSR0U65i2CX8B671lqUTcUMBWhN4gxlXSQUoEG0LwCQho5tAFK4N/S0MYDN45IHQA53rRZXvyP1JEgoQGNcLl9VNL65BiQUoDUu+bKRhDINitKi45J0dD+nq1uky2iBhmtV2QToUyNaDI0K2yyleJEZCoAsTkIBkIiEAiCFc5cHQB7XihkKgBSsoQDIcrkvDwkFQAb3dupQJicXxeM1TWpm50dhzGISN1haTE+Lx+eT8nFJWs4mYUy0AFazQOarDXUV/gTWxZ1Bu37QKCg4Lkm94TiM6W9VxIx2i8cHO/vhGNGOflJcQ1ITM94NzlsvoSsri7IA8rCGAiDJ5RoKLSABZOAuD4BMJBQAOZzCNgBJ3F2rOXd5AKRgDQVAok0lFFun3b6ZfSjp7ev7dYDPvJfd/ZmrDGBmfyvpsDL8nru/dpXX+1+vvan9OwC0J6HOFwAukVAApCGhAEhDQgGQhoQCIA0JBUAaEgqANCQUAGlIKADS/Dc0q6xesJVjzwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -142,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -151,13 +366,13 @@ "([], )" ] }, - "execution_count": 8, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -178,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -189,12 +404,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -217,22 +432,22 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -249,7 +464,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -259,7 +474,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -269,25 +484,25 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ - "param = np.hstack([B1,B2])" + "param = np.hstack([B0,B1,B2])" ] }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(625, 2)" + "(625, 3)" ] }, - "execution_count": 56, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -298,7 +513,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -307,7 +522,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -316,25 +531,25 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ - "X=np.hstack([x1,x2])" + "X=np.hstack([cons,x1,x2])" ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(625, 2)" + "(625, 3)" ] }, - "execution_count": 60, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -345,26 +560,26 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "#binomial y\n", - "y_exp = 1/(1+np.exp(-1*np.sum(X * param, axis=1).reshape(-1, 1)))" + "y_exp=((np.exp(np.sum(X * param, axis=1)+error)/(1+(np.exp(np.sum(X * param, axis=1)+error))))).reshape(-1,1)" ] }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.48826701350366136" + "0.6510162481437103" ] }, - "execution_count": 62, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -375,7 +590,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -384,7 +599,7 @@ "(625, 1)" ] }, - "execution_count": 63, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -395,22 +610,22 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 64, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -427,48 +642,63 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ - "def prob(y,ym):\n", - " n=y.shape[0]\n", - " for i in range(n):\n", - " if y[i]>=0.5:\n", - " ym[i]=1\n", - " else:\n", - " ym[i]=0\n", - " return ym" + "y = np.random.binomial(1,y_exp)" ] }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "ym=np.ones_like(y_exp)\n", - "y_new=prob(y_exp,ym)" + "pd.Series(y_exp.reshape(-1), index=x1).plot(style='.')" ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 67, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -480,53 +710,53 @@ } ], "source": [ - "sns.distplot(y_new)" + "pd.Series(y.reshape(-1), index=x1).plot(style='.')" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "coords = np.array(list(zip(lon,lat)))\n", - "y = np.array(y_new).reshape((-1,1))\n", + "y = np.array(y).reshape((-1,1))\n", "#y_std = (y-y.mean(axis=0))/y.std(axis=0)" ] }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "X=np.hstack([x1,x2])\n", - "X_std = (X-X.mean(axis=0))/X.std(axis=0)" + "#X_std = (X-X.mean(axis=0))/X.std(axis=0)" ] }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ - "bw=Sel_BW(coords,y,X_std,family=Binomial(),constant=False)\n", + "bw=Sel_BW(coords,y,X,family=Binomial())\n", "bw=bw.search()\n", - "gwr_model=GWR(coords,y,X_std,bw,family=Binomial(),constant=False).fit()" + "gwr_model=GWR(coords,y,X,bw,family=Binomial()).fit()" ] }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "103.0" + "172.0" ] }, - "execution_count": 71, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -537,16 +767,16 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "165.71680977089486" + "564.9462195662602" ] }, - "execution_count": 72, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -557,37 +787,51 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ - "selector=Sel_BW(coords,y,X_std,multi=True,family=Binomial(),constant=False)" + "selector=Sel_BW(coords,y,X,multi=True,family=Binomial())" ] }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Current iteration: 1 ,SOC: 0.0575755\n", - "Bandwidths: 624.0, 540.0\n", - "Current iteration: 2 ,SOC: 0.0005415\n", - "Bandwidths: 624.0, 540.0\n", - "Current iteration: 3 ,SOC: 7e-07\n", - "Bandwidths: 624.0, 540.0\n" + "Current iteration: 1 ,SOC: 0.0161926\n", + "Bandwidths: 622.0, 73.0, 170.0\n", + "Current iteration: 2 ,SOC: 0.0316518\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 3 ,SOC: 0.0039268\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 4 ,SOC: 0.0001849\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 5 ,SOC: 0.0001914\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 6 ,SOC: 8.61e-05\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 7 ,SOC: 4.99e-05\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 8 ,SOC: 2.72e-05\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 9 ,SOC: 1.62e-05\n", + "Bandwidths: 622.0, 181.0, 188.0\n", + "Current iteration: 10 ,SOC: 9.5e-06\n", + "Bandwidths: 622.0, 181.0, 188.0\n" ] }, { "data": { "text/plain": [ - "array([624., 540.])" + "array([622., 181., 188.])" ] }, - "execution_count": 74, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -598,13 +842,13 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a52eed3e1c8d4e519d75060e8e4bd5f4", + "model_id": "bdf3dfc6fb294029ab06adbd523e95bb", "version_major": 2, "version_minor": 0 }, @@ -624,27 +868,68 @@ } ], "source": [ - "mgwr_model=MGWR(coords,y,X_std,selector,family=Binomial(),constant=False).fit()" + "mgwr_model=MGWR(coords,y,X,selector,family=Binomial()).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([1.10211344, 2.53539688, 0.28485419]),\n", + " array([0.90342461, 2.26934826, 0.25936595]))" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_model.params,axis=0),np.mean(gwr_model.params,axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0, 2.471045176769571, 0.468)" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(B0),np.mean(B1),np.mean(B2)" ] }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(106.50235052741388, 16.93406345293964)" + "(558.2437551708874, 567.8076915280018)" ] }, - "execution_count": 79, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "mgwr_model.resid_ss,gwr_model.resid_ss" + "mgwr_model.aicc,gwr_model.aicc" ] } ],