diff --git a/mgwr/diagnostics.py b/mgwr/diagnostics.py index 82810de..f2c0d06 100755 --- a/mgwr/diagnostics.py +++ b/mgwr/diagnostics.py @@ -11,34 +11,37 @@ def get_AICc(gwr): """ Get AICc value - + Gaussian: p61, (2.33), Fotheringham, Brunsdon and Charlton (2002) - + GWGLM: AICc=AIC+2k(k+1)/(n-k-1), Nakaya et al. (2005): p2704, (36) """ n = gwr.n k = gwr.tr_S + y = gwr.y + mu = gwr.mu #sigma2 = gwr.sigma2 if isinstance(gwr.family, Gaussian): aicc = -2.0 * gwr.llf + 2.0 * n * (k + 1.0) / ( n - k - 2.0) #equivalent to below but - #can't control denominator of sigma without altering GLM familt code + #can't control denominator of sigma without altering GLM family code #aicc = n*np.log(sigma2) + n*np.log(2.0*np.pi) + n*(n+k)/(n-k-2.0) elif isinstance(gwr.family, (Poisson, Binomial)): aicc = get_AIC(gwr) + 2.0 * k * (k + 1.0) / (n - k - 1.0) + #aicc = np.sum(gwr.family.resid_dev(y, mu)**2) + 2.0 * n * (k + 1.0) / (n - k - 2.0) return aicc def get_AIC(gwr): """ - Get AIC calue + Get AIC value Gaussian: p96, (4.22), Fotheringham, Brunsdon and Charlton (2002) GWGLM: AIC(G)=D(G) + 2K(G), where D and K denote the deviance and the effective number of parameters in the model with bandwidth G, respectively. - + """ k = gwr.tr_S #deviance = -2*log-likelihood diff --git a/mgwr/gwr.py b/mgwr/gwr.py index f771c43..3862e85 100755 --- a/mgwr/gwr.py +++ b/mgwr/gwr.py @@ -134,7 +134,7 @@ class GWR(GLM): spherical : boolean True for shperical coordinates (long-lat), False for projected coordinates (defalut). - + hat_matrix : boolean True to store full n by n hat matrix, False to not store full hat matrix to minimize memory footprint (defalut). @@ -516,10 +516,10 @@ class GWRResults(GLMResults): R2 : float R-squared for the entire model (1- RSS/TSS) - + adj_R2 : float adjusted R-squared for the entire model - + aic : float Akaike information criterion @@ -575,11 +575,11 @@ class GWRResults(GLMResults): pDev : float local percent of deviation accounted for; analogous to r-squared for GLM's - + D2 : float percent deviance explained for GLM, equivaleng to R2 for Gaussian. - + adj_D2 : float adjusted percent deviance explained, equivaleng to adjusted R2 for Gaussian. @@ -1438,8 +1438,8 @@ class MGWR(GWR): """ - def __init__(self, coords, y, X, selector, sigma2_v1=True, - kernel='bisquare', fixed=False, constant=True, + def __init__(self, coords, y, X, selector, family, offset=None, + sigma2_v1=True, kernel='bisquare', fixed=False, constant=True, spherical=False, hat_matrix=False): """ Initialize class @@ -1448,17 +1448,18 @@ def __init__(self, coords, y, X, selector, sigma2_v1=True, self.bws = self.selector.bw[0] #final set of bandwidth self.bws_history = selector.bw[1] #bws history in backfitting self.bw_init = self.selector.bw_init #initialization bandiwdth - self.family = Gaussian( - ) # manually set since we only support Gassian MGWR for now - GWR.__init__(self, coords, y, X, self.bw_init, family=self.family, - sigma2_v1=sigma2_v1, kernel=kernel, fixed=fixed, - constant=constant, spherical=spherical, + self.family = family + self.offset = offset + # manually set since we only support Gassian MGWR for now + GWR.__init__(self, coords, y, X, self.bw_init, self.family, + self.offset,sigma2_v1=sigma2_v1, kernel=kernel, + fixed=fixed, constant=constant, spherical=spherical, hat_matrix=hat_matrix) self.selector = selector self.sigma2_v1 = sigma2_v1 self.points = None self.P = None - self.offset = None + self.family = family self.exog_resid = None self.exog_scale = None self_fit_params = None @@ -1483,7 +1484,14 @@ def _chunk_compute_R(self, chunk_id=0): for i in range(n): wi = self._build_wi(i, self.bw_init).reshape(-1, 1) - xT = (self.X * wi).T + 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] + w = rslt[3] + xT = (self.X * w).T + else: + xT = (self.X * wi).T P = np.linalg.solve(xT.dot(self.X), xT).dot(init_pR).T pR[i, :, :] = P * self.X[i] @@ -1502,8 +1510,16 @@ 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]) - xw = Xj * wi - pAj[i, :] = Xj[index] / np.sum(xw * Xj) * xw + 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) + + w = rslt[3] + xw = Xj * w + else: + xw = Xj * wi + pAj[i, :] = (Xj[index] / np.sum(xw * Xj) * xw).reshape(-1) pR[chunk_index_Aj, :, j] = pAj.dot(pRj_old) err = pRj_old - pR[:, :, j] @@ -1520,21 +1536,33 @@ def _chunk_compute_R(self, chunk_id=0): def fit(self, n_chunks=1, pool=None): """ Compute MGWR inference by chunk to reduce memory footprint. - + Parameters ---------- n_chunks : integer, optional - A number of chunks parameter to reduce memory usage. + A number of chunks parameter to reduce memory usage. e.g. n_chunks=2 should reduce overall memory usage by 2. pool : A multiprocessing Pool object to enable parallel fitting; default is None. - + Returns ------- : MGWRResults """ + #self.fit_params['ini_params'] = ini_params + #self.fit_params['tol'] = tol + #self.fit_params['max_iter'] = max_iter + params = self.selector.params - predy = np.sum(self.X * params, axis=1).reshape(-1, 1) + + if isinstance(self.family,Poisson): + 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))) + + else: + predy = np.sum(self.X * params, axis=1).reshape(-1, 1) try: from tqdm.autonotebook import tqdm #progress bar @@ -1692,7 +1720,7 @@ class MGWRResults(GWRResults): R2 : float R-squared for the entire model (1- RSS/TSS) - + adj_R2 : float adjusted R-squared for the entire model diff --git a/mgwr/search.py b/mgwr/search.py index fdd6662..78ce674 100755 --- a/mgwr/search.py +++ b/mgwr/search.py @@ -4,6 +4,7 @@ import numpy as np from copy import deepcopy +from spglm.family import Gaussian, Binomial, Poisson def golden_section(a, c, delta, function, tol, max_iter, int_score=False, @@ -164,8 +165,8 @@ def equal_interval(l_bound, u_bound, interval, function, int_score=False, return opt_val, opt_score, output -def multi_bw(init, y, X, n, k, family, tol, max_iter, rss_score, gwr_func, - bw_func, sel_func, multi_bw_min, multi_bw_max, bws_same_times, +def multi_bw(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=False): """ Multiscale GWR bandwidth search procedure using iterative GAM backfitting @@ -180,7 +181,17 @@ def multi_bw(init, y, X, n, k, family, tol, max_iter, rss_score, gwr_func, err = optim_model.resid_response.reshape((-1, 1)) param = optim_model.params - XB = np.multiply(param, X) + 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)) + XB = 1/(1+np.exp(-1*np.multiply(param,X))) + #XB=np.log(XB/(1-XB)) + else: + XB = np.multiply(param, X) + if rss_score: rss = np.sum((err)**2) iters = 0 @@ -205,6 +216,10 @@ def tqdm(x, desc=''): #otherwise, just passthrough the range temp_y = XB[:, j].reshape((-1, 1)) temp_y = temp_y + err temp_X = X[:, j].reshape((-1, 1)) + + #if isinstance(family, Binomial): + #bw_class = bw_func_g(temp_y, temp_X) + #else: bw_class = bw_func(temp_y, temp_X) if np.all(bw_stable_counter == bws_same_times): @@ -217,10 +232,16 @@ def tqdm(x, desc=''): #otherwise, just passthrough the range else: bw_stable_counter = np.ones(k) + #if isinstance(family, Binomial): + #optim_model = gwr_func_g(temp_y, temp_X, bw) + + #else: optim_model = gwr_func(temp_y, temp_X, bw) err = optim_model.resid_response.reshape((-1, 1)) param = optim_model.params.reshape((-1, )) + #new_XB[:,j] = 1/(1+np.exp(-1*np.sum(temp_X * param, axis=1).reshape(-1))) new_XB[:, j] = optim_model.predy.reshape(-1) + #new_XB[:, j] = np.log(new_XB[:,j]/(1-new_XB[:,j])) params[:, j] = param bws[j] = bw @@ -230,7 +251,14 @@ def tqdm(x, desc=''): #otherwise, just passthrough the range XB = new_XB if rss_score: - predy = np.sum(np.multiply(params, X), axis=1).reshape((-1, 1)) + 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))) + + else: + predy = np.sum(np.multiply(params, X), axis=1).reshape((-1, 1)) new_rss = np.sum((y - predy)**2) score = np.abs((new_rss - rss) / new_rss) rss = new_rss diff --git a/mgwr/sel_bw.py b/mgwr/sel_bw.py index 34d5587..d2d696c 100755 --- a/mgwr/sel_bw.py +++ b/mgwr/sel_bw.py @@ -136,7 +136,7 @@ class Sel_BW(object): >>> pov = np.array(data.by_col('PctPov')).reshape((-1,1)) >>> african_amer = np.array(data.by_col('PctBlack')).reshape((-1,1)) >>> X = np.hstack([rural, pov, african_amer]) - + Golden section search AICc - adaptive bisquare >>> bw = Sel_BW(coords, y, X).search(criterion='AICc') @@ -213,7 +213,7 @@ def search(self, search_method='golden_section', criterion='AICc', min value used in bandwidth search bw_max : float max value used in bandwidth search - multi_bw_min : list + multi_bw_min : list min values used for each covariate in mgwr bandwidth search. Must be either a single value or have one value for each covariate including the intercept @@ -374,12 +374,34 @@ def _mbw(self): bws_same_times = self.bws_same_times def gwr_func(y, X, bw): + family = self.family + #if isinstance(family, Binomial): + #family = Gaussian() + return GWR(coords, y, X, bw, family=family, kernel=kernel, + fixed=fixed, offset=offset, constant=False, + spherical=self.spherical, hat_matrix=False).fit( + lite=True, pool=self.pool) + + def gwr_func_g(y, X, bw): + family = self.family + family = Gaussian() return GWR(coords, y, X, bw, family=family, kernel=kernel, fixed=fixed, offset=offset, constant=False, spherical=self.spherical, hat_matrix=False).fit( lite=True, pool=self.pool) def bw_func(y, X): + family = self.family + #if isinstance(family, Binomial): + #family = Gaussian() + selector = Sel_BW(coords, y, X, X_glob=[], family=family, + kernel=kernel, fixed=fixed, offset=offset, + constant=False, spherical=self.spherical) + return selector + + def bw_func_g(y, X): + family = self.family + family = Gaussian() selector = Sel_BW(coords, y, X, X_glob=[], family=family, kernel=kernel, fixed=fixed, offset=offset, constant=False, spherical=self.spherical) @@ -391,9 +413,9 @@ def sel_func(bw_func, bw_min=None, bw_max=None): bw_min=bw_min, bw_max=bw_max, interval=interval, tol=tol, max_iter=max_iter, pool=self.pool, verbose=False) - self.bw = multi_bw(self.init_multi, y, X, n, k, family, self.tol_multi, - self.max_iter_multi, self.rss_score, gwr_func, - bw_func, sel_func, multi_bw_min, multi_bw_max, + self.bw = multi_bw(self.init_multi, y, X, n, k, family, offset, self.tol_multi, + self.max_iter_multi, self.rss_score, gwr_func,gwr_func_g, + bw_func,bw_func_g,sel_func, multi_bw_min, multi_bw_max, bws_same_times, verbose=self.verbose) def _init_section(self, X_glob, X_loc, coords, constant): diff --git a/notebooks/Binomial_MGWR_approaches_tried.ipynb b/notebooks/Binomial_MGWR_approaches_tried.ipynb new file mode 100644 index 0000000..e7bc82d --- /dev/null +++ b/notebooks/Binomial_MGWR_approaches_tried.ipynb @@ -0,0 +1,758 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "https://github.com/pysal/mgwr/pull/56" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from mgwr.gwr import GWR\n", + "from spglm.family import Gaussian, Binomial, Poisson\n", + "from mgwr.gwr import MGWR\n", + "from mgwr.sel_bw import Sel_BW\n", + "import multiprocessing as mp\n", + "pool = mp.Pool()\n", + "from scipy import linalg\n", + "import numpy.linalg as la\n", + "from scipy import sparse as sp\n", + "from scipy.sparse import linalg as spla\n", + "from spreg.utils import spdot, spmultiply\n", + "from scipy import special\n", + "import libpysal as ps\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "import copy\n", + "from collections import namedtuple\n", + "import spglm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Fundamental equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By simple algebraic manipulation, the probability that Y=1 is:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{align}\n", + "p = 1 / (1 + exp (-{\\beta} & _k x _{k,i}) ) \\\\\n", + "\\end{align}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Approaches tried:\n", + "\n", + "1. Changing XB to : `1 / (1 + np.exp (-1*np.sum(np.multiply(X,params),axis=1)))` - these are the predicted probabilities ~(0,1)\n", + "\n", + "\n", + "2. Changing XB as above and writing a function to create temp_y as a binary variable using condition `1 if BXi > 0 else 0.`\n", + "\n", + "\n", + "3. Derived manipulations to temp_y as in iwls for Logistic regression as below:\n", + "\n", + " `v = np.sum(np.multiply(X,params),axis=1)`\n", + " \n", + " `mu = 1/(1+(np.exp(-v)))`\n", + " \n", + " `z = v + (1/(mu * (1-mu)) * (y-mu))` -- this becomes the temp_y\n", + " \n", + " Then a simple linear regression can be run as z as the temp dependent variable\n", + " \n", + " \n", + "4. Taken from GAM logistic model literature:\n", + " \n", + " `y=exp(b0+b1*x1+...+bm*xm)/{1+exp(b0+b1*x1+...+bm*xm)}`\n", + "\n", + " Applying the logistic link function to the probability p (ranging between 0 and 1):\n", + "\n", + " `p' = log {p/(1-p)}`\n", + "\n", + " By applying the logistic link function, we can now rewrite the model as:\n", + "\n", + " `p' = b0 + b1*X1 + ... + bm*Xm`\n", + "\n", + " Finally, we substitute the simple single-parameter additive terms to derive the generalized additive logistic model:\n", + "\n", + " `p' = b0 + f1(X1) + ... + fm(Xm)`\n", + " \n", + " (http://www.statsoft.com/textbook/generalized-additive-models#gam)\n", + " \n", + " This is the current approach in the latest commit:\n", + " \n", + " `XB = 1 / (1 + np.exp (-1*(np.multiply(X,params))))`\n", + " \n", + " XB is now the probability and is normally distributed\n", + " \n", + " Run MGWR (Gaussian) on this as the dependent variable for the partial models.\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Clearwater data - downloaded from link: https://sgsup.asu.edu/sparc/multiscale-gwr" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "data_p = pd.read_csv(\"C:/Users/msachde1/Downloads/logistic_mgwr_data/landslides.csv\") " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
UserIDXYElevSlopeSinAspctCosAspctAbsSouthLandslidDistStrm
01616168.56255201076.51450.47527.441720.409126-0.91247824.149918.506
12624923.81255201008.51567.47621.88343-0.919245-0.39368566.8160115.561
23615672.00005199187.51515.06538.81030-0.535024-0.84483732.3455141.238
34615209.31255199112.01459.82726.71631-0.828548-0.55991855.9499117.539
45616354.68755198945.51379.44227.55271-0.872281-0.48900560.7248135.023
\n", + "
" + ], + "text/plain": [ + " UserID X Y Elev Slope SinAspct CosAspct \\\n", + "0 1 616168.5625 5201076.5 1450.475 27.44172 0.409126 -0.912478 \n", + "1 2 624923.8125 5201008.5 1567.476 21.88343 -0.919245 -0.393685 \n", + "2 3 615672.0000 5199187.5 1515.065 38.81030 -0.535024 -0.844837 \n", + "3 4 615209.3125 5199112.0 1459.827 26.71631 -0.828548 -0.559918 \n", + "4 5 616354.6875 5198945.5 1379.442 27.55271 -0.872281 -0.489005 \n", + "\n", + " AbsSouth Landslid DistStrm \n", + "0 24.1499 1 8.506 \n", + "1 66.8160 1 15.561 \n", + "2 32.3455 1 41.238 \n", + "3 55.9499 1 17.539 \n", + "4 60.7248 1 35.023 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_p.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Helper functions - hardcoded here for simplicity in the notebook workflow\n", + "Please note: A separate bw_func_b will not be required when changes will be made in the repository" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "kernel='bisquare'\n", + "fixed=False\n", + "spherical=False\n", + "search_method='golden_section'\n", + "criterion='AICc'\n", + "interval=None\n", + "tol=1e-06\n", + "max_iter=500\n", + "X_glob=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def gwr_func(y, X, bw,family=Gaussian(),offset=None):\n", + " return GWR(coords, y, X, bw, family,offset,kernel=kernel,\n", + " fixed=fixed, constant=False,\n", + " spherical=spherical, hat_matrix=False).fit(\n", + " lite=True, pool=pool)\n", + "\n", + "def gwr_func_g(y, X, bw):\n", + " return GWR(coords, y, X, bw, family=Gaussian(),offset=None,kernel=kernel,\n", + " fixed=fixed, constant=False,\n", + " spherical=spherical, hat_matrix=False).fit(\n", + " lite=True, pool=pool)\n", + "\n", + "\n", + "def bw_func_b(coords,y, X):\n", + " selector = Sel_BW(coords,y, X,family=Binomial(),offset=None, X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def bw_func_p(coords,y, X):\n", + " selector = Sel_BW(coords,y, X,family=Poisson(),offset=off, X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def bw_func(coords,y,X):\n", + " selector = Sel_BW(coords,y,X,X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def sel_func(bw_func, bw_min=None, bw_max=None):\n", + " return bw_func.search(\n", + " search_method=search_method, criterion=criterion,\n", + " bw_min=bw_min, bw_max=bw_max, interval=interval, tol=tol,\n", + " max_iter=max_iter, pool=pool, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GWR Binomial model with independent variable, x = slope" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "coords = list(zip(data_p['X'],data_p['Y']))\n", + "y = np.array(data_p['Landslid']).reshape((-1,1)) \n", + "elev = np.array(data_p['Elev']).reshape((-1,1))\n", + "slope = np.array(data_p['Slope']).reshape((-1,1))\n", + "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", + "\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", + "y_std = (y-y.mean(axis=0))/y.std(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "bw_gwbr=Sel_BW(coords,y,x_std,family=Binomial(),constant=False).search()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "gwbr_model=GWR(coords,y,x_std,bw=bw_gwbr,family=Binomial(),constant=False).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100.0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw_gwbr" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "predy = 1/(1+np.exp(-1*np.sum(gwbr_model.X * gwbr_model.params, axis=1).reshape(-1, 1)))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "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(predy)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(predy==gwbr_model.predy).all()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8VOXZN/DfNdn3fd8DCZCwJ2wiiCKKqNBWVHCrC2J9bLWPfdvHPq1L7dundq+KdakrqIAvWkVFUBaLIFvYCSQhhOxk3/fMzP3+QfCJMSETMpMzc+b3/XzyIZM5zLk4TH45uc9130eUUiAiIn0xaF0AERFZH8OdiEiHGO5ERDrEcCci0iGGOxGRDjHciYh0iOFORKRDDHciIh1iuBMR6ZCrVjsODQ1ViYmJWu2eiMghHTx4sEYpFTbYdpqFe2JiIrKysrTaPRGRQxKRIku247AMEZEOMdyJiHSI4U5EpEMMdyIiHWK4ExHpEMOdiEiHGO5ERDrEcCci0iGGOxGRDmk2Q5WIhubdfcVal/Adt82I17oEGgDP3ImIdIjhTkSkQwx3IiIdYrgTEekQw52ISIcY7kREOsRwJyLSIYY7EZEOMdyJiHSI4U5EpEMMdyIiHWK4ExHpEMOdiEiHGO5ERDrEcCci0iGGOxGRDjHciYh0iOFORKRDDHciIh1iuBMR6RDDnYhIhxjuREQ6xHAnItKhQcNdROJEZIeInBKRbBF5pJ9tRESeE5F8ETkmIlNtUy4REVnC1YJtjAB+ppQ6JCJ+AA6KyBdKqZO9trkOQErPxwwAL/b8SUREGhj0zF0pdU4pdajn82YApwDE9NlsCYDV6ry9AAJFJMrq1RIRkUWGNOYuIokApgDY1+epGAAlvR6X4rs/ACAiK0UkS0Syqqurh1YpERFZzOJwFxFfAO8D+KlSqqnv0/38FfWdLyj1ilIqUymVGRYWNrRKiYjIYhaFu4i44Xywv6OU+qCfTUoBxPV6HAugfPjlERHRpbCkW0YAvAbglFLqrwNsthHAXT1dMzMBNCqlzlmxTiIiGgJLumVmA7gTwHEROdLztf8GEA8ASqmXAGwCsAhAPoA2APdYv1QiIrLUoOGulNqF/sfUe2+jADxkraKIiGh4OEOViEiHGO5ERDrEcCci0iGGOxGRDjHciYh0iOFORKRDDHciIh1iuBMR6RDDnYhIhxjuREQ6xHAnItIhhjsRkQ4x3ImIdIjhTkSkQwx3IiIdYrgTEekQw52ISIcY7kREOsRwJyLSIYY7EZEOMdyJiHSI4U5EpEOuWhdAI+fdfcVal9Cv22bEa10Cke7wzJ2ISIcY7kREOsRwJyLSIYY7EZEOMdyJiHSI4U5EpEMMdyIiHWK4ExHpEMOdiEiHGO5ERDrEcCci0iGGOxGRDjHciYh0aNBwF5HXRaRKRE4M8Pw8EWkUkSM9H09Yv0wiIhoKS5b8fRPAKgCrL7LNV0qpG6xSERERDdugZ+5KqZ0A6kagFiIishJrjbnPEpGjIvKZiKQPtJGIrBSRLBHJqq6uttKuiYioL2uE+yEACUqpSQCeB/DhQBsqpV5RSmUqpTLDwsKssGsiIurPsMNdKdWklGrp+XwTADcRCR12ZUREdMmGHe4iEiki0vP59J7XrB3u6xIR0aUbtFtGRNYCmAcgVERKATwJwA0AlFIvAVgK4EERMQJoB7BMKaVsVjEREQ1q0HBXSi0f5PlVON8qSUREdoIzVImIdIjhTkSkQwx3IiIdYrgTEekQw52ISIcY7kREOsRwJyLSIYY7EZEOMdyJiHSI4U5EpEMMdyIiHbLkNntERAAAk1nhdGUzjpU1otNoxu78GiSEeGP59HjEBXtrXR71wnAnIoscLq7H5uwKNHcY4e3uAn9PN+QYTdicXYEX/30GC8ZF4KnF6YgO9NK6VALDnYgGYTSZ8enxc9h3tg7xwd5YMikGYyL94GIQ3DYjHuca2/H23iK8ubsQi1ftxst3ZiAjIUjrsp0ex9yJaEDdJjPe+LoQ+87WYU5KKO6fk4y0aH+4GOSbbaICvPDza8fiw4dmw8fDBctf2YuPj5ZrWDUBDHciGoBZKWw4WIqzNa24OSMW142P+lao95US4YePHpqNSXEBePS9IzhQWDeC1VJfDHci6tfn2ZU4XtaIhemRmBJv2TBLoLc7/nlXJmKDvPHAmoMoqWuzcZU0EIY7EX3HibJG7DxdjelJwZiTMrT73Qd6u+PVH2bCaDJjxVtZ6Og22ahKuhiGOxF9S2unER8dKUN0oCdunBgNkYGHYgYyKswXzy2fgtzKZjy77bQNqqTBMNyJ6Fs+PlaOjm4zlk6Nu+gY+2DmjQnHLZmxeGVnAU6UNVqxQrIEw52IvpFd3ohjpY24cmw4IgM8h/16v1qUhmAfd/xiwzF0m8xWqJAsxXAnIgDn2x4/PXYOUQGeuCI1zCqvGeDtht8uGY+T55rw5u5Cq7wmWYbhTkQAgL0FtWho78aiCRdveRyqheMjMTc1DKt25KOxrdtqr0sXx3AnIrR1GbEjtwpjIvwwKszX6q//2MKxaOroxov/PmP116b+MdyJCDtyqtDZbcbC8ZE2ef20aH98b3IM3th9Fuca222yD/o2hjuRk2to68Les3XISAhChP/wL6IO5NEFqVAK+NsXeTbbB/0vhjuRk/sqvwZKKVw5Ntym+4kL9sbtM+PxwaEylNZz5qqtMdyJnFhLpxFZhXWYHBeEIG93m+9v5dxkiAD/3Flg8305O4Y7kRPbnV8Do0lZrfVxMFEBXvj+lBisO1CC6ubOEdmns2K4Ezmp9i4T9hbUIj0mAGF+HiO23weuGIUukxlv7D47Yvt0Rgx3Iie1/2wtOo1mzBuhs/YLRoX5YtH4KKzZU4SmDva92wrDncgJmcwKewpqMSrMR5Pb4v3oilFo7jTivQMlI75vZ8FwJ3JC2eWNaOow4rJRQ1vO11omxAYgMyEIq/cUwWRWmtSgdwx3Iif09ZlaBPu4Y0ykn2Y13D07EcV1bfgyt0qzGvSM4U7kZErr21Bc14ZZySEwXMJa7dZybXokIv098ebXhZrVoGeDhruIvC4iVSJyYoDnRUSeE5F8ETkmIlOtXyYRWcvXZ2rh7mpARoJlt86zFTcXA+6YGY+vTtcgv6pZ01r0yJIz9zcBLLzI89cBSOn5WAngxeGXRUS20NppxPGyRkyND4Snm4vW5WD59Hi4uxqwek+R1qXozqDhrpTaCeBitzFfAmC1Om8vgEARibJWgURkPYeK62EyK0xPCtG6FABAiK8HFo2PxL8Ol6G9i/datSZrjLnHAOjdz1Ta8zUisiNKKew/W4f4YG9E2nCBsKG6dVo8mjuM+OzEOa1L0RVrhHt/V2T67W0SkZUikiUiWdXV1VbYNRFZqqCmFbWtXZieFKx1Kd8yMzkYiSHeWMeed6uyRriXAojr9TgWQHl/GyqlXlFKZSqlMsPCRnZWHJGz23+2Dl5uLpgQE6B1Kd8iIrhlWhz2n61DQXWL1uXohjXCfSOAu3q6ZmYCaFRK8fcrIjvS0mnEyfImTIkPhJuL/XVAL50aCxeDYH0Wz96txXWwDURkLYB5AEJFpBTAkwDcAEAp9RKATQAWAcgH0AbgHlsVS0NnNiscL2tEflULsgrrICJICPZGiK87RMMeZxpZR0oaYFIK0xLta0jmgnB/T8wfG473D5bi/1wzxi5/ADmaQcNdKbV8kOcVgIesVhFZRW1LJ17YcQabjp9DRVPHd54P8nbD1IQgzBkdBndXfiPpmVIKh4rqERvkZdM7LQ3Xsulx+PxkJbadqrLZ7f6cyaDhTo7FZFZ4d38x/rQ5B21dJswfF46fp43B1IQgfHb8HLpMZhRUtyKnognbTlUhq7AeC9MjMSkuUOvSyUbONXagoqkDiydFa13KRc1NCUOkvyfWHyhmuFsBw11H2rqMeHjtYWw9VYXLRoXg6SXpGB3+v2uHBPbcaSfczxMzk0NQWNOKT4+fw/qsEhTVteH6CVFwMXCoRm8OFtfDxSCYFGvfP8BdXQy4OTMWL+zIR3lDuyarVeoJfx/XiermTix7ZS+251ThN4vT8c6KGd8K9v4khvrgwXmjcPnoUOwtqMWavYXo6OZEEj0xms04WtKAtCh/eLlrPyN1MLdkxsGsgA0HS7UuxeEx3HWgtqUTt7y8B6crW/DKnZn44WWJFl8sNYhg0YQofH9yDPKrWrBmbxG6TWYbV0wjJbeiGW1dJkyN13YdGUvFBXvj8tGhWH+gBGYuBTwsDHcH195lwn1vZaG8oR1r7puOq9MiLul1piUF4+aMOJytacV7WSUwK35j6cGhonr4ebpidLiv1qVY7NZpcShraMeu/BqtS3FoDHcHZjIr/GTtIRwrbcBzy6cgc5htbpPiAnH9hChklzfh46P9zkMjB9Lc0Y3cymZMiQt0qGsp16RHIMDLjUMzw8Rwd2DPbs3D1lNVeGpxOq5Nt053wezRoZgzOhT7ztbhcHG9VV6TtHG0tBFmBUxxkCGZCzxcXbBkcjS2ZFegsZ33WL1UDHcH9XV+DZ7fkY+bpsbirlmJVn3ta9IjkRjigw+PlKGqnx55sn+O0ts+kKUZseg0mvHpMU52v1QMdwdU09KJR9YfQXKoD55ekm7113cxCJZNi4O7iwHv7i9Gl5EXWB1NeU9vu6NcSO1rQkwAUiN8seEglyO4VAx3B6OUwmPvH0djezdW3TYVPh62marg7+WGWzLjUNXcia2nKm2yD7KdQ0WO0ds+EBHB0oxYHCpuwBkuJnZJGO4O5pNj57D1VCV+fs0YjIvyt+m+UiL8MD0xGLvza1BS12bTfZH1GE1mHHGg3vaBfG9yDFwMgvd5YfWSMNwdSH1rF57amI1JsQG4Z3biiOxz4fhI+Hu54f1DpTCy/90h5FQ0o73bcXrbBxLu74krUsPwwaEymNjzPmQMdwfy209OorG9G8/cNBGuI7RqnqebC743OQZVzZ34Mo83WHEEh4odr7d9IEszYlHR1IHd7HkfMoa7g9hbUIsPDpfhwXmjbD4c09eYSD9MjA3Azrxq1LV2jei+aWiaO7qRV9mMKXFBDtXbPpD548LZ836JGO4OwGgy46mN2YgJ9MJDV47WpIZF46NgMAg+PcbJTfbsaEkDzAqYGu+YF1L7Ys/7pWO4O4C1+4uRU9GMx28YB083bS6Q+Xu54aox4ThV0YzcimZNaqCLU0rhYHE94oK8EO6Ave0DYc/7pWG427n61i78+fM8zB4dYrVZqJfqstEhCPX1wCfHymE08+KqvSlv7EBlUyemJjj2hdS+2PN+aRjudu7ZbafR0mnEkzema35bPFeDAddPiERtaxcOFHJpAntzqKgergbBxBh9DMlcwJ73S8Nwt2OFNa14e28Rbp0Wh9SIi6/NPlJSI/yQFOqD7TlV6DRy7Xd7caG3fZyD97YPhD3vQ8dwt2N/2pILd1cDfnp1italfENEsDA9Eq2dRi7Jakcu9LZn6GxI5gL2vA8dw91OHS6ux6fHz+H+OckI97Ovi2Nxwd5Ij/bHV6dr0NJp1Locwvnedn+d9LYPhD3vQ8Nwt0NKKfz+sxyE+nrg/rnJWpfTr2vSImE0mbEjt0rrUpzehd72yXFBMGh8XcaW2PM+NAx3O7Qrvwb7z9bhJ1eNhq+NFgYbrjA/D2QkBGF/QR0nNmlMb73tA2HP+9Aw3O2MUgp/+TwP0QGeWDY9TutyLuqqsREQAVeN1NCF3vZYnfW2D4Q975ZjuNuZHblVOFLSgJ/MT4GHq313PQR4uWH26FAcLWlAeUO71uU4pdL6dlQ2dSIzYXi3WHQU7Hm3HMPdjiil8Ncv8hAf7I2lGbFal2ORuSlh8HRzwecnK7QuxSllFdXBzUUwMTZA61JGBHveLcdwtyNbsitxoqwJD89PgdsIrfo4XF7uLrgiNQx5lS0oqm3Vuhyn0mk04WhpIybEBGq2LIUW2PNuGcdIECdgNiv87Ys8JIf64HuTo7UuZ0hmJofAx8MVX3DsfUQdL21El9GMaYn67G0fCHveLcNwtxOfHj+H3MpmPHJ1yoit1W4t7q4GzEsNQ0F1K39VHkFZRfUI8/VAfLC31qWMOPa8D86xUkSnTGaFv2/NQ2qEL26c6Fhn7RdMTwqGv6crtp6shFI8m7K1qqYOFNe1ITMxSPM1h7TAnvfBMdztwEdHynCmuhX/eXUqDA56gwU3FwPmjQlHUV0bTlfx7N3WsorqYRBgioPfSu9SXeh535xdgcY29rz3h+GusW6TGX/fehppUf6aL+k7XJkJQQj0csPWUzx7tyWj2YxDxfUYF+Vvt5PcRsKt0+LQZTTjg8M8e+8Pw11j7x8sRXFdGx5d4Lhn7Re4uhhw1dhwlNa3I4c39LCZU+ea0dZlcpre9oGkRwdgUlwg1u4v5slEPxjuGuo0mvD89nxMigvE/HHhWpdjFVPigxDs446tpyph5jecTRwsqkOAlxtSIvS7SJilbpseh7zKFhwq5v0F+mK4a+i9AyUoa2jHowtSdXNRzMUgmD82HOcaO3CyvEnrcnSnoa0LpytbkJGg70XCLHXDxGj4erji3X2csdoXw10jHd0mrNqRj8yEIMxNCdW6HKuaFBeIMF8Pnr3bwMGi82eoGU56IbUvHw9XLJkcjU+OlfPCah8WhbuILBSRXBHJF5HH+nn+bhGpFpEjPR8rrF+qvryzrxiVTZ149Br9nLVfYBDB/HHhqGruxPHSRq3L0Q2TWeFAYR1Gh/siyMdd63LsxvLp8ejkhdXvGDTcRcQFwAsArgOQBmC5iKT1s+l6pdTkno9XrVynrrR1GfHil/mYlRyCy0bp66z9gvExAYj098S2nErOIrSSk+ea0NRhxMzkEK1LsSvjYwIwJT4Qa/YUwcz32jcsOXOfDiBfKVWglOoCsA7AEtuWpW+r9xShpqULP7smVetSbObC2XtNSxeOljRoXY4u7C2oRaC3G8ZE2sf9dO3JXbMSUFDTit1nOGP1AkvCPQZA76sVpT1f6+smETkmIhtExL4XItdQS6cRL//7DOamhiEzUd+tbGlR/ogO9MT23CqevQ9TXmUzzta0YkZSCC+k9mPRhCiE+Lhj9Z4irUuxG5aEe3/vpL7fqR8DSFRKTQSwFcBb/b6QyEoRyRKRrOrq6qFVqhOvfXUW9W3deHSBfs/aLxARLBgXgbrWLhwqYqvacKzZUwRXgyBTpzfAHi4PVxcsmx6HbacqUVLXpnU5dsGScC8F0PtMPBZAee8NlFK1SqnOnof/BJDR3wsppV5RSmUqpTLDwsIupV6HVtvSiVd2nsG16RGYHKfvW6JdkBrhh7ggL2zPrYLRZNa6HIfU1NGNDw6VYmJsAHyceEbqYG6fkQDgfLMCWRbuBwCkiEiSiLgDWAZgY+8NRCSq18PFAE5Zr0T9WLUjH+3dJvz82jFalzJiRAQL0iLR2N6NA4V1WpfjkNbvL0FrlwmzdHrx3VqiA71wTVok1u4vRluXUetyNDdouCuljAB+DGALzof2e0qpbBF5WkQW92z2sIhki8hRAA8DuNtWBTuqkro2vLO3GDdnxGF0uHNdEBsV5oPEEB98mVeNbp69D4nRZMYbu89iZnIwYgK9tC7H7q2Yk4TG9m6uFgkL+9yVUpuUUqlKqVFKqd/1fO0JpdTGns9/qZRKV0pNUkpdqZTKsWXRjuhvW/MgAvx0QYrWpYy482fvEWjuMGLPmVqty3Eom05UoLyxAysuT9a6FIeQkRCEyXGBeG3XWae/iM8ZqiMgp6IJ/zpchrsvS0RUgHOefSWF+mBMhB++zKtCayd/ZbaEUgqvflWApFAfXDVWH2sP2ZqI4P45ySiqbcMXJ537zmAM9xHwp8258PVwxYPzRmldiqYWjo9EZ7cZ23OrtC7FIRworMex0kbce3mSw68YOpKuTY9AbJAXXv2qQOtSNMVwt7EDhXXYllOFH10xCoHezj1lPMLfE9MSg7GvoBY1zZ2D/wUn948v8xHk7YabpvY3rYQG4upiwL2zk5BVVP/NWjzOiOFuQ0op/OGzHIT7eeDe2Ulal2MX5o8Lh6uLAZuzK7Quxa6dKGvEl7nVuO/yJHi7s/1xqJZNj0OQtxtWbT+tdSmaYbjb0JbsSmQV1eORq1Pg5e6idTl2wc/TDVekhuHkuSacrWnVuhy79cKOfPh5uuKuyxK1LsUhebu7YsWcZOzIrcaJMudcvI7hbiOdRhP+Z9MppEb44tZMrsbQ2+xRoQjwcsOm4+e4JHA/8quasTm7Aj+clQh/Tzety3FYd85KgJ+nK1Ztz9e6FE0w3G3k9V2FKK5rw+M3pMHVhYe5N3dXAxakRaCsoR3HuCTwd7yw4ww8XV1w7+UcyhsOf0833HNZIjZnVyDXCW/7yNSxgarmDqzafhpXjwvHnBTnW2bBEpPjAhEd4InPsyvQ0W3Suhy7cbqyGR8dKcMdM+MRzDXbh+2e2UnwcXfBc9ucb+yd4W4Df9yciy6TGb+6vr9l7wk4vyTwoglRaGjvxotfntG6HLvx589z4e3uigfnjda6FF0I8nHHfZcn4dPj55zuxjEMdyvbf7YOGw6WYsWcZCSF+mhdjl1LDvPFxNgAvPjvM7y4CuBoSQO2ZFfi/jnJPGu3ohVzkxHk7YY/bnGuifMMdyvqNpnx6w+PIybQCw9f5XzLDFyKRROi4O5iwJMbs6Gc/OLqn7bkItjHHffN4Vi7Nfl7uuGhK0fjq9M1+NqJbubBcLei13adRV5lC36zOJ2tjxby93TDz65Jxc68amw67ry97zvzqrErvwb/MW8UfLmsr9XdMTMBUQGe+MPmXKc5iWC4W0lRbSue3XoaC9IicHVahNblOJQ7ZyYgPdofT27MRn1rl9bljLhukxlPf3ISiSHeuHNWgtbl6JKnmwseXZCKoyUN+PBImdbljAiGuxWYzQq/2HAMrgbB00vStS7H4bi6GPDHpRPR0NaF335yUutyRtzqPUXIr2rBr69Pg4crf+OzlZumxmJSbAB+vykHLU6weB3D3Qre3leEfWfr8PgNaU676uNwpUcH4D/mjcIHh8uwPcd5VvOrbenE37fmYW5qGOaP48qPtmQwCJ5anI6q5k487wTLEjDch6m4tg3PfJaDualhuDkzVutyHNqPr0rBmAg//PKD404zPPP7z3LQ3mXCEzekQXjja5ubEh+EmzNi8fquszhT3aJ1OTbFcB+GbpMZj6w/DBcR/P4HE/jNOUzurgb85ZZJqGvtwmMfHNP9ha+dedXYcLAUK+cmY3S4r9blOI1fLBwLLzcX/PL94zDr+IYeDPdheHbraRwubsD//GACb4FmJeNjAvCLa8diS3Yl3t2v3xsdt3Ya8csPjmNUmA8ens+22ZEU5ueBx29Iw/7COry9r0jrcmyG4X6Jvj5Tgxe+zMctmbG4cVK01uXoyn2XJ2FOSih++8lJ5FXqc02QP27OQXljO/64dCI83XgRdaQtzYjFFalheOazHJTUtWldjk0w3C9BRWMHHll3BEkhPnhqMbtjrM1gEPzllknw9XDDA2sOoqmjW+uSrGpHbhXe2lOEH85KREZCsNblOCXpGUo1iODnG47q8n6rDPch6ug24YG3D6K104iX7szgjRRsJNzPE/+4fSpK6trwn+uO6GZstLKpAz977yjGRvrhsevGal2OU4sO9MKTN6Zhb0GdLrtnGO5DoJTCEx+dwNGSBvz1lklIjfDTuiRdm54UjCduTMO2nCr8bWue1uUMm8ms8Mi6w2jvMmHVbVM5HGMHlmbE4gdTYvDsttO6W5qA4T4EL/27AO9lleLHV47GwvFRWpfjFO6cmYBbMmPx/PZ8rHPwC6x/3JKDvQV1eHpJOrtj7ISI4LffG4+kUB88su4Iqpo6tC7JahjuFtpwsBR/2JyDGydF49EFqVqX4zREBL/7/gTMTQ3Drz48gW2nHHOC03tZJXj53wW4bUY8lmZwPoQ98fFwxT9un4rWTiPueysLbV36mL3KcLfAjpwq/Nf7xzB7dAj+fPNEGAzsZx9Jbi4GvHj7VKRH++Ohdw9hz5larUsakj1navHfHxzHnJRQ/GZxOudD2KGxkf54btkUnChvxH+u18c1Hob7ILadqsQDaw5iXJQfXrojg2t/aMTHwxWv3z0NcUHeuOfN/did7xjjo0dKGrBydRYSQ32w6rapcOMtF+3W1WkR+PX1adiSXYmnPznp8JPo+E67iM+zK/Cjtw9ibJQf3rlvJvx4s2JNhfp6YO3KmUgM8cG9bx7AjtwqrUu6qOOljbjztX0I8nHHmvumI8CL7x97d+/sRNw7Owlvfl2I3316yqEDnuE+gLf3FuHBdw4hPToAa+6bgQBvfmPag1BfD7x7/0yMDvfFireysGavfc4wzCqswx2v7UOAlxvWrpzJBeUchIjg8RvG4a5ZCXh111k881mOwwY8w70Pk1nhd5+exK8/PIG5KaF4e8UMnnHZmWAfd6x/YBauSA3D4x+ewG8+zka3yax1Wd/4+Gg5bnt1H0J83LH2/plcmsLBiAh+szgdd8yMx8s7C/Cz946iy2g/7y9LcQZOL1XNHXh0/VHsyq/B3Zcl4tfXj4Mrx0jtkq+HK/55Vyb+76cn8cbuQhwubsDzy6cgLthbs5qMJjOe3XYaz2/Px/TEYLx8ZwaCeC9UhyQi+O2S8Qj388Rfv8hDeWM7Xrzdsf4/mVw9vsytwqJnv0JWUR3+cNMEPLU4ncFu51wMgidvTMcLt03FmeoWLHr2K6zbX6xJp0NJXRtueXkPnt+ej5szYrFmxXSHCgL6LhHBw/NT8LdbJ+FQUQMWPfcV9p+t07osizl9etW0dOKRdYdx9xsHEOTtjo0/vhy3TovXuiwagusnRmHTw3MwLtofj31wHEtf+honyhpHZN+dRhP+8WU+rv37TpyuasFzy6fgTzdPYleVjnx/Sizef/AyeLgasOyVPfjzllx0dJu0LmtQTjss09Ftwuo9hXhhxxm0dRnx8PwU/Me8UZwS7qDigr2xfuVMvH+oDP+z6RRueH4XFqZH4uH5KUiL9rf6/rpNZnxyrBzPbj2Nwto2LEiLwJM3piE2SLthIbKdCbEB+OThOXiQGh+MAAAHtUlEQVTyo2ys2pGPjUfL8dTiNFw5Jtxu5y04Xbi3dBrx/3pmC1Y0dWBuahgev34cUrhOjMMTESzNiMWCtAi8tuss3th1FpuzKzAjKRi3zYjHtemRw/7hXdHYgY+OlGH1niKUNbQjNcIXb907HVekhlnpX0H2ytfDFX+5ZRJumhqDxz86gXvfzML0xGD89OoUzBoVYnchL1q1+WRmZqqsrKwR2ZdSCsdKG/Gvw2V4/2ApmjuNmJYYhJ9dMwYzk0NGpAZ78O4++1yb5bYZthkGa2zrxjv7i7BufwmK69rg6WbA5aNDcUVqGCbHBWFMpB/cXS8+MtnRbUJ2eSP2FtRhZ1419hfWQSlgWmIQHpg7CleNDR+xGcv2+P9nq/87e9dlNGPdgWL8Y8cZVDR1YHyMP5ZPj8eSyTHw9bDtObOIHFRKZQ66nV7Dva3LiAOF9diZV41tpypRWNsGdxcDFo6PxL2XJ2FyXKDN9m2v7DEcANsHhNmssLegFluyK7D1VBXKGtoBAO4uBkQHeiI60AtB3u7wcDXAYBC0dBjR2N6N4ro2lDe248K3yNhIPywcH4nFk6KRHDbyC3/Z4/+fs4b7BR3dJmw4WIq39xYhp6IZHq4GzEkJxTVpkZg1KgSxQV5WP6O3NNwt+hEjIgsBPAvABcCrSqln+jzvAWA1gAwAtQBuVUoVDrVoS5jNCl0mM7pMZnQbzWjqMKKutROVTZ0orG1FQXUrTpQ1Iq+yGWZ1/r6cM5KC8eC8UVg4Poo9607IYBBcNjoUl40OxVOLFUrr23G0tAEnyppQWt+GsoZ2VFQ0octohtms4OfpBj9PV2QmBiE5NA5jIn0xLTEYIb4eWv9TyM54urngjpkJuH1GPA6XNGDjkXJ8cbISW0+dnz0d6e+JibEBSI3ww6hwH0T4eyLczxNRAZ7wsfEZ/qCvLiIuAF4AsABAKYADIrJRKXWy12b3AahXSo0WkWUA/gDgVlsU/Onxc/jJ2sMDPh/q64G0aH8sSItARkIQZiSFwMudF0npPBFBXLA34oK9ccNE3h6RrENEMDU+CFPjg/DkjWnIqWjGgcI6HCisx8nyRmzLqfrW3Z7un5OEX12fZtOaLPnRMR1AvlKqAABEZB2AJQB6h/sSAE/1fL4BwCoREWWDMZ9xUf74r4Vj4eYicDUI/L3cEOTjjnA/DySE+Nh8vIuI6GJEBOOi/DEuyh93zUoEcH6MvriuDVXNHahq6kRymI/N67AkCWMAlPR6XApgxkDbKKWMItIIIASA1ZfuGx3uyxsdEJFDcXc1jHh2WRLu/V0N6HtGbsk2EJGVAFb2PGwRkVwL9m+JUNjgB4kO2eVxul3rAvpnl8fK3tzO42Qpax6nBEs2siTcSwHE9XocC6B8gG1KRcQVQACA78zTVUq9AuAVSwobChHJsuTqsbPjcbIcj5VleJwso8VxsmT5gQMAUkQkSUTcASwDsLHPNhsB/LDn86UAtttivJ2IiCwz6Jl7zxj6jwFswflWyNeVUtki8jSALKXURgCvAVgjIvk4f8a+zJZFExHRxVnUWqKU2gRgU5+vPdHr8w4AN1u3tCGx+lCPTvE4WY7HyjI8TpYZ8eOk2QxVIiKyHadf8peISI8cMtxFJFhEvhCR0z1/Bg2wnUlEjvR89L0IrFsislBEckUkX0Qe6+d5DxFZ3/P8PhFJHPkqtWfBcbpbRKp7vYdWaFGn1kTkdRGpEpETAzwvIvJcz3E8JiJTR7pGe2DBcZonIo293k9P9LedtThkuAN4DMA2pVQKgG09j/vTrpSa3POxeOTK006v5SKuA5AGYLmI9J3n/M1yEQD+hvPLRTgVC48TAKzv9R56dUSLtB9vAlh4keevA5DS87ESwIsjUJM9ehMXP04A8FWv99PTtizGUcN9CYC3ej5/C8D3NKzF3nyzXIRSqgvAheUieut9/DYAmC/2thi17VlynAiAUmon+pm30ssSAKvVeXsBBIpI1MhUZz8sOE4jylHDPUIpdQ4Aev4MH2A7TxHJEpG9IuIsPwD6Wy4iZqBtlFJGABeWi3AmlhwnALipZ6hhg4jE9fM8WX4sCZglIkdF5DMRSbfljux2lS0R2Qogsp+nfjWEl4lXSpWLSDKA7SJyXCl1xjoV2i2rLRehc5Ycg48BrFVKdYrIj3D+t52rbF6Z4+H7yTKHACQopVpEZBGAD3F+KMsm7DbclVJXD/SciFSKSJRS6lzPr39VA7xGec+fBSLyJYApAPQe7lZbLkLnBj1OSqnaXg//CSe8NmEhS95zTk8p1dTr800i8g8RCVVK2WRtHkcdlum93MEPAXzUdwMRCeq5iQhEJBTAbHx7mWK94nIRlhn0OPUZN14M4NQI1udINgK4q6drZiaAxgvDpvS/RCTywrUtEZmO8/lbe/G/dens9sx9EM8AeE9E7gNQjJ7ZsSKSCeBHSqkVAMYBeFlEzDh/EJ/pc4MRXeJyEZax8Dg9LCKLARhx/jjdrVnBGhKRtQDmAQgVkVIATwJwAwCl1Es4P3t9EYB8AG0A7tGmUm1ZcJyWAnhQRIwA2gEss+VJFWeoEhHpkKMOyxAR0UUw3ImIdIjhTkSkQwx3IiIdYrgTEekQw52ISIcY7kREOsRwJyLSof8PzuBecCum9P8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(gwbr_model.y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multi_bw changes" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def multi_bw(init,coords,y, X, n, k, family=Gaussian(),offset=None, tol=1e-06, max_iter=20, multi_bw_min=[None], multi_bw_max=[None],rss_score=True,bws_same_times=3,\n", + " verbose=True):\n", + "\n", + "\n", + " if multi_bw_min==[None]:\n", + " multi_bw_min = multi_bw_min*X.shape[1]\n", + " \n", + " if multi_bw_max==[None]:\n", + " multi_bw_max = multi_bw_max*X.shape[1]\n", + " \n", + " if isinstance(family,spglm.family.Poisson):\n", + " bw = sel_func(bw_func_p(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw,family=Poisson(),offset=offset)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " #This change for the Poisson model follows from equation (1) above\n", + " XB = offset*np.exp(np.multiply(param, X))\n", + " \n", + " \n", + " elif isinstance(family,spglm.family.Binomial):\n", + " bw = sel_func(bw_func_b(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw,family=Binomial())\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " XB = 1/(1+np.exp(-1*np.multiply(optim_model.params,X)))\n", + " print(\"first family: \"+str(optim_model.family))\n", + " \n", + " else:\n", + " bw=sel_func(bw_func(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " XB = np.multiply(param, X)\n", + " \n", + " bw_gwr = bw\n", + " XB=XB\n", + " \n", + " if rss_score:\n", + " rss = np.sum((err)**2)\n", + " iters = 0\n", + " scores = []\n", + " delta = 1e6\n", + " BWs = []\n", + " bw_stable_counter = np.ones(k)\n", + " bws = np.empty(k)\n", + "\n", + " try:\n", + " from tqdm.auto import tqdm #if they have it, let users have a progress bar\n", + " except ImportError:\n", + "\n", + " def tqdm(x, desc=''): #otherwise, just passthrough the range\n", + " return x\n", + "\n", + " for iters in tqdm(range(1, max_iter + 1), desc='Backfitting'):\n", + " new_XB = np.zeros_like(X)\n", + " neww_XB = np.zeros_like(X)\n", + "\n", + " params = np.zeros_like(X)\n", + "\n", + " for j in range(k):\n", + " temp_y = XB[:, j].reshape((-1, 1))\n", + " temp_y = temp_y + err\n", + " \n", + " temp_X = X[:, j].reshape((-1, 1))\n", + " \n", + " #The step below will not be necessary once the bw_func is changed in the repo to accept family and offset as attributes\n", + " if isinstance(family,spglm.family.Poisson):\n", + "\n", + " bw_class = bw_func_p(coords,temp_y, temp_X)\n", + " \n", + " else:\n", + " bw_class = bw_func(coords,temp_y, temp_X)\n", + " print(bw_class.family)\n", + "\n", + " if np.all(bw_stable_counter == bws_same_times):\n", + " #If in backfitting, all bws not changing in bws_same_times (default 3) iterations\n", + " bw = bws[j]\n", + " else:\n", + " bw = sel_func(bw_class, multi_bw_min[j], multi_bw_max[j])\n", + " if bw == bws[j]:\n", + " bw_stable_counter[j] += 1\n", + " else:\n", + " bw_stable_counter = np.ones(k)\n", + "\n", + " optim_model = gwr_func_g(temp_y, temp_X, bw)\n", + " print(optim_model.family)\n", + " \n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params.reshape((-1, ))\n", + "\n", + " new_XB[:,j]=optim_model.predy.reshape(-1)\n", + " params[:, j] = param\n", + " bws[j] = bw\n", + "\n", + " num = np.sum((new_XB - XB)**2) / n\n", + " print(\"num = \"+str(num))\n", + " den = np.sum(np.sum(new_XB, axis=1)**2)\n", + " score = (num / den)**0.5\n", + " print(score)\n", + " XB = new_XB\n", + "\n", + " if rss_score:\n", + " print(\"here\")\n", + " predy = 1/(1+np.exp(-1*np.sum(X * params, axis=1).reshape(-1, 1)))\n", + " new_rss = np.sum((y - predy)**2)\n", + " score = np.abs((new_rss - rss) / new_rss)\n", + " rss = new_rss\n", + " scores.append(deepcopy(score))\n", + " delta = score\n", + " print(delta)\n", + " BWs.append(deepcopy(bws))\n", + "\n", + " if verbose:\n", + " print(\"Current iteration:\", iters, \",SOC:\", np.round(score, 7))\n", + " print(\"Bandwidths:\", ', '.join([str(bw) for bw in bws]))\n", + "\n", + " if delta < tol:\n", + " break\n", + " \n", + " print(\"iters = \"+str(iters))\n", + " opt_bws = BWs[-1]\n", + " print(\"opt_bws = \"+str(opt_bws))\n", + " print(bw_gwr)\n", + " return (opt_bws, np.array(BWs), np.array(scores), params, err, bw_gwr)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first family: \n", + "\n", + "\n", + "num = 0.2261860620412264\n", + "0.1493438159109546\n", + "here\n", + "0.019261197296944955\n", + "Current iteration: 1 ,SOC: 0.0192612\n", + "Bandwidths: 82.0\n", + "\n", + "\n", + "num = 0.0\n", + "0.0\n", + "here\n", + "0.0\n", + "Current iteration: 2 ,SOC: 0.0\n", + "Bandwidths: 82.0\n", + "iters = 2\n", + "opt_bws = [82.]\n", + "100.0\n" + ] + } + ], + "source": [ + "mgwbr = multi_bw(init=None,coords=coords,y=y, X=x_std, n=239, k=x.shape[1], family=Binomial())" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "param = mgwbr[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "predy = 1/(1+np.exp(-1*np.sum(x_std * param, axis=1).reshape(-1, 1)))" + ] + }, + { + "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(predy)" + ] + } + ], + "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 new file mode 100644 index 0000000..e0d84b0 --- /dev/null +++ b/notebooks/Binomial_MGWR_univariate_check.ipynb @@ -0,0 +1,1160 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "https://github.com/pysal/mgwr/pull/56" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from mgwr.gwr import GWR\n", + "from spglm.family import Gaussian, Binomial, Poisson\n", + "from mgwr.gwr import MGWR\n", + "from mgwr.sel_bw import Sel_BW\n", + "import multiprocessing as mp\n", + "pool = mp.Pool()\n", + "from scipy import linalg\n", + "import numpy.linalg as la\n", + "from scipy import sparse as sp\n", + "from scipy.sparse import linalg as spla\n", + "from spreg.utils import spdot, spmultiply\n", + "from scipy import special\n", + "import libpysal as ps\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "import copy\n", + "from collections import namedtuple\n", + "import spglm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Fundamental equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By simple algebraic manipulation, the probability that Y=1 is:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{align}\n", + "p = 1 / (1 + exp (-{\\beta} & _k x _{k,i}) ) (1) \\\\\n", + "\\end{align}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Clearwater data - downloaded from link: https://sgsup.asu.edu/sparc/multiscale-gwr" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "data_p = pd.read_csv(\"C:/Users/msachde1/Downloads/logistic_mgwr_data/landslides.csv\") " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
UserIDXYElevSlopeSinAspctCosAspctAbsSouthLandslidDistStrm
01616168.56255201076.51450.47527.441720.409126-0.91247824.149918.506
12624923.81255201008.51567.47621.88343-0.919245-0.39368566.8160115.561
23615672.00005199187.51515.06538.81030-0.535024-0.84483732.3455141.238
34615209.31255199112.01459.82726.71631-0.828548-0.55991855.9499117.539
45616354.68755198945.51379.44227.55271-0.872281-0.48900560.7248135.023
\n", + "
" + ], + "text/plain": [ + " UserID X Y Elev Slope SinAspct CosAspct \\\n", + "0 1 616168.5625 5201076.5 1450.475 27.44172 0.409126 -0.912478 \n", + "1 2 624923.8125 5201008.5 1567.476 21.88343 -0.919245 -0.393685 \n", + "2 3 615672.0000 5199187.5 1515.065 38.81030 -0.535024 -0.844837 \n", + "3 4 615209.3125 5199112.0 1459.827 26.71631 -0.828548 -0.559918 \n", + "4 5 616354.6875 5198945.5 1379.442 27.55271 -0.872281 -0.489005 \n", + "\n", + " AbsSouth Landslid DistStrm \n", + "0 24.1499 1 8.506 \n", + "1 66.8160 1 15.561 \n", + "2 32.3455 1 41.238 \n", + "3 55.9499 1 17.539 \n", + "4 60.7248 1 35.023 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_p.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "coords = list(zip(data_p['X'],data_p['Y']))\n", + "y = np.array(data_p['Landslid']).reshape((-1,1)) \n", + "elev = np.array(data_p['Elev']).reshape((-1,1))\n", + "slope = np.array(data_p['Slope']).reshape((-1,1))\n", + "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", + "\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", + "y_std = (y-y.mean(axis=0))/y.std(axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Helper functions - hardcoded here for simplicity in the notebook workflow\n", + "Please note: A separate bw_func_b will not be required when changes will be made in the repository" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "kernel='bisquare'\n", + "fixed=False\n", + "spherical=False\n", + "search_method='golden_section'\n", + "criterion='AICc'\n", + "interval=None\n", + "tol=1e-06\n", + "max_iter=200\n", + "X_glob=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def gwr_func(y, X, bw,family=Gaussian(),offset=None):\n", + " return GWR(coords, y, X, bw, family,offset,kernel=kernel,\n", + " fixed=fixed, constant=False,\n", + " spherical=spherical, hat_matrix=False).fit(\n", + " lite=True, pool=pool)\n", + "\n", + "\n", + "def bw_func_b(coords,y, X):\n", + " selector = Sel_BW(coords,y, X,family=Binomial(),offset=None, X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def bw_func_p(coords,y, X):\n", + " selector = Sel_BW(coords,y, X,family=Poisson(),offset=off, X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def bw_func(coords,y,X):\n", + " selector = Sel_BW(coords,y,X,X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def sel_func(bw_func, bw_min=None, bw_max=None):\n", + " return bw_func.search(\n", + " search_method=search_method, criterion=criterion,\n", + " bw_min=bw_min, bw_max=bw_max, interval=interval, tol=tol,\n", + " max_iter=max_iter, pool=pool, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GWR Binomial model with independent variable, x = slope" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "bw_gwbr=Sel_BW(coords,y_std,x_std,family=Binomial(),constant=False).search()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "gwbr_model=GWR(coords,y_std,x_std,bw=bw_gwbr,family=Binomial(),constant=False).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "235.0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw_gwbr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MGWR Binomial loop with one independent variable, x = slope" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Edited multi_bw function - original function in https://github.com/pysal/mgwr/blob/master/mgwr/search.py#L167" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def multi_bw(init,coords,y, X, n, k, family=Gaussian(),offset=None, tol=1e-06, max_iter=200, multi_bw_min=[None], multi_bw_max=[None],rss_score=False,bws_same_times=3,\n", + " verbose=False):\n", + " \n", + " if multi_bw_min==[None]:\n", + " multi_bw_min = multi_bw_min*X.shape[1]\n", + " \n", + " if multi_bw_max==[None]:\n", + " multi_bw_max = multi_bw_max*X.shape[1]\n", + " \n", + " if isinstance(family,spglm.family.Poisson):\n", + " bw = sel_func(bw_func_p(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw,family=Poisson(),offset=offset)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " #This change for the Poisson model follows from equation (1) above\n", + " XB = offset*np.exp(np.multiply(param, X))\n", + " \n", + " elif isinstance(family,spglm.family.Binomial):\n", + " bw = sel_func(bw_func_b(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw,family=Binomial())\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " #This change for the Binomial model follows from equation above\n", + " XB = 1/(1+np.exp(-1*np.multiply(optim_model.params,X)))\n", + " #print(XB)\n", + "\n", + " \n", + " else:\n", + " bw=sel_func(bw_func(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " XB = np.multiply(param, X)\n", + " \n", + " bw_gwr = bw\n", + " XB=XB\n", + " \n", + " if rss_score:\n", + " rss = np.sum((err)**2)\n", + " iters = 0\n", + " scores = []\n", + " delta = 1e6\n", + " BWs = []\n", + " bw_stable_counter = np.ones(k)\n", + " bws = np.empty(k)\n", + "\n", + " try:\n", + " from tqdm.auto import tqdm #if they have it, let users have a progress bar\n", + " except ImportError:\n", + "\n", + " def tqdm(x, desc=''): #otherwise, just passthrough the range\n", + " return x\n", + "\n", + " for iters in tqdm(range(1, max_iter + 1), desc='Backfitting'):\n", + " new_XB = np.zeros_like(X)\n", + " params = np.zeros_like(X)\n", + "\n", + " for j in range(k):\n", + " temp_y = XB[:, j].reshape((-1, 1))\n", + " temp_y = temp_y + err\n", + " temp_X = X[:, j].reshape((-1, 1))\n", + " \n", + " #The step below will not be necessary once the bw_func is changed in the repo to accept family and offset as attributes\n", + " if isinstance(family,spglm.family.Poisson):\n", + "\n", + " bw_class = bw_func_p(coords,temp_y, temp_X)\n", + " \n", + " elif isinstance(family,spglm.family.Binomial):\n", + " \n", + " bw_class = bw_func_b(coords,temp_y, temp_X)\n", + "\n", + "\n", + " \n", + " else:\n", + " bw_class = bw_func(coords,temp_y, temp_X)\n", + "\n", + "\n", + " if np.all(bw_stable_counter == bws_same_times):\n", + " #If in backfitting, all bws not changing in bws_same_times (default 3) iterations\n", + " bw = bws[j]\n", + " else:\n", + " bw = sel_func(bw_class, multi_bw_min[j], multi_bw_max[j])\n", + " if bw == bws[j]:\n", + " bw_stable_counter[j] += 1\n", + " else:\n", + " bw_stable_counter = np.ones(k)\n", + "\n", + " #Changed gwr_func to accept family and offset as attributes\n", + " optim_model = gwr_func(temp_y, temp_X, bw,family,offset)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params.reshape((-1, ))\n", + " new_XB[:, j] = optim_model.predy.reshape(-1)\n", + " params[:, j] = param\n", + " bws[j] = bw\n", + "\n", + " num = np.sum((new_XB - XB)**2) / n\n", + " den = np.sum(np.sum(new_XB, axis=1)**2)\n", + " score = (num / den)**0.5\n", + " XB = new_XB\n", + "\n", + " if rss_score:\n", + " predy = np.sum(np.multiply(params, X), axis=1).reshape((-1, 1))\n", + " new_rss = np.sum((y - predy)**2)\n", + " score = np.abs((new_rss - rss) / new_rss)\n", + " rss = new_rss\n", + " scores.append(deepcopy(score))\n", + " delta = score\n", + " BWs.append(deepcopy(bws))\n", + "\n", + " if verbose:\n", + " print(\"Current iteration:\", iters, \",SOC:\", np.round(score, 7))\n", + " print(\"Bandwidths:\", ', '.join([str(bw) for bw in bws]))\n", + "\n", + " if delta < tol:\n", + " break\n", + " \n", + " print(\"iters = \"+str(iters))\n", + " opt_bws = BWs[-1]\n", + " print(\"opt_bws = \"+str(opt_bws))\n", + " return (opt_bws, np.array(BWs), np.array(scores), params, err, bw_gwr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Running the function with family = Binomial()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "here\n", + "iters = 1\n", + "opt_bws = [235.]\n" + ] + } + ], + "source": [ + "bw_mgwbr = multi_bw(init=None,coords=coords,y=y_std, X=x_std, n=239, k=x.shape[1], family=Binomial())" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([235.]), array([[235.]]), array([6.30119852e-18]), array([[-0.50162668],\n", + " [-0.50579495],\n", + " [-0.5009641 ],\n", + " [-0.50208058],\n", + " [-0.49536418],\n", + " [-0.50809538],\n", + " [-0.4853955 ],\n", + " [-0.49949875],\n", + " [-0.49974347],\n", + " [-0.50030985],\n", + " [-0.48398055],\n", + " [-0.48413828],\n", + " [-0.49259636],\n", + " [-0.48373625],\n", + " [-0.57440075],\n", + " [-0.55847694],\n", + " [-0.50233966],\n", + " [-0.47313647],\n", + " [-0.50921201],\n", + " [-0.57617062],\n", + " [-0.61195324],\n", + " [-0.54159058],\n", + " [-0.58434527],\n", + " [-0.58149828],\n", + " [-0.50533145],\n", + " [-0.50856601],\n", + " [-0.51325344],\n", + " [-0.58351236],\n", + " [-0.59746032],\n", + " [-0.47098322],\n", + " [-0.61692044],\n", + " [-0.55422262],\n", + " [-0.5388478 ],\n", + " [-0.53263404],\n", + " [-0.53153951],\n", + " [-0.52267724],\n", + " [-0.59592076],\n", + " [-0.57660501],\n", + " [-0.59318783],\n", + " [-0.60579886],\n", + " [-0.51294826],\n", + " [-0.5113788 ],\n", + " [-0.53976137],\n", + " [-0.54297624],\n", + " [-0.53952562],\n", + " [-0.54538527],\n", + " [-0.54001321],\n", + " [-0.50661058],\n", + " [-0.50416192],\n", + " [-0.51150675],\n", + " [-0.58222597],\n", + " [-0.65472344],\n", + " [-0.50323678],\n", + " [-0.51045941],\n", + " [-0.49541628],\n", + " [-0.50812033],\n", + " [-0.5045734 ],\n", + " [-0.48846882],\n", + " [-0.64593964],\n", + " [-0.64639923],\n", + " [-0.5873994 ],\n", + " [-0.6118988 ],\n", + " [-0.61247772],\n", + " [-0.61195408],\n", + " [-0.61252053],\n", + " [-0.61351723],\n", + " [-0.61376775],\n", + " [-0.50021178],\n", + " [-0.50030925],\n", + " [-0.520556 ],\n", + " [-0.60257245],\n", + " [-0.60434035],\n", + " [-0.48795221],\n", + " [-0.52474021],\n", + " [-0.52883104],\n", + " [-0.52417453],\n", + " [-0.52369372],\n", + " [-0.48652049],\n", + " [-0.50992728],\n", + " [-0.50330024],\n", + " [-0.50389375],\n", + " [-0.58790106],\n", + " [-0.6461279 ],\n", + " [-0.57837391],\n", + " [-0.5706227 ],\n", + " [-0.56711251],\n", + " [-0.58798405],\n", + " [-0.5878962 ],\n", + " [-0.55764189],\n", + " [-0.61177538],\n", + " [-0.60753747],\n", + " [-0.60306586],\n", + " [-0.55438512],\n", + " [-0.5236934 ],\n", + " [-0.5007593 ],\n", + " [-0.49381687],\n", + " [-0.49511583],\n", + " [-0.51853197],\n", + " [-0.49961788],\n", + " [-0.57284769],\n", + " [-0.56564421],\n", + " [-0.56259463],\n", + " [-0.5832299 ],\n", + " [-0.56941476],\n", + " [-0.62172386],\n", + " [-0.59982648],\n", + " [-0.59396042],\n", + " [-0.60749722],\n", + " [-0.6053944 ],\n", + " [-0.65456469],\n", + " [-0.65488097],\n", + " [-0.6544558 ],\n", + " [-0.65018448],\n", + " [-0.6502449 ],\n", + " [-0.6501103 ],\n", + " [-0.65079445],\n", + " [-0.6459635 ],\n", + " [-0.6474695 ],\n", + " [-0.67067724],\n", + " [-0.56699725],\n", + " [-0.56575062],\n", + " [-0.5662022 ],\n", + " [-0.50522358],\n", + " [-0.49118299],\n", + " [-0.51810571],\n", + " [-0.60437077],\n", + " [-0.54522489],\n", + " [-0.50199315],\n", + " [-0.5764369 ],\n", + " [-0.57417465],\n", + " [-0.54422143],\n", + " [-0.48028202],\n", + " [-0.48243379],\n", + " [-0.50259763],\n", + " [-0.50106093],\n", + " [-0.50073298],\n", + " [-0.53682547],\n", + " [-0.55374154],\n", + " [-0.63515491],\n", + " [-0.49264444],\n", + " [-0.65928688],\n", + " [-0.66587164],\n", + " [-0.54824281],\n", + " [-0.56684771],\n", + " [-0.5154442 ],\n", + " [-0.50998827],\n", + " [-0.48655246],\n", + " [-0.6116885 ],\n", + " [-0.52715459],\n", + " [-0.58303947],\n", + " [-0.51254857],\n", + " [-0.59508138],\n", + " [-0.52508374],\n", + " [-0.48638727],\n", + " [-0.57311434],\n", + " [-0.48276036],\n", + " [-0.58519914],\n", + " [-0.56853571],\n", + " [-0.50046431],\n", + " [-0.52710603],\n", + " [-0.64416489],\n", + " [-0.64575535],\n", + " [-0.57468226],\n", + " [-0.64014701],\n", + " [-0.51447122],\n", + " [-0.55361224],\n", + " [-0.51632938],\n", + " [-0.58235398],\n", + " [-0.57229934],\n", + " [-0.54291022],\n", + " [-0.5843499 ],\n", + " [-0.6396942 ],\n", + " [-0.54525607],\n", + " [-0.61197265],\n", + " [-0.5880856 ],\n", + " [-0.47829365],\n", + " [-0.55198933],\n", + " [-0.50853952],\n", + " [-0.51035675],\n", + " [-0.63932996],\n", + " [-0.52477839],\n", + " [-0.55266949],\n", + " [-0.62846196],\n", + " [-0.55153547],\n", + " [-0.48711099],\n", + " [-0.60712317],\n", + " [-0.58356933],\n", + " [-0.5070068 ],\n", + " [-0.60213329],\n", + " [-0.60846734],\n", + " [-0.61292924],\n", + " [-0.53490376],\n", + " [-0.47500022],\n", + " [-0.52456535],\n", + " [-0.52170511],\n", + " [-0.56676546],\n", + " [-0.56862029],\n", + " [-0.55615123],\n", + " [-0.5052756 ],\n", + " [-0.61703825],\n", + " [-0.58117158],\n", + " [-0.62450409],\n", + " [-0.50193804],\n", + " [-0.61634617],\n", + " [-0.52808561],\n", + " [-0.64539463],\n", + " [-0.55676761],\n", + " [-0.51915393],\n", + " [-0.59047998],\n", + " [-0.52630813],\n", + " [-0.65614561],\n", + " [-0.54472627],\n", + " [-0.58033092],\n", + " [-0.4982667 ],\n", + " [-0.63191874],\n", + " [-0.65814127],\n", + " [-0.60122561],\n", + " [-0.60093234],\n", + " [-0.52646795],\n", + " [-0.57150567],\n", + " [-0.52434229],\n", + " [-0.61977644],\n", + " [-0.52205774],\n", + " [-0.47826181],\n", + " [-0.49064864],\n", + " [-0.51282297],\n", + " [-0.64026819],\n", + " [-0.5672968 ],\n", + " [-0.55102685],\n", + " [-0.51960286],\n", + " [-0.6012776 ],\n", + " [-0.54353722],\n", + " [-0.49165576],\n", + " [-0.6133591 ],\n", + " [-0.51984449],\n", + " [-0.50390647],\n", + " [-0.5999121 ],\n", + " [-0.51732227],\n", + " [-0.52151524]]), array([[ 0.45031024],\n", + " [ 0.49604843],\n", + " [ 0.47504854],\n", + " [ 0.45403453],\n", + " [ 0.4215429 ],\n", + " [ 0.46183891],\n", + " [ 0.33932814],\n", + " [ 0.47460185],\n", + " [ 0.43653338],\n", + " [ 0.40603358],\n", + " [ 0.43167116],\n", + " [ 0.43701201],\n", + " [ 0.52675256],\n", + " [ 0.334331 ],\n", + " [ 0.51435897],\n", + " [ 0.3053954 ],\n", + " [ 0.43054904],\n", + " [ 0.2623979 ],\n", + " [ 0.45694021],\n", + " [ 0.13654226],\n", + " [ 0.09246393],\n", + " [ 0.24236477],\n", + " [ 0.14448191],\n", + " [ 0.0963041 ],\n", + " [ 0.17162991],\n", + " [ 0.22310146],\n", + " [ 0.31888604],\n", + " [ 0.08659607],\n", + " [ 0.32745944],\n", + " [ 0.27224757],\n", + " [ 0.3859315 ],\n", + " [ 0.34589613],\n", + " [ 0.26773825],\n", + " [ 0.28868253],\n", + " [ 0.30326734],\n", + " [ 0.32742759],\n", + " [ 0.19277132],\n", + " [ 0.1278229 ],\n", + " [ 0.13457933],\n", + " [ 0.37372086],\n", + " [ 0.27600742],\n", + " [ 0.33273349],\n", + " [ 0.31755073],\n", + " [ 0.35349303],\n", + " [ 0.30045255],\n", + " [ 0.26457078],\n", + " [ 0.3024146 ],\n", + " [ 0.20023058],\n", + " [ 0.23390638],\n", + " [ 0.26727188],\n", + " [ 0.37837202],\n", + " [ 0.45238338],\n", + " [ 0.31804961],\n", + " [ 0.35722213],\n", + " [ 0.36795831],\n", + " [ 0.37000182],\n", + " [ 0.2545264 ],\n", + " [ 0.36362392],\n", + " [ 0.4190397 ],\n", + " [ 0.39338513],\n", + " [ 0.19118445],\n", + " [ 0.10689354],\n", + " [ 0.07336121],\n", + " [ 0.10498226],\n", + " [ 0.08680491],\n", + " [ 0.11189461],\n", + " [ 0.1349893 ],\n", + " [ 0.31624951],\n", + " [ 0.19053904],\n", + " [ 0.20325235],\n", + " [ 0.19904361],\n", + " [ 0.1902473 ],\n", + " [ 0.28803362],\n", + " [ 0.22648834],\n", + " [ 0.27851139],\n", + " [ 0.21843995],\n", + " [ 0.21556676],\n", + " [ 0.47881589],\n", + " [ 0.45000109],\n", + " [ 0.43822284],\n", + " [ 0.49934519],\n", + " [ 0.49140914],\n", + " [ 0.38122889],\n", + " [ 0.12566529],\n", + " [ 0.30699577],\n", + " [ 0.2414741 ],\n", + " [ 0.19116142],\n", + " [ 0.20340448],\n", + " [ 0.27614553],\n", + " [ 0.1581619 ],\n", + " [ 0.22784066],\n", + " [ 0.26464982],\n", + " [ 0.16997955],\n", + " [ 0.38154019],\n", + " [ 0.41582019],\n", + " [ 0.38272415],\n", + " [ 0.37350927],\n", + " [ 0.24602357],\n", + " [ 0.21334332],\n", + " [ 0.22102301],\n", + " [ 0.40153118],\n", + " [ 0.34208383],\n", + " [ 0.29045806],\n", + " [ 0.24177596],\n", + " [ 0.41218824],\n", + " [ 0.31635339],\n", + " [ 0.4034071 ],\n", + " [ 0.21282194],\n", + " [ 0.1541137 ],\n", + " [ 0.42494689],\n", + " [ 0.42461165],\n", + " [ 0.4765204 ],\n", + " [ 0.39295313],\n", + " [ 0.38466861],\n", + " [ 0.39146973],\n", + " [ 0.46130277],\n", + " [ 0.32244738],\n", + " [ 0.38031154],\n", + " [ 0.44348457],\n", + " [ 0.47246158],\n", + " [ 0.48981853],\n", + " [ 0.5064532 ],\n", + " [ 0.41460868],\n", + " [ 0.25113815],\n", + " [ 0.29404699],\n", + " [ 0.19677541],\n", + " [ 0.44075007],\n", + " [ 0.25452405],\n", + " [ 0.33709288],\n", + " [ 0.26728236],\n", + " [ 0.49675747],\n", + " [ 0.24086762],\n", + " [ 0.3407801 ],\n", + " [ 0.41968045],\n", + " [ 0.44217573],\n", + " [ 0.45262285],\n", + " [ 0.43362456],\n", + " [ 0.35312939],\n", + " [-1.74194827],\n", + " [-1.8782295 ],\n", + " [-1.43691145],\n", + " [-1.48002428],\n", + " [-1.73572846],\n", + " [-1.64049088],\n", + " [-1.70961543],\n", + " [-1.77537159],\n", + " [-1.71601925],\n", + " [-1.61792894],\n", + " [-1.65557947],\n", + " [-1.57748516],\n", + " [-1.70827071],\n", + " [-1.47710386],\n", + " [-1.87849297],\n", + " [-1.68826406],\n", + " [-1.86518335],\n", + " [-1.4519699 ],\n", + " [-1.41393778],\n", + " [-1.87613884],\n", + " [-1.60592175],\n", + " [-1.88969651],\n", + " [-1.40115795],\n", + " [-1.50170581],\n", + " [-1.57285995],\n", + " [-1.39156065],\n", + " [-1.70276004],\n", + " [-1.68630848],\n", + " [-1.77771365],\n", + " [-1.64419835],\n", + " [-1.58008387],\n", + " [-1.67159209],\n", + " [-1.6892239 ],\n", + " [-1.54817831],\n", + " [-1.42752186],\n", + " [-1.53276248],\n", + " [-1.50462734],\n", + " [-1.60613558],\n", + " [-1.75384715],\n", + " [-1.6184391 ],\n", + " [-1.50406687],\n", + " [-1.46529525],\n", + " [-1.83177244],\n", + " [-1.65497757],\n", + " [-1.49798552],\n", + " [-1.52024496],\n", + " [-1.67996552],\n", + " [-1.60225243],\n", + " [-1.63919227],\n", + " [-1.79614582],\n", + " [-1.4540713 ],\n", + " [-1.62836624],\n", + " [-1.58332682],\n", + " [-1.6277436 ],\n", + " [-1.71807618],\n", + " [-1.4038076 ],\n", + " [-1.69266606],\n", + " [-1.73470198],\n", + " [-1.68627215],\n", + " [-1.51615083],\n", + " [-1.79883451],\n", + " [-1.39468716],\n", + " [-1.76092102],\n", + " [-1.63634511],\n", + " [-1.80978027],\n", + " [-1.35261006],\n", + " [-1.78643044],\n", + " [-1.42036149],\n", + " [-1.52553444],\n", + " [-1.55391705],\n", + " [-1.44926518],\n", + " [-1.58932542],\n", + " [-1.5075396 ],\n", + " [-1.59362734],\n", + " [-1.77740513],\n", + " [-1.53606879],\n", + " [-1.49876255],\n", + " [-1.37830312],\n", + " [-1.57005654],\n", + " [-1.66799355],\n", + " [-1.70114239],\n", + " [-1.38343149],\n", + " [-1.82222543],\n", + " [-1.45194331],\n", + " [-1.6988142 ],\n", + " [-1.75244203],\n", + " [-1.60027711],\n", + " [-1.6650667 ],\n", + " [-1.41687276],\n", + " [-1.73583175],\n", + " [-1.63872057],\n", + " [-1.45459415],\n", + " [-1.37092133],\n", + " [-1.66690238],\n", + " [-1.47219282],\n", + " [-1.60876858],\n", + " [-1.45964275],\n", + " [-1.77517727],\n", + " [-1.55829329],\n", + " [-1.71452787],\n", + " [-1.73675916]]), 235.0)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw_mgwbr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Running without family and offset attributes runs the normal MGWR loop" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iters = 1\n", + "opt_bws = [125.]\n" + ] + } + ], + "source": [ + "bw_mgwr = multi_bw(init=None, coords=coords,y=y_std, X=x_std, n=262, k=x.shape[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Difference in parameters from the GWR - Binomial model and MGWR Binomial model" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(bw_mgwbr[3]==gwbr_model.params).all()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are identical" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Banwidths" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "235.0" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw_gwbr" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([235.])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw_mgwbr[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The bandwidth from both models is the same" + ] + } + ], + "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/Poisson_MC_script/f_2.py b/notebooks/Poisson_MC_script/f_2.py new file mode 100644 index 0000000..25f37fa --- /dev/null +++ b/notebooks/Poisson_MC_script/f_2.py @@ -0,0 +1,115 @@ +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/120)*(a+b)) + +def con(u,v): + return (0*(u)*(v))+0.3 + +def sp(u,v): + return 1+1/3240*(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).reshape(-1, 1))) + y_new = np.random.poisson(y_raw) + + 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=Poisson(),offset=None) + bw=bw.search() + s.gwr_bw.append(bw) + gwr_model=GWR(coords,y,X1,bw,family=Poisson(),offset=None).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=Poisson(),offset=None) + selector.search() + s.mgwr_bw.append(selector.bw[0]) + mgwr_model=MGWR(coords,y,X1,selector,family=Poisson(),offset=None).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/Poisson_MC_script/main_mc.py b/notebooks/Poisson_MC_script/main_mc.py new file mode 100644 index 0000000..68795ea --- /dev/null +++ b/notebooks/Poisson_MC_script/main_mc.py @@ -0,0 +1,24 @@ +from multiprocessing import Process, Queue +import multiprocessing as mp + + +import f_2 +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(f_2.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/Poisson_MC_script/pkls/results-0-50.pkl b/notebooks/Poisson_MC_script/pkls/results-0-50.pkl new file mode 100644 index 0000000..d88e04e Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-0-50.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-100-150.pkl b/notebooks/Poisson_MC_script/pkls/results-100-150.pkl new file mode 100644 index 0000000..d2d2554 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-100-150.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-150-200.pkl b/notebooks/Poisson_MC_script/pkls/results-150-200.pkl new file mode 100644 index 0000000..486b5b3 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-150-200.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-200-250.pkl b/notebooks/Poisson_MC_script/pkls/results-200-250.pkl new file mode 100644 index 0000000..60b7f3f Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-200-250.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-250-300.pkl b/notebooks/Poisson_MC_script/pkls/results-250-300.pkl new file mode 100644 index 0000000..3b75957 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-250-300.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-300-350.pkl b/notebooks/Poisson_MC_script/pkls/results-300-350.pkl new file mode 100644 index 0000000..f160846 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-300-350.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-350-400.pkl b/notebooks/Poisson_MC_script/pkls/results-350-400.pkl new file mode 100644 index 0000000..0b0764c Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-350-400.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-400-450.pkl b/notebooks/Poisson_MC_script/pkls/results-400-450.pkl new file mode 100644 index 0000000..c54a73e Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-400-450.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-450-500.pkl b/notebooks/Poisson_MC_script/pkls/results-450-500.pkl new file mode 100644 index 0000000..b2ec353 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-450-500.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-50-100.pkl b/notebooks/Poisson_MC_script/pkls/results-50-100.pkl new file mode 100644 index 0000000..9baa620 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-50-100.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-500-550.pkl b/notebooks/Poisson_MC_script/pkls/results-500-550.pkl new file mode 100644 index 0000000..5063f3a Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-500-550.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-550-600.pkl b/notebooks/Poisson_MC_script/pkls/results-550-600.pkl new file mode 100644 index 0000000..59eab90 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-550-600.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-600-650.pkl b/notebooks/Poisson_MC_script/pkls/results-600-650.pkl new file mode 100644 index 0000000..c626eee Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-600-650.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-650-700.pkl b/notebooks/Poisson_MC_script/pkls/results-650-700.pkl new file mode 100644 index 0000000..81c2f6b Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-650-700.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-700-750.pkl b/notebooks/Poisson_MC_script/pkls/results-700-750.pkl new file mode 100644 index 0000000..39d7f87 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-700-750.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-750-800.pkl b/notebooks/Poisson_MC_script/pkls/results-750-800.pkl new file mode 100644 index 0000000..b61350b Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-750-800.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-800-850.pkl b/notebooks/Poisson_MC_script/pkls/results-800-850.pkl new file mode 100644 index 0000000..6defbd3 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-800-850.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-850-900.pkl b/notebooks/Poisson_MC_script/pkls/results-850-900.pkl new file mode 100644 index 0000000..1e806d6 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-850-900.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-900-950.pkl b/notebooks/Poisson_MC_script/pkls/results-900-950.pkl new file mode 100644 index 0000000..7d0e448 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-900-950.pkl differ diff --git a/notebooks/Poisson_MC_script/pkls/results-950-1000.pkl b/notebooks/Poisson_MC_script/pkls/results-950-1000.pkl new file mode 100644 index 0000000..b3e5549 Binary files /dev/null and b/notebooks/Poisson_MC_script/pkls/results-950-1000.pkl differ diff --git a/notebooks/Poisson_MGWR.ipynb b/notebooks/Poisson_MGWR.ipynb new file mode 100644 index 0000000..e327427 --- /dev/null +++ b/notebooks/Poisson_MGWR.ipynb @@ -0,0 +1,153 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiscale Geographically Weighted Regression - Poisson 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 Poisson 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 Poisson 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", + "- [Tokyo Mortality 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": [ + "---\n", + "\n", + "# Introduction\n", + "\n", + "## Introduction to the project\n", + "\n", + "A recent addition to the local statistical models in PySAL is the implementation of Multiscale Geographically Weighted Regression (MGWR) model, a multiscale extension to the widely used approach for modeling process spatial heterogeneity - Geographically Weighted Regression (GWR). GWR is a local spatial multivariate statistical modeling technique embedded within the regression framework that is calibrated and estimates covariate parameters at each location using borrowed data from neighboring observations. The extent of neighboring observations used for calibration is interpreted as the indicator of scale for the spatial processes and is assumed to be constant across covariates in GWR. MGWR, using a back-fitting algorithm relaxes the assumption that all processes being modeled operate at the same spatial scale and estimates a unique indicator of scale for each process.\n", + "The GWR model in PySAL can currently estimate Gaussian, Poisson and Logistic models though the MGWR model is currently limited to only Gaussian models. This project aims to expand the MGWR model to nonlinear local spatial regression modeling techniques where the response outcomes may be discrete (following a Poisson distribution). This will enable a richer and holistic local statistical modeling framework to model multi-scale process heterogeneity for the open source community.\n", + "\n", + "## Statistical Equations\n", + "\n", + "A conventional Poisson regression model is written as:\n", + "\n", + "\\begin{align}\n", + "O_i ~ Poisson[E_i exp ({\\sum} {\\beta} & _k x _{k,i})] \\\\\n", + "\\end{align}\n", + "\n", + "where $x_{k,1}$ is the kth explanatory variable in place i and the ${\\beta}_ks$ are the parameters and Poisson indicates a Poisson distribution with mean $\\lambda$.\n", + "\n", + "Nakaya et.al. (2005) introduced the concept of allowing parameter values to vary with geographical location ($u_i$), which is a vector of two dimensional co-ordinates describing the location i. The Poisson model for geographically varying parameters can be written as:\n", + "\n", + "\\begin{align}\n", + "O_i ~ Poisson[E_i exp ({\\sum} {\\beta} & _k (u_i) x _{k,i})] \\\\\n", + "\\end{align}\n", + "\n", + "The Geographically Weighted Poisson Regression model (GWPR) is estimated using a modified local Fisher scoring procedure, a form of iteratively reweighted least squares (IRLS). In this procedure, the following matrix computation of weighted least squares should be repeated to update parameter estimates until they converge (Nakaya et.al., 2005):\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": [ + "# Approaches Explored" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Fotheringham, A. S., Yang, W., & Kang, W. (2017). Multiscale Geographically Weighted Regression (MGWR). Annals of the American Association of Geographers, 107(6), 1247–1265. https://doi.org/10.1080/24694452.2017.1352480\n", + "\n", + "\n", + "2. Nakaya, T., Fotheringham, A. S., Brunsdon, C., & Charlton, M. (2005). Geographically weighted Poisson regression for disease association mapping. Statistics in Medicine, 24(17), 2695–2717. https://doi.org/10.1002/sim.2129\n", + "\n", + "\n", + "3. Yu, H., Fotheringham, A. S., Li, Z., Oshan, T., Kang, W., & Wolf, L. J. (2019). Inference in Multiscale Geographically Weighted Regression. Geographical Analysis, gean.12189. https://doi.org/10.1111/gean.12189\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/Poisson_MGWR_MonteCarlo_Results.ipynb b/notebooks/Poisson_MGWR_MonteCarlo_Results.ipynb new file mode 100644 index 0000000..c9fcc6e --- /dev/null +++ b/notebooks/Poisson_MGWR_MonteCarlo_Results.ipynb @@ -0,0 +1,1011 @@ +{ + "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": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnin`gs.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/Poisson_MC_script/\")\n", + "import f_2\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": 10, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_bw0=[]\n", + "mgwr_bw1=[]\n", + "mgwr_bw2=[]\n", + "gwr_bw=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,1000,50):\n", + " p1 = pickle.load( open( \"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Poisson_MC_script/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": 21, + "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": 22, + "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": "markdown", + "metadata": {}, + "source": [ + "### GWR bandwidth" + ] + }, + { + "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(gwr_bw)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "170.074" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(gwr_bw)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MGWR bandwidths" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 25, + "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": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "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_bw0)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "546.083" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw0)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 28, + "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": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "91.753" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw1)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "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_bw1)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 31, + "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": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "209.398" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_bw2)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "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": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(546.083, 91.753, 209.398)" + ] + }, + "execution_count": 34, + "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": 160, + "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=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,1000,50):\n", + " p1 = pickle.load( open( \"C:/Users/msachde1/Downloads/Research/Development/mgwr/notebooks/Poisson_MC_script/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])" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "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": 47, + "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": 46, + "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": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(640.2736332530651, 696.9264487767485)" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_aicc), np.mean(gwr_aicc)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(640.2353688823071, 693.79977380067)" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(mgwr_aic), np.mean(gwr_aic)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(653.4726886933404, 823.1916659552306)" + ] + }, + "execution_count": 51, + "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": 149, + "metadata": {}, + "outputs": [], + "source": [ + "model=[]\n", + "model = ['gwr']*1000\n", + "model2 = ['mgwr']*1000\n", + "model=model+model2" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [], + "source": [ + "aic=[]\n", + "aic=gwr_aic\n", + "aic=aic+mgwr_aic" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [], + "source": [ + "aicc=[]\n", + "aicc=gwr_aicc\n", + "aicc=aicc+mgwr_aicc" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [], + "source": [ + "bic=[]\n", + "bic=gwr_bic\n", + "bic=bic+mgwr_bic" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [], + "source": [ + "d = {'aic':aic,'bic':bic,'aicc':aicc,'model':model}" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [], + "source": [ + "df=pd.DataFrame(data=d)" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "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": 175, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XtUlXWixvHvhg1bVCbZCmFqjNSUComOjUoXQAIRlWwYmkiXOrVKx9PVtfKMouXYycuYU7Oahso6y3UOdhYaNuJ4HPCCmg5awurUEJadQPNSgGEGKrhv5w8Oe0KreSVf3008n3/sfdm7/WwFnv17L7+fzefz+RARETEgyOoAIiLSdag0RETEMJWGiIgYptIQERHDVBoiImKYSkNERAxTaYiIiGEqDRERMUylISIihqk0RETEMJWGiIgYZrc6wPfl9Xo5c+YMISEh2Gw2q+OIiHQJPp8Pl8tFr169CAoyPn7o8qVx5swZDh06ZHUMEZEu6YYbbiA8PNzw47t8aYSEhABtbzw0NNTiNCIiXcP58+c5dOiQ/3eoUV2+NNoPSYWGhuJwOCxOIyLStVzqYX2dCBcREcNUGiIiYphKQ0REDFNpiEiX0NjYyPz58zl16pTVUbo1lYaIdAmFhYVUV1dTWFhodZRuTaUhIgGvsbGR7du34/P52LZtm0YbFlJpiEjAKywsxO12A+B2uzXasJBKQ0QC3s6dO/H5fEDb9Bc7d+60OFH3pdIQkYAXGRn5ndty5ag0RCTg1dfXf+e2XDkqDREJeFFRUd+5LVeOSkNEAl5DQ0OHbY00rKPSEJGAN27cOP/EejabjdTUVIsTdV+mlsbq1avJyMggKyuLl156CYCDBw+SnZ1NRkYGCxcu9F9Gd+LECaZNm8aECROYM2cOZ86cMTOaiHQhubm52O1tk3Lb7XZyc3MtTtR9mVYa5eXl/OUvf2HDhg1s3LiR9957j61btzJv3jyeeuopSktL8fl8rF+/HoAlS5YwdepUSkpKiI+PJz8/36xoItLFOJ1O0tLSsNlspKenExERYXWkbsu00qiurua2226jd+/eBAcHc/vtt1NQUEBLSwsjRowAIDs7m5KSElwuFwcOHCAjI6PDfhGRdrm5uQwbNkyjDIuZVhpxcXHs3buXL7/8ktbWVsrKyrDb7R2ur46MjKSuro5Tp07Ru3dv//Czfb+ISDun08mKFSs0yrCYaSv3JSYmkp2dzfTp0+nTpw+JiYns27evwypRPp8Pm83m//PrLnU1qaqqqsuSW0REvp1ppdHc3Mz48eO57777AHjttdcYOHAgFRUV/secPHmSqKgonE4nTU1NeDwegoODaWhouOTrsOPj47Xcq4iIQa2trZ36sG3a4aljx47xL//yL7jdbpqamigqKiInJweHw0FlZSUAxcXFJCUlERISws0338yWLVsA2LhxI0lJSWZFExGRTjJtpDFkyBDGjx/PnXfeicfj4Ve/+hWjRo1i1apVLFq0iObmZuLi4pgxYwYAixcvZv78+bz00kv079+f5557zqxoIiLSSTZf+9SRXVT7EEuHp0REjOvs707dES4iIoapNERExDCVhoh0CY2NjcyfP19LvVpMpSEiXUJhYSHV1dVa6tViKg0RCXiNjY3s2LEDn8/H9u3bNdqwkEpDRAJeYWEhXq8XAK/Xq9GGhVQaIhLwdu3a5V9Gwe12s3PnTosTdV8qDREJeCkpKR3W0xg3bpzFibovlYaIBLzc3NwOK/dpenTrqDREJOA5nU6io6MB6N+/v6ZHt5BKQ0QCXmNjI59//jkAn332ma6espBKQ0QCXmFhIe3T5Pl8Pl09ZSGVhogEPF09FThUGiIS8HT1VOBQaYhIwMvNzSUoqO3XVVBQkK6espBKQ0QCntPp5I477sBms5GWlqarpyxk2sp9IiKXU25uLp9++qlGGRZTaYhIl+B0OlmxYoXVMbo9Uw9PFRcXM2nSJCZNmsTvfvc7AF588UXGjRvHlClTmDJlCq+//joABw8eJDs7m4yMDBYuXOi/UkJERAKHaSONc+fOsXTpUkpKSvjRj37EvffeS3l5OVVVVTz33HOMHDmyw+PnzZvHM888w4gRI8jLy2P9+vVMnTrVrHgiItIJpo00PB4PXq+Xc+fO4Xa7cbvdOBwOqqqqeOWVV8jKyuLpp5+mtbWV48eP09LSwogRIwDIzs6mpKTErGgiItJJpo00evfuzWOPPUZmZiZhYWH87Gc/48Ybb2To0KHMmzePmJgY5s+fT35+PikpKURGRvqfGxkZSV1d3SW9XlVV1eV+CyIicgHTSuPDDz9kw4YN7Ny5k/DwcJ544gkKCwt59dVX/Y+5//77ycvLIykpyT+DJbRNE/D1bSPi4+NxOByXLb+IyA9Za2trpz5sm3Z4au/evSQmJtK3b19CQ0PJzs5m9+7dFBUV+R/j8/mw2+1ER0fT0NDg33/y5EmioqLMiiYiXVBNTQ333HMPtbW1Vkfp1kwrjSFDhlBeXs7Zs2fx+XyUlZVx/fXX8+yzz3L06FF8Ph+vv/466enpDBgwAIfDQWVlJdB21VVSUpJZ0USkC/rd737H2bNn/VdiijVMOzx12223UV1dTXZ2NiEhIdx0000sXLiQsWPHMmfOHFwuFz/96U+57777AFi1ahWLFi2iubmZuLg4ZsyYYVY0EeliampqOHHiBADHjx+ntraWwYMHW5yqe7L52ucb7qLaj8vpnIbID9fs2bP9pQEwYMAAXn75ZQsTdX2d/d2puadEJOB9vTCgbbQh1lBpiEjAu/Bqyku9ulIuH5WGiAS8W265pcP2rbfealESUWmISMCbNWvWd27LlaPSEJGA53Q6+dnPfgbA6NGjtZ6GhVQaItIlhIeHd/hTrKHSEJGA19jYyN69ewHYs2cPp06dsjhR96XSEJGAV1hYiNfrBcDr9VJYWGhxou5LpSEiAW/Xrl3+hdncbjc7d+60OFH3pdIQkYCXkpKC3d4265HdbmfcuHEWJ+q+VBoiEvByc3MJCmr7dRUUFERubq7FibovlYaIBDyn08kdd9yBzWYjLS1Nl9xayLRZbkVELqfc3Fw+/fRTjTIsptIQkS7B6XSyYsUKq2N0ezo8JSIihqk0RKRLaGxsZP78+bqxz2IqDRHpEgoLC6murtaNfRYztTSKi4uZNGkSkyZN8q/re/DgQbKzs8nIyGDhwoX+G3ZOnDjBtGnTmDBhAnPmzOHMmTNmRhORLqSxsZEdO3bg8/nYvn27RhsWMq00zp07x9KlSykoKKC4uJiKigrKy8uZN28eTz31FKWlpfh8PtavXw/AkiVLmDp1KiUlJcTHx5Ofn29WNBHpYjSNSOAwrTQ8Hg9er5dz587hdrtxu93Y7XZaWloYMWIEANnZ2ZSUlOByuThw4AAZGRkd9ouIgKYRCSSmlUbv3r157LHHyMzMJDk5mQEDBhASEkJkZKT/MZGRkdTV1XHq1Cl69+7tnyagfb+ICLRNI/J1mkbEOqbdp/Hhhx+yYcMGdu7cSXh4OE888QR/+9vfOqzt6/P5sNls/j+/7lLXAK6qqrosubu7pqYmioqKyMnJ0boFErCCg4OprKy0Oka3ZFpp7N27l8TERPr27Qu0HXL693//dxoaGvyPOXnyJFFRUTidTpqamvB4PAQHB9PQ0EBUVNQlvV58fDwOh+OyvofuKD8/n08//ZSDBw8yZ84cq+OIAPDMM8902P7rX/+qJV+/p9bW1k592Dbt8NSQIUMoLy/n7Nmz+Hw+ysrKGD16NA6Hw/8Jobi4mKSkJEJCQrj55pvZsmULABs3biQpKcmsaPItGhsb2bZtGz6fj61bt+oKFQkY7eczvm1brhzTSuO2225j0qRJZGdnc+edd+J2u5k1axarVq1i+fLlTJgwgbNnzzJjxgwAFi9ezPr165k4cSIVFRU8/vjjZkWTb1FYWNjhZKOuUJFA0X6+89u25cqx+Xw+n9Uhvo/2IZYOT31/OTk5tLa2+rcdDgdFRUUWJhJp89Zbb/Hss8/6t3/zm99w2223WZio6+vs707dES5+F356CwkJsSiJSEdJSUkEBwcDbSfBVRjWUWmI34V34Tc3N1uURORiN910EwDDhw+3OEn3pgODAaKsrIxt27ZZmsHhcFx0eGrBggWWZElPTyc1NdWS15bA09jYSHV1NQAffPABp06d0kJMFtFIQ/wGDhz4ndsiVtE0IoFDI40AkZqaGhCfrNtPhl977bX84Q9/sDqOCPDN04joPiJraKQhHQwcOJCgoCCeeOIJq6OI+CUmJnbYvuWWWyxKIioN6SAsLIxhw4YxePBgq6OI+HXxOwN+UFQaIhLw9u3b12G7vLzcoiSi0hCRgPf12bG/aVuuHJWGiAS8+vr6DttaOsE6Kg0RCXgXznp99dVXW5REVBoiEvC+vqTCN23LlaPSEJGAd+Eltrrk1joqDREJeLrkNnCoNEQk4O3fv7/Dti65tY5KQ0QCnu4IDxwqDREJeDo8FThMm7DwjTfeYO3atf7tY8eOMWXKFM6dO0dlZSVhYWEAPPzww6Snp1NeXs7y5ctpbW0lMzOTuXPnmhVNRLqYCw9H7d27V0tCW8S00rj77ru5++67Afj444956KGHePjhh5k5cyZr167tcN11S0sLeXl5FBQU0L9/f2bPns3u3btJTk42K56IdCF2u73DWi9aVdI6V+Tw1G9/+1vmzp1LWFgYJ06cIC8vj6ysLF544QW8Xi/vv/8+MTExDBo0CLvdTlZWFiUlJVcimoh0AVpVMnCYXhrl5eW0tLSQmZnJyZMnGTt2LMuWLWP9+vVUVFRQVFREfX19h7lkoqKiNE2AiPj169evw7bmnrKO6YswFRYWct999wEwaNAg/vSnP/m/Nn36dDZu3EhGRgY2m82/3+fzddg2oqqq6vIE7uaampoAqKystDiJyD+cPn36om19j1rjkkvD6/Xi9Xqx2//5U8+fP8+BAwdYsWIFAB999BGHDx8mIyMDaCsHu91OdHR0h2kBGhoaLppr5p+Jj4/H4XBc0nPkYkVFRQCMGjXK4iQi/+ByuTpsnz9/Xt+j31Nra2unPmwbOjy1f/9+7rzzTgA++eQTkpOTeffdd//p8z766CN+/OMf07NnT6CtJJYtW8bp06dxuVysW7eO9PR0EhISqK2t5ciRI3g8HjZv3kxSUtIlvxkRETGXodJYuXIly5cvB+AnP/kJq1ev9m9/l6NHjxIdHe3fHjJkCLNmzeLee+9l0qRJDB06lMmTJ+NwOFixYgWPPPIIEydOJDY2lgkTJnTyLYmIiFkMHZ5yuVzExcX5t+Pi4jh//vw/fd7EiROZOHFih33Tpk1j2rRpFz02MTGRTZs2GYkjIiIWMTTSCAsL46233vJv79u3z3/ISUREug9DI42FCxfy0EMPYbfbsdls2Gw2/vjHP5qdTUQEgL59+/LFF1902BZrGCqNhIQEysrK+N///V+Cg4OJjY3VHZki3UhZWRnbtm2z7PUvvHrK5XKxYMECi9JAeno6qamplr2+lQxfPZWTk8OwYcMICgoiJSXF0NVTIiKXw4V3gOuOcOsYGml809VTS5YsYf369aaGE5HAkJqaaukn6/z8fP76178CEBQUxIQJE5gzZ45lebozQyONzl49JSJyOeTm5vpnibDb7eTm5lqcqPvS1VMiEvCcTicREREApKWl+f9brrxLvnoK2oaHunpKRK6kyMhIWlpaNMqwmOGrp3bt2sWhQ4cIDg5m8ODBhIaGmp1NRMQvJCSE2NhYjTIs9p2lUVxczJQpU1izZk2H/e2raLXPXisiIt3Dd5bGkSNHADh06NBFX/shrdn76quvUlNTY3WMgND+92DlNfCBJDY2lgcffNDqGCIB4ztL49FHHwXalm5dvXo1586d80+Nfvz48SsS8Eqoqamhqvojgnv0sTqK5bzuYAAO1mgRLE/Ll1ZHEAk4hs5pPPnkk0yZMoXS0lJyc3PZsWMH48ePNzvbFRXcow89Y+6wOoYEkLNHdlgdQSTgGCoNm83GrFmzOHXqFLGxsWRlZfGLX/zC7GwiIhJgDN2n0atXLwCuvfZaPv74Y3r06EFQkOnLi4uISIAxNNIYPnw4jz/+OI899hizZ8/m8OHDhpZ7FRGRHxZDw4W8vDx+9atfMXjwYPLy8vB6vfz+9783O5uIiAQYw+c0RowYAUBKSgopKSn/9DlvvPEGa9eu9W8fO3aMKVOmkJaWxvLly2ltbSUzM5O5c+cCcPDgQRYuXMiZM2e4+eabWbJkiUYzIiIBxrQTE3fffTfFxcUUFxezatUq+vbty4MPPkheXh75+fls2bKFqqoqdu/eDcC8efN46qmnKC0txefzaQZdEZEAdEXOZv/2t79l7ty5HD16lJiYGAYNGoTdbicrK4uSkhKOHz9OS0uLfzSTnZ1NSUnJlYgmIiKXwPTSKC8vp6WlhczMTOrr64mMjPR/LSoqirq6uov2R0ZGUlenm8tERAKN6ScNCgsL/XNUeb1e/5z40DYVic1m+9b9l6KqqqrTGZuamjr9XPlha2pqorKy0uoYwj9+TvXvYS1TS+P8+fMcOHCAFStWABAdHU1DQ4P/6w0NDURFRV20/+TJk0RFRV3Sa8XHx+NwODqV89VXX8XT8qXuAJYOPC1f4naHMmrUKKujCFBUVASgf4/LpLW1tVMftk09PPXRRx/x4x//2L9gU0JCArW1tRw5cgSPx8PmzZtJSkpiwIABOBwO/yeI4uJikpKSzIwmIiKdYOpI4+jRo0RHR/u3HQ4HK1as4JFHHqG1tZXk5GQmTJgAwKpVq1i0aBHNzc3ExcUxY8YMM6N1EBERweenzmvuKeng7JEdWrtB5AKmlsbEiROZOHFih32JiYls2rTposcOGTLEP/wUEZHApAmkRETEMJWGiIgYptIQERHDVBoiImKYSkNERAxTaYiIiGEqDRERMUwLVvw/TSPSxutuASDI3sPiJNbztHwJXG11DJGAotIAYmNjrY4QMGpqagCIjdUvS7ha3xsiF1BpAA8++KDVEQLGggULAFi+fLnFSUQkEOmchoiIGKbSEBERw1QaIiJimEpDREQMU2mIiIhhunpKJIC9+uqr/sugu7v2v4f2K/y6u9jYWEuu/FRpiASwmpoaPj74AdG99aMa5vMC0HT0I4uTWO/zZrdlr23qd2JZWRkvvvgi586d49Zbb2XRokUsWLCAyspKwsLCAHj44YdJT0+nvLyc5cuX09raSmZmJnPnzjUzmkiXEd3bzn3DnVbHkACy5v1Gy17btNI4evQoixcv5o033qBv377MnDmT3bt3U1VVxdq1a4mKivI/tqWlhby8PAoKCujfvz+zZ89m9+7dJCcnmxVPREQ6wbQT4du2bWPixIlER0cTEhLC888/z5AhQzhx4gR5eXlkZWXxwgsv4PV6ef/994mJiWHQoEHY7XaysrIoKSkxK5qIiHSSaSONI0eOEBISwq9//Ws+++wzUlJS+MUvfsHYsWNZvHgx4eHhzJ49m6KiInr27ElkZKT/uVFRUdTV1ZkVTUREOsm00vB4PFRUVFBQUEDPnj2ZM2cOMTEx/OlPf/I/Zvr06WzcuJGMjAxsNpt/v8/n67BtRFVV1WXL3p01NTUBUFlZaXESgX/8e4hcqKmpyZKfU9NKo1+/fiQmJuJ0tp3AS0tL489//jO9evUiIyMDaCsHu91OdHQ0DQ0N/uc2NDR0OOdhRHx8PA6H4/K9gW6qqKgIgFGjRlmcRKDt36PpS6tTSCAKDw//Xj+nra2tnfqwbdo5jXHjxrF3716++uorPB4Pe/bsIS0tjWXLlnH69GlcLhfr1q0jPT2dhIQEamtrOXLkCB6Ph82bN5OUlGRWNBER6STTRhoJCQk88MADTJ06FZfLxa233sr06dOx2+3ce++9uN1uxo8fz+TJkwFYsWIFjzzyCK2trSQnJzNhwgSzoomISCeZep9GTk4OOTk5HfZNmzaNadOmXfTYxMRENm3aZGYcERH5njT3lIiIGKbSEBERw1QaIiJimGZBEwlgp06d4mSz29K5hiTwfN7sxn3qlCWvrZGGiIgYppGGSACLiIjA3lyvWW6lgzXvNxIeEWHJa2ukISIihqk0RETEMJWGiIgYptIQERHDVBoiImKYSkNERAxTaYiIiGG6TyNAlJWVsW3bNqtjUFNTA8CCBQsszZGenk5qaqqlGUTkYhppSAdXXXUVbrcbl8tldRQRCUAaaQSI1NTUgPhknZ+fT0lJCddddx1z5syxOo7QNs+Q5p6C5vNeAHqH6rPu581uwi16bZWG+DU2NrJjxw58Ph/bt28nNzeXCIumKpA2sbGxVkcIGA3/f+i0/yD9nYRj3feGSkP8CgsL8XrbPs15vV4KCws12rDYgw8+aHWEgNF+nm358uUWJ+neTB3nlZWVkZ2dTWZmJs888wwA5eXlZGVlMX78eJ5//nn/Yw8ePEh2djYZGRksXLgQt9ttZjT5Brt27fL/vbvdbnbu3GlxIhEJNKaVxtGjR1m8eDH5+fls2rSJ6upqdu/eTV5eHvn5+WzZsoWqqip2794NwLx583jqqacoLS3F5/Oxfv16s6LJt0hJScFubxt82u12xo0bZ3EiEQk0ppXGtm3bmDhxItHR0YSEhPD8888TFhZGTEwMgwYNwm63k5WVRUlJCcePH6elpYURI0YAkJ2dTUlJiVnR5Fvk5uYSFNT2LREUFERubq7FiUQk0Jh2TuPIkSOEhITw61//ms8++4yUlBR+8pOfEBkZ6X9MVFQUdXV11NfXd9gfGRlJXV3dJb1eVVXVZcvenQ0fPpzKykqGDx/uv2dDJBA0NTUBUFlZaXGS7s200vB4PFRUVFBQUEDPnj2ZM2cOPXr0wGaz+R/j8/mw2Wx4vd5v3H8p4uPjcTgcly1/dzV48GBWrlzJo48+qiunJKAUFRUBMGrUKIuT/DC0trZ26sO2aaXRr18/EhMTcTrbVhxLS0ujpKSE4OBg/2MaGhqIiooiOjqahoYG//6TJ08SFRVlVjT5Dk6nkxUrVlgdQ0QClGnnNMaNG8fevXv56quv8Hg87NmzhwkTJlBbW8uRI0fweDxs3ryZpKQkBgwYgMPh8A87i4uLSUpKMiuaiIh0kmkjjYSEBB544AGmTp2Ky+Xi1ltv5d577yU2NpZHHnmE1tZWkpOTmTBhAgCrVq1i0aJFNDc3ExcXx4wZM8yKJiIinWTqzX05OTnk5OR02JeYmMimTZsueuyQIUP8xyxFRCQwaRIXERExTKUhIiKGqTRERMQwlYaIiBim0hAREcNUGiIiYphKQ0REDFNpiIiIYSoNERExTKUhIiKGqTRERMQwlYaIiBim0hAREcNUGiIiYphKQ0REDFNpiIiIYSoNERExzNSV+6ZPn05jYyN2e9vLPP3006xateqifQkJCfzlL3/hpZdewu12M3PmTKZNm2ZmNBER6QTTSsPn83H48GF27tzpL4hv2gdQV1fH888/z5tvvkloaCi5ubmMGTOG66+/3qx4IiLSCaYdnqqpqQHg/vvv584772Tt2rXfuA+gvLycsWPH0qdPH3r27ElGRgYlJSVmRRMRkU4ybaTx1VdfkZiYyJNPPonL5WLGjBmcPn36on2DBw+mvr6eyMhI/3OjoqJ4//33zYomIiKdZFppjBw5kpEjR/q3c3JyOHHiBCtXruywb/fu3URERGCz2fz7fT5fh20jqqqqvn9oEQlYTU1NAFRWVlqcpHszrTQqKipwuVwkJiYCbUXw4Ycfsm/fvg777HY70dHRVFRU+J/b0NBAVFTUJb1efHw8Dofj8r0BEQkoRUVFAIwaNcriJD8Mra2tnfqwbVppNDU18cILL1BYWIjL5eLPf/4zGRkZrFy5ssO+JUuWcM011/DHP/6RxsZGwsLC2Lp1K//2b/9mVjQRuURlZWVs27bN0gzt50QXLFhgaQ6A9PR0UlNTrY5hCdNKY9y4cbz33nvcddddeL1epk6dysyZM3G5XB32tR/Cmjt3LjNmzMDlcpGTk8Pw4cPNiiYiXZDT6bQ6ggA2n8/nszrE99E+xNLhKRER4zr7u1N3hIuIiGEqDRERMUylISIihqk0RETEMJWGiIgYptIQERHDVBoiImKYqetpXAntt5mcP3/e4iQiIl1H++/MS71Vr8uXhsvlAuDQoUMWJxER6XpcLhc9evQw/Pguf0e41+vlzJkzhISEXPLMuCIi3ZXP58PlctGrVy+CgoyfqejypSEiIleOToSLiIhhKg0RETFMpSEiIoapNERExDCVhoiIGKbSEBERw1QaIiJimEpDREQMU2mIiIhhXX7uKbl0v//97yktLSUiIoLIyEj+9re/8Yc//IHk5GSee+45qquree2116ivr+f+++/n5Zdf5oEHHiAiIoIePXqwZs0aq9+C/AC8/fbbvPzyy4SEhHDs2DFSU1Pp2bMn27dvB2D16tW88847vPDCC/Ts2ZOhQ4fi8Xi44YYb+OKLL5g3bx579+7l0Ucf5Z133sFut5OZmUlBQQG//OUvGT58OAcPHuS//uu/6Nu3r8Xv9odDI41upqysjMrKSjZv3szq1auprq7mX//1X9m/fz8AFRUV1NTU4PF42LNnD8nJyQDU1tby7LPPqjDksnrvvfdYsmQJGzZs4PXXX8fpdPLmm29y4403UlhYyLJly/iP//gPioqKOH36NADJycns27cPgP3799OjRw+qq6s5evQo4eHh9OvXD4CkpCRKS0tVGJeZSqObKS8vJzMzk9DQUK666irS0tJobGxk3759NDc3A3DjjTfywQcf8NZbbzFu3DgA+vbty8CBA62MLj9AN9xwA/379ycsLIyIiAgSExMBuOaaaygtLWXkyJFcffXVBAUFcddddwFw3XXX0dzczOnTp6moqGDq1Km88847vPXWW/4POQAJCQmWvKcfOpVGNxMUFITX6+2wr3///ni9XrZu3cpPf/pTxowZw/79+/nggw8YOXIkwCVNnSxiVEhISIft4ODgDv994fdqu9tvv51t27Zhs9lITU3lwIED7Nmzx/8hB8DhcJgTuptTaXQzt9xyC1u3buX8+fM0Nze0GqkKAAADm0lEQVSza9cubDYbSUlJvPTSS4wePZqxY8dSUFBAQkJChx9ikStp5MiR/P3vf6e+vh6fz8eWLVv8yx8kJyfzyiuvMGrUKIYOHconn3xCbW0tw4YNszj1D59OhHczKSkpvPvuu/z85z/nqquuIioqCofDQUpKCmvWrGHUqFH07NkTl8vV4VObyJXmdDpZtGgR999/P6GhoQwcOJAf/ehHAIwZM4aGhgZGjx6NzWZj6NChREREWJy4e9B6Gt3Mu+++y+HDh/n5z3+Oy+XinnvuYdmyZQwZMsTqaCIdnDp1ioKCAh5++GGCgoJ45plniImJYfr06VZH69Y00uhmBg8ezIsvvsiaNWvw+XzcddddKgwJSH369OGrr75i8uTJBAcHExcXxy9/+UurY3V7GmmIiIhhOhEuIiKGqTRERMQwlYaIiBim0hC5wmbPns2bb775nY95++23mTx58hVKJGKcSkNERAzTJbci/8Tbb7/Nc889R//+/amtrSUsLIxZs2ZRUFBAbW0t48ePJy8vj3Xr1lFQUEBQUBD9+vXjySefZPDgwdTV1TF//nzq6+u55ppr+OKLL/z/708++YSlS5fy5Zdf4vF4mD59Ojk5ORa+W5HvptIQMeDvf/87ixcvZtiwYTzwwAOsXr2a//zP/6S5uZmkpCRuuukmXnvtNdatW+efqfWhhx7iv//7v3n66adJSEjg8ccf58iRI/6J99xuN48++igrV64kLi6OpqYm7rnnHq6//nqL363It1NpiBgwcOBA/7xG1157LeHh4YSGhuJ0OunVqxelpaVMnDgRp9MJQHZ2NkuXLuXYsWOUl5fzm9/8BoCYmBjGjBkDwOHDh/n000/Jy8vzv05LSwvV1dVcd911V/gdihij0hAxIDQ0tMO23d7xR6d9Ir2v8/l8uN1ubDYbX7+Htv25Ho+H8PBwiouL/V87efIk4eHh/M///M/ljC9y2ehEuMhlMHr0aLZs2UJjYyMAGzZsoE+fPsTExHD77bezbt06AE6cOMHbb78NtE3p0qNHD39pfPbZZ0yePJmqqipr3oSIARppiFwGY8aMISgoiJkzZ+L1enE6nbzyyisEBQWxePFiFixYQGZmJtHR0f65vkJDQ8nPz2fp0qW89tpruN1uHnvsMUaNGuUvFpFAo7mnRETEMB2eEhERw1QaIiJimEpDREQMU2mIiIhhKg0RETFMpSEiIoapNERExDCVhoiIGPZ/RdXZQciCrRIAAAAASUVORK5CYII=\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": 176, + "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": 182, + "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": 207, + "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": 208, + "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": 211, + "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": 315, + "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": 314, + "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": 316, + "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()" + ] + } + ], + "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/Poisson_MGWR_univariate_check.ipynb b/notebooks/Poisson_MGWR_univariate_check.ipynb new file mode 100644 index 0000000..ed829f9 --- /dev/null +++ b/notebooks/Poisson_MGWR_univariate_check.ipynb @@ -0,0 +1,486 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notebook Outline:** \n", + " \n", + "- [Setup with libraries](#Set-up-Cells)\n", + "- [Fundamental equations for Poisson 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)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up Cells" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from mgwr.gwr import GWR\n", + "from spglm.family import Gaussian, Binomial, Poisson\n", + "from mgwr.gwr import MGWR\n", + "from mgwr.sel_bw import Sel_BW\n", + "import multiprocessing as mp\n", + "pool = mp.Pool()\n", + "from scipy import linalg\n", + "import numpy.linalg as la\n", + "from scipy import sparse as sp\n", + "from scipy.sparse import linalg as spla\n", + "from spreg.utils import spdot, spmultiply\n", + "from scipy import special\n", + "import libpysal as ps\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "import copy\n", + "from collections import namedtuple\n", + "import spglm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fundamental equations for Poisson MGWR " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{align}\n", + "y = Poisson[E_i exp ({\\sum} {\\beta} & _k x _{k,i})] - (1) \\\\\n", + "E_i = Offset - (2) \\\\\n", + "\\hat{y} = predicted(y) - (3) \\\\\n", + "z = ({\\sum} {\\beta} & _k x _{k,i}) + ((y - \\hat{y})/\\hat{y}) - (4) \\\\\n", + "\\end{align}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data_p = ps.io.open(ps.examples.get_path('Tokyomortality.csv'))\n", + "coords = list(zip(data_p.by_col('X_CENTROID'),data_p.by_col('Y_CENTROID')))\n", + "off = np.array(data_p.by_col('eb2564')).reshape((-1,1))\n", + "y = np.array(data_p.by_col('db2564')).reshape((-1,1)) \n", + "occ = np.array(data_p.by_col('OCC_TEC')).reshape((-1,1))\n", + "own = np.array(data_p.by_col('OWNH')).reshape((-1,1))\n", + "pop = np.array(data_p.by_col('POP65')).reshape((-1,1))\n", + "unemp = np.array(data_p.by_col('UNEMP')).reshape((-1,1))\n", + "X = np.hstack([occ,own,pop,unemp])\n", + "x = unemp\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", + "y_std = (y-y.mean(axis=0))/y.std(axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Helper functions\n", + "Hardcoded here for simplicity in the notebook workflow\n", + "\n", + "Please note: A separate bw_func_p will not be required when changes will be made in the repository" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "kernel='bisquare'\n", + "fixed=False\n", + "spherical=False\n", + "search_method='golden_section'\n", + "criterion='AICc'\n", + "interval=None\n", + "tol=1e-06\n", + "max_iter=200\n", + "X_glob=[]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def gwr_func(y, X, bw,family=Gaussian(),offset=None):\n", + " return GWR(coords, y, X, bw, family,offset,kernel=kernel,\n", + " fixed=fixed, constant=False,\n", + " spherical=spherical, hat_matrix=False).fit(\n", + " lite=True, pool=pool)\n", + "\n", + "def bw_func_p(coords,y, X):\n", + " selector = Sel_BW(coords,y, X,family=Poisson(),offset=off, X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def bw_func(coords,y,X):\n", + " selector = Sel_BW(coords,y,X,X_glob=[],\n", + " kernel=kernel, fixed=fixed,\n", + " constant=False, spherical=spherical)\n", + " return selector\n", + "\n", + "def sel_func(bw_func, bw_min=None, bw_max=None):\n", + " return bw_func.search(\n", + " search_method=search_method, criterion=criterion,\n", + " bw_min=bw_min, bw_max=bw_max, interval=interval, tol=tol,\n", + " max_iter=max_iter, pool=pool, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Univariate example\n", + "#### GWPR model with independent variable, x = unemployment" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "bw_gwpr=Sel_BW(coords,y_std,x_std,family=Poisson(),offset=off,constant=False).search()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "gwpr_model=GWR(coords,y_std,x_std,bw=bw_gwpr,family=Poisson(),offset=off,constant=False).fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### MGWR Poisson loop with one independent variable, x = unemployment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Edited multi_bw function - original function in https://github.com/pysal/mgwr/blob/master/mgwr/search.py#L167" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def multi_bw(init,coords,y, X, n, k, family=Gaussian(),offset=None, tol=1e-06, max_iter=200, multi_bw_min=[None], multi_bw_max=[None],rss_score=False,bws_same_times=3,\n", + " verbose=False):\n", + " \n", + " if isinstance(family,spglm.family.Poisson):\n", + " bw = sel_func(bw_func_p(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw,family=Poisson(),offset=offset)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " #This change for the Poisson model follows from equation (1) above\n", + " XB = offset*np.exp(np.multiply(param, X))\n", + " \n", + " else:\n", + " bw=sel_func(bw_func(coords,y,X))\n", + " optim_model=gwr_func(y,X,bw)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params\n", + " XB = np.multiply(param, X)\n", + " \n", + " bw_gwr = bw\n", + " XB=XB\n", + " \n", + " if rss_score:\n", + " rss = np.sum((err)**2)\n", + " iters = 0\n", + " scores = []\n", + " delta = 1e6\n", + " BWs = []\n", + " bw_stable_counter = np.ones(k)\n", + " bws = np.empty(k)\n", + "\n", + " try:\n", + " from tqdm.auto import tqdm #if they have it, let users have a progress bar\n", + " except ImportError:\n", + "\n", + " def tqdm(x, desc=''): #otherwise, just passthrough the range\n", + " return x\n", + "\n", + " for iters in tqdm(range(1, max_iter + 1), desc='Backfitting'):\n", + " new_XB = np.zeros_like(X)\n", + " params = np.zeros_like(X)\n", + "\n", + " for j in range(k):\n", + " temp_y = XB[:, j].reshape((-1, 1))\n", + " temp_y = temp_y + err\n", + " temp_X = X[:, j].reshape((-1, 1))\n", + " \n", + " #The step below will not be necessary once the bw_func is changed in the repo to accept family and offset as attributes\n", + " if isinstance(family,spglm.family.Poisson):\n", + "\n", + " bw_class = bw_func_p(coords,temp_y, temp_X)\n", + " \n", + " else:\n", + " bw_class = bw_func(coords,temp_y, temp_X)\n", + "\n", + "\n", + " if np.all(bw_stable_counter == bws_same_times):\n", + " #If in backfitting, all bws not changing in bws_same_times (default 3) iterations\n", + " bw = bws[j]\n", + " else:\n", + " bw = sel_func(bw_class, multi_bw_min[j], multi_bw_max[j])\n", + " if bw == bws[j]:\n", + " bw_stable_counter[j] += 1\n", + " else:\n", + " bw_stable_counter = np.ones(k)\n", + "\n", + " #Changed gwr_func to accept family and offset as attributes\n", + " optim_model = gwr_func(temp_y, temp_X, bw,family,offset)\n", + " err = optim_model.resid_response.reshape((-1, 1))\n", + " param = optim_model.params.reshape((-1, ))\n", + " new_XB[:, j] = optim_model.predy.reshape(-1)\n", + " params[:, j] = param\n", + " bws[j] = bw\n", + "\n", + " num = np.sum((new_XB - XB)**2) / n\n", + " den = np.sum(np.sum(new_XB, axis=1)**2)\n", + " score = (num / den)**0.5\n", + " XB = new_XB\n", + "\n", + " if rss_score:\n", + " predy = np.sum(np.multiply(params, X), axis=1).reshape((-1, 1))\n", + " new_rss = np.sum((y - predy)**2)\n", + " score = np.abs((new_rss - rss) / new_rss)\n", + " rss = new_rss\n", + " scores.append(deepcopy(score))\n", + " delta = score\n", + " BWs.append(deepcopy(bws))\n", + "\n", + " if verbose:\n", + " print(\"Current iteration:\", iters, \",SOC:\", np.round(score, 7))\n", + " print(\"Bandwidths:\", ', '.join([str(bw) for bw in bws]))\n", + "\n", + " if delta < tol:\n", + " break\n", + " \n", + " print(\"iters = \"+str(iters))\n", + " opt_bws = BWs[-1]\n", + " print(\"opt_bws = \"+str(opt_bws))\n", + " return (opt_bws, np.array(BWs), np.array(scores), params, err, bw_gwr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Running the function with family = Poisson() and offset" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iters = 2\n", + "opt_bws = [178.]\n" + ] + } + ], + "source": [ + "bw_mgwpr = multi_bw(init=None,coords=coords,y=y_std, X=x_std, n=262, k=x.shape[1], family=Poisson(),offset=off)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Running without family and offset attributes runs the normal MGWR loop" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iters = 1\n", + "opt_bws = [73.]\n" + ] + } + ], + "source": [ + "bw_mgwr = multi_bw(init=None,coords=coords,y=y_std, X=x_std, n=262, k=x.shape[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter check" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Difference in parameters from the GWPR model and MGWPR model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.89357983e-05])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max(bw_mgwpr[3]-gwpr_model.params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are not identical but the maximum difference in the parameters is to the order of 1e-05 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bandwidths check" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "178.0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw_gwpr" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([178.])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw_mgwpr[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bandwidths from both models is the same" + ] + } + ], + "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/Real_data_example_Binomial-MGWR.ipynb b/notebooks/Real_data_example_Binomial-MGWR.ipynb new file mode 100644 index 0000000..88477fc --- /dev/null +++ b/notebooks/Real_data_example_Binomial-MGWR.ipynb @@ -0,0 +1,723 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "https://github.com/pysal/mgwr/pull/60" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from mgwr.gwr import GWR\n", + "from spglm.family import Gaussian, Binomial, Poisson\n", + "from mgwr.gwr import MGWR\n", + "from mgwr.sel_bw import Sel_BW\n", + "import multiprocessing as mp\n", + "pool = mp.Pool()\n", + "from scipy import linalg\n", + "import numpy.linalg as la\n", + "from scipy import sparse as sp\n", + "from scipy.sparse import linalg as spla\n", + "from spreg.utils import spdot, spmultiply\n", + "from scipy import special\n", + "import libpysal as ps\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "import copy\n", + "from collections import namedtuple\n", + "import spglm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Clearwater data - downloaded from link: https://sgsup.asu.edu/sparc/multiscale-gwr" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "data_p = pd.read_csv(\"C:/Users/msachde1/Downloads/logistic_mgwr_data/landslides.csv\") " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
UserIDXYElevSlopeSinAspctCosAspctAbsSouthLandslidDistStrm
01616168.56255201076.51450.47527.441720.409126-0.91247824.149918.506
12624923.81255201008.51567.47621.88343-0.919245-0.39368566.8160115.561
23615672.00005199187.51515.06538.81030-0.535024-0.84483732.3455141.238
34615209.31255199112.01459.82726.71631-0.828548-0.55991855.9499117.539
45616354.68755198945.51379.44227.55271-0.872281-0.48900560.7248135.023
\n", + "
" + ], + "text/plain": [ + " UserID X Y Elev Slope SinAspct CosAspct \\\n", + "0 1 616168.5625 5201076.5 1450.475 27.44172 0.409126 -0.912478 \n", + "1 2 624923.8125 5201008.5 1567.476 21.88343 -0.919245 -0.393685 \n", + "2 3 615672.0000 5199187.5 1515.065 38.81030 -0.535024 -0.844837 \n", + "3 4 615209.3125 5199112.0 1459.827 26.71631 -0.828548 -0.559918 \n", + "4 5 616354.6875 5198945.5 1379.442 27.55271 -0.872281 -0.489005 \n", + "\n", + " AbsSouth Landslid DistStrm \n", + "0 24.1499 1 8.506 \n", + "1 66.8160 1 15.561 \n", + "2 32.3455 1 41.238 \n", + "3 55.9499 1 17.539 \n", + "4 60.7248 1 35.023 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_p.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GWR Binomial model with independent variable, x = slope" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "coords = list(zip(data_p['X'],data_p['Y']))\n", + "y = np.array(data_p['Landslid']).reshape((-1,1)) \n", + "elev = np.array(data_p['Elev']).reshape((-1,1))\n", + "slope = np.array(data_p['Slope']).reshape((-1,1))\n", + "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", + "\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", + "y_std = (y-y.mean(axis=0))/y.std(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "bw=Sel_BW(coords,y,x_std,family=Binomial(),constant=False).search()\n", + "gwr_mod=GWR(coords,y,x_std,bw=bw,family=Binomial(),constant=False).fit()\n", + "bw" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Running the function with family = Binomial()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0\n", + "Bandwidths: 100.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([100.])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector = Sel_BW(coords,y,x_std,family=Binomial(),multi=True,constant=False)\n", + "selector.search(verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e53c42ebdd2145c8ad340c0add1dbdb2", + "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_std,selector,family=Binomial(),constant=False).fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Testing with random bw initialization" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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.])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector.search(verbose=True,init_multi=200)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Parameter check" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(330.2451626798668, 330.2296364641693)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mgwr_mod.aic, gwr_mod.aic" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "239" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum(mgwr_mod.predy==gwr_mod.predy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple bandwidth check" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "121.0" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw=Sel_BW(coords,y,X_std,family=Binomial(),constant=True).search()\n", + "gwr_mod=GWR(coords,y,X_std,bw=bw,family=Binomial(),constant=True).fit()\n", + "bw" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "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" + ] + }, + { + "data": { + "text/plain": [ + "array([238., 235., 192., 238., 228.])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector = Sel_BW(coords,y,X_std,family=Binomial(),multi=True,constant=True)\n", + "selector.search(verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "81557aa8e38f4d97b164f6349c8d195e", + "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_std,selector,family=Binomial(),constant=True).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(259.72499337648424, 273.19218208627643)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_mod.aic, mgwr_mod.aic" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "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": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(gwr_mod.predy-mgwr_mod.predy)[:10]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Global model check" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0033277\n", + "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", + "Current iteration: 2 ,SOC: 0.0003028\n", + "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", + "Current iteration: 3 ,SOC: 1.82e-05\n", + "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n", + "Current iteration: 4 ,SOC: 3.5e-06\n", + "Bandwidths: 239.0, 239.0, 239.0, 239.0, 239.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([239., 239., 239., 239., 239.])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector=Sel_BW(coords,y,X_std,multi=True,family=Binomial(),constant=True)\n", + "selector.search(verbose=True,multi_bw_min=[239,239,239,239,239], multi_bw_max=[239,239,239,239,239])" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0677b3083f5a4fb0a1b04da239579f36", + "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_std,selector,family=Binomial(),constant=True).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===========================================================================\n", + "Model type Binomial\n", + "Number of observations: 239\n", + "Number of covariates: 5\n", + "\n", + "Global Regression Results\n", + "---------------------------------------------------------------------------\n", + "Deviance: 266.246\n", + "Log-likelihood: -133.123\n", + "AIC: 276.246\n", + "AICc: 276.504\n", + "BIC: -1015.246\n", + "Percent deviance explained: 0.182\n", + "Adj. percent deviance explained: 0.168\n", + "\n", + "Variable Est. SE t(Est/SE) p-value\n", + "------------------------------- ---------- ---------- ---------- ----------\n", + "X0 0.389 0.150 2.591 0.010\n", + "X1 -0.784 0.166 -4.715 0.000\n", + "X2 0.654 0.168 3.881 0.000\n", + "X3 0.039 0.149 0.264 0.792\n", + "X4 -0.371 0.156 -2.381 0.017\n", + "\n", + "Geographically Weighted Regression (GWR) Results\n", + "---------------------------------------------------------------------------\n", + "Spatial kernel: Adaptive bisquare\n", + "Bandwidth used: 121.000\n", + "\n", + "Diagnostic information\n", + "---------------------------------------------------------------------------\n", + "Effective number of parameters (trace(S)): 23.263\n", + "Degree of freedom (n - trace(S)): 215.737\n", + "Log-likelihood: -106.599\n", + "AIC: 259.725\n", + "AICc: 264.982\n", + "BIC: 340.598\n", + "Percent deviance explained: 0.345\n", + "Adjusted percent deviance explained: 0.274\n", + "Adj. alpha (95%): 0.011\n", + "Adj. critical t value (95%): 2.571\n", + "\n", + "Summary Statistics For GWR Parameter Estimates\n", + "---------------------------------------------------------------------------\n", + "Variable Mean STD Min Median Max\n", + "-------------------- ---------- ---------- ---------- ---------- ----------\n", + "X0 0.459 0.360 -0.360 0.436 1.232\n", + "X1 -0.824 0.479 -2.128 -0.729 -0.095\n", + "X2 0.567 0.390 -0.030 0.600 1.328\n", + "X3 0.103 0.270 -0.473 0.183 0.565\n", + "X4 -0.331 0.247 -1.118 -0.287 0.096\n", + "===========================================================================\n", + "\n" + ] + } + ], + "source": [ + "gwr_mod.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.51706075, -0.62371359, 0.40876353, 0.18489423, -0.25850672],\n", + " [ 0.53944656, -0.62786302, 0.4517912 , 0.12124392, -0.30271264],\n", + " [ 0.51507462, -0.62266611, 0.41219502, 0.18443272, -0.25063396],\n", + " [ 0.50706347, -0.62907618, 0.41797955, 0.18280349, -0.25311318],\n", + " [ 0.5215872 , -0.61765274, 0.41172973, 0.18103538, -0.24980074]])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mgwr_mod.params[:5]" + ] + } + ], + "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/Real_data_example_Poisson-MGWR.ipynb b/notebooks/Real_data_example_Poisson-MGWR.ipynb new file mode 100644 index 0000000..97a3b57 --- /dev/null +++ b/notebooks/Real_data_example_Poisson-MGWR.ipynb @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notebook Outline:** \n", + " \n", + "- [Setup with libraries](#Set-up-Cells)\n", + "- [Tokyo Mortality 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)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Branch - gsco19\n", + "\n", + "PR - https://github.com/pysal/mgwr/pull/60" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up Cells" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "#append path here to point to your folder\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from mgwr.gwr import GWR\n", + "from spglm.family import Gaussian, Binomial, Poisson\n", + "from mgwr.gwr import MGWR\n", + "from mgwr.sel_bw import Sel_BW\n", + "import multiprocessing as mp\n", + "pool = mp.Pool()\n", + "from scipy import linalg\n", + "import numpy.linalg as la\n", + "from scipy import sparse as sp\n", + "from scipy.sparse import linalg as spla\n", + "from spreg.utils import spdot, spmultiply\n", + "from scipy import special\n", + "import libpysal as ps\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "import copy\n", + "from collections import namedtuple\n", + "import spglm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tokyo Mortality Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data_p = ps.io.open(ps.examples.get_path('Tokyomortality.csv'))\n", + "coords = list(zip(data_p.by_col('X_CENTROID'),data_p.by_col('Y_CENTROID')))\n", + "off = np.array(data_p.by_col('eb2564')).reshape((-1,1))\n", + "y = np.array(data_p.by_col('db2564')).reshape((-1,1)) \n", + "occ = np.array(data_p.by_col('OCC_TEC')).reshape((-1,1))\n", + "own = np.array(data_p.by_col('OWNH')).reshape((-1,1))\n", + "pop = np.array(data_p.by_col('POP65')).reshape((-1,1))\n", + "unemp = np.array(data_p.by_col('UNEMP')).reshape((-1,1))\n", + "#X set for multivariate example\n", + "X = np.hstack([occ,own,pop,unemp])\n", + "#x set for univariate example\n", + "x = occ" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X_std = (X-X.mean(axis=0))/X.std(axis=0)\n", + "x_std = (x-x.mean(axis=0))/x.std(axis=0)\n", + "y_std = (y-y.mean(axis=0))/y.std(axis=0)\n", + "off_std = (off-off.mean(axis=0))/off.std(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#checking distribution of y\n", + "sns.distplot(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Univariate example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### First example: checking GWR and MGWR models with one independent variable and constant = False" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "bw=Sel_BW(coords,y,x_std,family=Poisson(),offset=off,constant=False)\n", + "bw=bw.search()\n", + "gwr_model=GWR(coords,y,x_std,bw,family=Poisson(),offset=off,constant=False).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "43.0" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "selector=Sel_BW(coords,y,x_std,multi=True,family=Poisson(),offset=off,constant=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0\n", + "Bandwidths: 43.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([43.])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector.search(verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9550662cb0ab4ac5a16cb33e608a653f", + "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_model=MGWR(coords,y,x_std,selector,family=Poisson(),offset=off,constant=False).fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Bandwidth: Random initialization check" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "selector.search(verbose=True,init_multi=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Parameter check" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "262" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "262" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum(((gwr_model.params-mgwr_model.params)==0.0)==True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(619.7791467932716, 621.8839585099654)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_model.aic,mgwr_model.aic" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "262" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum((gwr_model.predy-mgwr_model.predy==0)==True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multivariate example" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "bw=Sel_BW(coords,y,X_std,family=Poisson(),offset=off)\n", + "bw=bw.search()\n", + "gwr_model=GWR(coords,y,X_std,bw,family=Poisson(),offset=off).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "107.0" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "selector=Sel_BW(coords,y,X_std,multi=True,family=Poisson(),offset=off)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0002848\n", + "Bandwidths: 64.0, 66.0, 83.0, 95.0, 44.0\n", + "Current iteration: 2 ,SOC: 0.0001778\n", + "Bandwidths: 171.0, 65.0, 105.0, 95.0, 44.0\n", + "Current iteration: 3 ,SOC: 7.21e-05\n", + "Bandwidths: 241.0, 65.0, 134.0, 106.0, 44.0\n", + "Current iteration: 4 ,SOC: 4.75e-05\n", + "Bandwidths: 261.0, 65.0, 212.0, 95.0, 44.0\n", + "Current iteration: 5 ,SOC: 2.22e-05\n", + "Bandwidths: 261.0, 65.0, 261.0, 95.0, 44.0\n", + "Current iteration: 6 ,SOC: 1.52e-05\n", + "Bandwidths: 260.0, 65.0, 261.0, 95.0, 44.0\n", + "Current iteration: 7 ,SOC: 1.57e-05\n", + "Bandwidths: 261.0, 65.0, 261.0, 95.0, 45.0\n", + "Current iteration: 8 ,SOC: 1.4e-05\n", + "Bandwidths: 261.0, 65.0, 261.0, 95.0, 44.0\n", + "Current iteration: 9 ,SOC: 1.09e-05\n", + "Bandwidths: 261.0, 65.0, 261.0, 95.0, 44.0\n", + "Current iteration: 10 ,SOC: 9.2e-06\n", + "Bandwidths: 261.0, 65.0, 261.0, 95.0, 44.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([261., 65., 261., 95., 44.])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector.search(verbose=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Bandwidths: Random initialization check" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "selector.search(verbose=True, init_multi=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ffc299d718647c4ac8d407f4f54da1d", + "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_model=MGWR(coords,y,X_std,selector,family=Poisson(),offset=off).fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### AIC, AICc, BIC check" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(362.36478481908165, 368.06775592811084)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mgwr_model.aicc,gwr_model.aicc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_model.aic,gwr_model.aic" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mgwr_model.bic,gwr_model.bic" + ] + } + ], + "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/Simulated_data_example_Binomial-MGWR.ipynb b/notebooks/Simulated_data_example_Binomial-MGWR.ipynb new file mode 100644 index 0000000..8557141 --- /dev/null +++ b/notebooks/Simulated_data_example_Binomial-MGWR.ipynb @@ -0,0 +1,672 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from mgwr.gwr import GWR\n", + "from spglm.family import Gaussian, Binomial, Poisson\n", + "from mgwr.gwr import MGWR\n", + "from mgwr.sel_bw import Sel_BW\n", + "import multiprocessing as mp\n", + "pool = mp.Pool()\n", + "from scipy import linalg\n", + "import numpy.linalg as la\n", + "from scipy import sparse as sp\n", + "from scipy.sparse import linalg as spla\n", + "from spreg.utils import spdot, spmultiply\n", + "from scipy import special\n", + "import libpysal as ps\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "import copy\n", + "from collections import namedtuple\n", + "import spglm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulated data for Binomial MGWR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Forming variables" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + "\n", + "def sp(u,v):\n", + " return 1+1/324*(36-(6-u/2)**2)*(36-(6-v/2)**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)\n", + "X, Y = np.meshgrid(x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "x1=np.random.normal(0,0.1,625)\n", + "x2=np.random.normal(0,0.25,625)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "B0=con(X,Y)\n", + "B1=add(X,Y)\n", + "B2=sp(X,Y)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 7, + "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,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "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": [ + "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": 9, + "metadata": {}, + "outputs": [], + "source": [ + "B0=B0.reshape(-1,1)\n", + "B1=B1.reshape(-1,1)\n", + "B2=B2.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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(B0,ax=axes[0])\n", + "sns.distplot(B1,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "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(B2)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "lat=Y.reshape(-1,1)\n", + "lon=X.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "x1=x1.reshape(-1,1)\n", + "x2=x2.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "param = np.hstack([B1,B2])" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(625, 2)" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "param.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "cons=np.ones_like(x1)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "cons=cons.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "X=np.hstack([x1,x2])" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(625, 2)" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "#binomial y\n", + "y_exp = 1/(1+np.exp(-1*np.sum(X * param, axis=1).reshape(-1, 1)))" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.48826701350366136" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(y_exp)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(625, 1)" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_exp.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 64, + "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_exp)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "ym=np.ones_like(y_exp)\n", + "y_new=prob(y_exp,ym)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 67, + "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_new)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "coords = np.array(list(zip(lon,lat)))\n", + "y = np.array(y_new).reshape((-1,1))\n", + "#y_std = (y-y.mean(axis=0))/y.std(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "X=np.hstack([x1,x2])\n", + "X_std = (X-X.mean(axis=0))/X.std(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "bw=Sel_BW(coords,y,X_std,family=Binomial(),constant=False)\n", + "bw=bw.search()\n", + "gwr_model=GWR(coords,y,X_std,bw,family=Binomial(),constant=False).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "103.0" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "165.71680977089486" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_model.aic" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "selector=Sel_BW(coords,y,X_std,multi=True,family=Binomial(),constant=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "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" + ] + }, + { + "data": { + "text/plain": [ + "array([624., 540.])" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector.search(verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a52eed3e1c8d4e519d75060e8e4bd5f4", + "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_model=MGWR(coords,y,X_std,selector,family=Binomial(),constant=False).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(106.50235052741388, 16.93406345293964)" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mgwr_model.resid_ss,gwr_model.resid_ss" + ] + } + ], + "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/Simulated_data_example_Poisson-MGWR.ipynb b/notebooks/Simulated_data_example_Poisson-MGWR.ipynb new file mode 100644 index 0000000..be8758b --- /dev/null +++ b/notebooks/Simulated_data_example_Poisson-MGWR.ipynb @@ -0,0 +1,1065 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notebook Outline:** \n", + " \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 Poisson 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)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Branch - gsco19\n", + "\n", + "PR - https://github.com/pysal/mgwr/pull/60" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up Cells" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "#change path here to point to your folder\n", + "sys.path.append(\"C:/Users/msachde1/Downloads/Research/Development/mgwr\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from mgwr.gwr import GWR\n", + "from spglm.family import Gaussian, Binomial, Poisson\n", + "from mgwr.gwr import MGWR\n", + "from mgwr.sel_bw import Sel_BW\n", + "import multiprocessing as mp\n", + "pool = mp.Pool()\n", + "from scipy import linalg\n", + "import numpy.linalg as la\n", + "from scipy import sparse as sp\n", + "from scipy.sparse import linalg as spla\n", + "from spreg.utils import spdot, spmultiply\n", + "from scipy import special\n", + "import libpysal as ps\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "import copy\n", + "from collections import namedtuple\n", + "import spglm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create Simulated Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Forming independent variables" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 25, 25)\n", + "y = np.linspace(25, 0, 25)\n", + "X, Y = np.meshgrid(x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "B0=con(X,Y)\n", + "B1=add(X,Y)\n", + "B2=sp(X,Y)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 7, + "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": 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": [ + "plt.imshow(B1, extent=[0,10, 0, 10], origin='lower',cmap='RdBu_r')\n", + "plt.colorbar()\n", + "plt.axis(aspect='image')\n", + "plt.xticks([])\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 9, + "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": 10, + "metadata": {}, + "outputs": [], + "source": [ + "B0=B0.reshape(-1,1)\n", + "B1=B1.reshape(-1,1)\n", + "B2=B2.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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(B0,ax=axes[0])\n", + "sns.distplot(B1,ax=axes[1])\n", + "\n", + "plt.setp(axes, yticks=[])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "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(B2)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "lat=Y.reshape(-1,1)\n", + "lon=X.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "x1=x1.reshape(-1,1)\n", + "x2=x2.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "param = np.hstack([B0,B1,B2])\n", + "cons=np.ones_like(x1)\n", + "X=np.hstack([cons,x1,x2])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((625, 3), (625, 3))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "param.shape,X.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Creating y variable with Poisson distribution\n", + "Incorporating step from - Chapter 6. Simulating Generalized Linear Models, p. 153" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#y\n", + "y=(np.exp((np.sum(X * param, axis=1)+error).reshape(-1, 1)))\n", + "y_new = np.random.poisson(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(625, 1)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHIhJREFUeJzt3XuQXOV55/Hv09eZ0UgzuowE6IIECBw5wWDLyOCEXQcb5JQLkl0oy/Zm5cQJ5d2wTtaVTaCoxQne1Bonu+VNhbVNgmzHNmAMviiOXCyxZRzfhCTETYBAEroMQtZldJ3RTE93P/vHOT20Wj2aHmmmW5z39ylNqfuc091Pv9Pzm3fe855zzN0REZEwpFpdgIiINI9CX0QkIAp9EZGAKPRFRAKi0BcRCYhCX0QkIAp9EZGAKPRFRAKi0BcRCUim1QXUmjVrli9cuLDVZYiIvKls3LjxgLv3jLXdORf6CxcuZMOGDa0uQ0TkTcXMdjaynYZ3REQCotAXEQmIQl9EJCAKfRGRgCj0RUQCotAXEQmIQl9EJCAKfRGRgCj0RUQCcs4dkTuRHli3q+7yDy9b0ORKRETODerpi4gERKEvIhIQhb6ISEAU+iIiAVHoi4gERKEvIhIQhb6ISEAU+iIiAVHoi4gERKEvIhIQhb6ISEAU+iIiAVHoi4gERKEvIhIQhb6ISEAU+iIiAVHoi4gERKEvIhIQhb6ISEAU+iIiAVHoi4gERKEvIhKQhkLfzJab2RYz22pmt9dZ/0kze8HMnjWzH5jZhVXrVprZK/HXyoksXkRExmfM0DezNHAv8H5gCfAhM1tSs9kmYKm7Xw48Anw2fuwM4FPAMuAq4FNmNn3iyhcRkfFopKd/FbDV3be7ewF4CLipegN3X+vuA/HdXwDz4ts3AI+7e5+7HwIeB5ZPTOkiIjJejYT+XGB31f3eeNloPgZ8fzyPNbNbzWyDmW3Yv39/AyWJiMiZaCT0rc4yr7uh2X8AlgJ/PZ7Huvt97r7U3Zf29PQ0UJKIiJyJRkK/F5hfdX8esKd2IzN7L3AncKO7D43nsSIi0hyNhP56YLGZLTKzHLACWF29gZldCXyRKPD3Va16DLjezKbHO3Cvj5eJiEgLZMbawN2LZnYbUVingVXuvtnM7gY2uPtqouGcTuCbZgawy91vdPc+M/s00S8OgLvdvW9S3omIiIxpzNAHcPc1wJqaZXdV3X7vaR67Clh1pgWKiMjE0RG5IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBT6IiIBUeiLiAREoS8iEhCFvohIQBoKfTNbbmZbzGyrmd1eZ/21ZvaUmRXN7OaadSUzezr+Wj1RhYuIyPhlxtrAzNLAvcD7gF5gvZmtdvcXqjbbBXwU+NM6T3HC3a+YgFpFROQsjRn6wFXAVnffDmBmDwE3ASOh7+474nXlSahRREQmSCPDO3OB3VX3e+NljWozsw1m9gsz++1xVSciIhOqkZ6+1Vnm43iNBe6+x8wuAn5oZs+5+7aTXsDsVuBWgAULFozjqUVEZDwa6en3AvOr7s8D9jT6Au6+J/5/O/Aj4Mo629zn7kvdfWlPT0+jTy0iIuPUSOivBxab2SIzywErgIZm4ZjZdDPLx7dnAe+mal+AiIg015ih7+5F4DbgMeBF4GF332xmd5vZjQBm9k4z6wVuAb5oZpvjh/8KsMHMngHWAp+pmfUjIiJN1MiYPu6+BlhTs+yuqtvriYZ9ah/3M+DXzrJGERGZIDoiV0QkIAp9EZGAKPRFRAKi0BcRCYhCX0QkIAp9EZGAKPRFRAISTOi/eqCfvv5Cq8sQEWmpYEL/wSd38cTL+1pdhohISwUR+sVSmeNDRQaHdbp/EQlbEKF/bKgIQKGo0BeRsIUR+ieGARhS6ItI4III/aODUU9/uKTQF5GwBRH6xwbV0xcRgUBCv9LTLxRLLa5ERKS1ggj9Sk+/oOEdEQlcEKH/Rk+/jPt4rukuIpIsYYR+PHun7FAqK/RFJFxBhP6xwSIW39ZcfREJWeJDf7hU5sRwielTcoDG9UUkbIkP/WPxeP7MOPQ1bVNEQhZA6Efj+bM684CGd0QkbIkP/crMnZmdGt4REUl86KunLyLyhsSH/tETRdJmdHdkAYW+iIQt8aF/bHCYqW0Z8pk0oOEdEQlb4kP/aBz6uXT0VtXTF5GQBRD6Raa1Z8lloreqKZsiErLEh340vJMlnTLSKVNPX0SClujQLxTLDA6XmdaWASCXTmlMX0SClujQr0zXnNoWzdzJZ1Lq6YtI0BId+pUDsyo9/WwmpQupiEjQEh36g8NRwLfnouma+YyGd0QkbIkO/WJ87vxMKnqbubSGd0QkbIkO/VI5CvhMKjqbfk5j+iISuISHftTTT1eHvoZ3RCRgDYW+mS03sy1mttXMbq+z/loze8rMimZ2c826lWb2Svy1cqIKb0SxNvQ1vCMigRsz9M0sDdwLvB9YAnzIzJbUbLYL+CjwQM1jZwCfApYBVwGfMrPpZ192Y0ojY/pv9PR1RK6IhKyRnv5VwFZ33+7uBeAh4KbqDdx9h7s/C9Qm6g3A4+7e5+6HgMeB5RNQd0PqDu8Uy7jr4ugiEqZGQn8usLvqfm+8rBFn89izNjK8k45CP59O4ej8OyISrkZC3+osa7Sr3NBjzexWM9tgZhv279/f4FOPbaSnb1EZ2fikawMFHaAlImFqJPR7gflV9+cBexp8/oYe6+73uftSd1/a09PT4FOPrVR20inD4tDPx6HfP1ScsNcQEXkzaST01wOLzWyRmeWAFcDqBp//MeB6M5se78C9Pl7WFMVSeWQ8HyAXX0jlxLB6+iISpjFD392LwG1EYf0i8LC7bzazu83sRgAze6eZ9QK3AF80s83xY/uATxP94lgP3B0va4qS+8jQDkAuHttXT19EQpVpZCN3XwOsqVl2V9Xt9URDN/UeuwpYdRY1nrFiycmkT+3pa0xfREKV+CNyTx7e0Y5cEQlbokO/WPaRA7OAkevkDhQ0vCMiYUp06I/W0+8fUk9fRMIUVOjnM+rpi0jYEh/6lXPpA2TTGtMXkbAlOvSLNT39dMrIpIx+9fRFJFCJDv1SuXzSjlyIxvUHNKYvIoFKeOif3NOHaAaPhndEJFSJDv3a4R2Ie/oa3hGRQCU69Ov29DMp+tXTF5FAJT70TxnTT6c4oZ6+iAQq0aEfDe+c/BZzmZQOzhKRYCU69Ecb3tGYvoiEKtGhX6w3ZVOzd0QkYIkO/Xo9/XxGoS8i4Ups6JfLTtmpe3BWf6GIe6OX+RURSY7Ehn6hVAY4pafflk3jDsd19SwRCVBiQ394lNDvyEVXzzo8MNz0mkREWi2xoV8oRqFfO7zTno2uEHnkhEJfRMKT2NAfLkVj9rXz9NvV0xeRgCU29Efr6Y8M75woNL0mEZFWS27ojzKmr56+iIQssaE/2o7c9mwU+hrTF5EQJTb0RxveyaZTtGfTHB7Q8I6IhCexoT9aTx+guyOr4R0RCVJiQ7/S00+nTw39rvYshzW8IyIBSm7oxz39jNXv6R9RT19EApTY0B+Zp58+9S12t+c0ZVNEgpTY0B8Z3tGYvojIiMSGfmVHbu3sHYCujmhMX2faFJHQJDb0T9vTb89RKJYZHC43uywRkZZKbuiPMWUTdCoGEQlPckN/lIOzALrb49DXuL6IBCaxoX+6g7O6OhT6IhKmxId+JlV/yibAEQ3viEhgEhv6leGdOh39N8b01dMXkcA0FPpmttzMtpjZVjO7vc76vJl9I16/zswWxssXmtkJM3s6/vrCxJY/ukLJyaQMG+WIXECnYhCR4GTG2sDM0sC9wPuAXmC9ma129xeqNvsYcMjdLzGzFcA9wAfjddvc/YoJrntMhWK57ng+RKdXzqVT6umLSHAa6elfBWx19+3uXgAeAm6q2eYm4Cvx7UeA66xeF7uJhkujh76Z0dWR1Zi+iASnkdCfC+yuut8bL6u7jbsXgSPAzHjdIjPbZGZPmNlvnGW9DSsUy3Wna1Z0t+tUDCISnjGHd4B6yVl7/oLRtnkdWODuB83sHcB3zOyt7n70pAeb3QrcCrBgwYIGShrb6Xr6oPPviEiYGunp9wLzq+7PA/aMto2ZZYAuoM/dh9z9IIC7bwS2AZfWvoC73+fuS919aU9Pz/jfRR2FUpl0nemaFV3tOe3IFZHgNBL664HFZrbIzHLACmB1zTargZXx7ZuBH7q7m1lPvCMYM7sIWAxsn5jST2/M4Z2OLEd0yUQRCcyYwzvuXjSz24DHgDSwyt03m9ndwAZ3Xw3cD3zVzLYCfUS/GACuBe42syJQAj7u7n2T8UZqjTm8o6tniUiAGhnTx93XAGtqlt1VdXsQuKXO4x4FHj3LGs9IoYEx/YFCiaFiiXwm3cTKRERaJ7FH5A4X/bSh39VRORWDevsiEo7Ehn6hNPaUTUDXyhWRoCQ39E9zRC7oVAwiEqbEhv7wmD39aHhHc/VFJCSJDf1GduQCHNK0TREJSGJDf7h4+oOzeqbmMYM9h080sSoRkdZKbOiPtSO3LZvmgq52dh4caGJVIiKt1dA8/Tej0+3IfWDdLgDy2RQbdvSN3P/wsok574+IyLkqsT394fgiKqcza0qeg/0a0xeRcCQ29MfakQswszPHQKHEiUKpSVWJiLRWIkO/VHZKZSedHiP0p+QBOHB8qBlliYi0XCJDf7gUXRQ9M8bFu2Z2RnP1NcQjIqFIZOgX4tAfa3hnxpQcBhxUT19EApHM0C/GoZ8+/dvLplN0tWfV0xeRYCQy9Bsd3oFoiEc9fREJRTJDvxhdwnesHbkQ7cw9cFw9fREJQyJDv1CKpmCONaYPUU//xHCJgUJxsssSEWm5ZIZ+3NMf6+AsgFmd0bTNg+rti0gAkhn6Dc7egWgGD8DBfo3ri0jyJTL0h8cZ+tG0TfX0RST5khn68ZTNzGlOrVyRTafo6tC0TREJQyJDf2gcPX2ITrz22uETuPtkliUi0nKJDP03evqNhf7l87rYf2yIf33lwGSWJSLScokM/fHsyAW4Yn4309oyfP5H20aWPfHyfnoP6QIrIpIsiQz9kSNyGwz9TDrFr18yi59vP8imXYf48k9fZeWqJ7nz289PZpkiIk2XyCtnjZx7p8HQB3jnwhn8dNtB/uQbT7Pz4ADT2jL8ZOsB+voLI9M6RUTe7BLZ0y+U4tMwjCP089k077hwOjsPDnDpnE4+suxCSmXnL/9p88g2W/Yeoxj/FSEi8maUyNAfz5TNatcu7uHfXTmXjyy7kHnT2+npzPPM7iMArN2yjxs+92MeXL97wusVEWmWRIb+eHfkVuQyKZYunEE2ncLMuHx+FzsP9rN13zHu/NZzAPy/zXsnvF4RkWZJZOgPn8GYfj1vm9eNA797/5O8fnSQqy+aybrtfRwf0snZROTNKZGhXyiVMYOzzHxmdeaZ293O60cGWXn1Qj5x3WIKpTI/0Xx+EXmTSmzoV4ZoztY1F89kwYwOLpzRwdZ9x2nLpvj7f93OA+t2MThcYu1L+yiVdSSviLw5JDL0h4tOfoxLJTbqygXT+fi/uZh8Nk06ZVw6Zypb9h6j7M6fP/osv/fl9dz/k+0T8loiIpMtkaFfKJXIZibnrb3lvKkcHyry3adf47tP72HOtDx/89jLbNl7bFJeT0RkIiUy9IeLTm6Cevq1Lp09FQPW7zjE4tmd/P67F5FNG7/3pSf5x5/v4IF1uybldUVEJkIiQ79QKpPNnP14fj0d+QyLZk1hWluGW5bOZ2pblt+5ci57jgzygxf3nbL9vmODfPUXO1n70qnrGtGvmUIiMoEaOg2DmS0H/g+QBv7B3T9Tsz4P/CPwDuAg8EF33xGvuwP4GFACPuHuj01Y9XW4O/1DxUnr6QN86KoFlN3pzEfNt+SCLpZeOJ0fv7yfi3s6Aeg9NMDtjz7HT7cdwD06D9ADf/gurlo0A4ChYoncaXY2uzv/459f5Ms/28H/uuVt/PaVcyft/YhIOMYMfTNLA/cC7wN6gfVmttrdX6ja7GPAIXe/xMxWAPcAHzSzJcAK4K3ABcC/mNml7l6a6Dey7+ggn3hoE5v3HOXYYJEr5ndP9EuMmJI/tdk+cPkF7Oob4OENuxkulfnWptcolcu857LZXDZnKt/cuJv//PWNfOeP3s0TL+/nM99/icvmTOWemy/n4p5OBodLbNp1mAUzO7igq41Pf+9FVv30VeZMy/PJh5/GDN5y3jT+bu1WNu06RHdHlukdOfKZNLmMMThc5sDxIYol58YrLuCDS+czfZRzBpXKzhMv7+Nrv9jFpl2HuOaSWSx/63m8b8kc2rLpSWu3sZTLzuETw0zvyE7IzCuRc91wqczjL/ySZYtmMDO+Xvdks7EuHGJmVwN/4e43xPfvAHD3/1m1zWPxNj83swywF+gBbq/etnq70V5v6dKlvmHDhnG/kaFiiQ///Trect5UfnVuF9de2sMTW/aP+3nOxt6jg/zftVsplp3pHVlWXrOQ2VPbgGiY5/M/2kap7BTLzoIZHew/NsRwqcx73jKbn209QH8h+l04Y0qOvv4C11w8k+uXnMdXfr6DHQf6caKjhi+bM5XhUpn+oSLF+PmyKaOzLcPQcJmdfQNkUkZ3R5ZMKsX53W1M78gxJZ9hV98A2/Yd5/hQkan5DIt6prB9fz/Hh4p05jNcu3gW99x8OZ35zKQHr7uz9+ggW/cdZ+1L+1nz3OvsPTrIrM4cvzq3i1+b28VbL+gCnB+/coAX9hzl3ZfM5N+/fR4X9XTi7lQ+vmYE/YvC3SmUyhw4XuCXRwd5Yc9Rnt59mBPDJa5fMofrfmXOyF+mrRRdt2I/T+06xIyOHPOmdzBvRjvzp3cwe1qetBlmhjH+76m7Uyo7JXeGimV2Hhhg+4Hj/PLoIH39wzjOskUzuGrRTKbk0gzFB3HmM9Ff3OWyMzBcIm1GWzZaNlQs0T9UIp9J0ZFL4w7HBoscLxSZ2pZhaj5DoVRm/7EhThRKzOrM092Rpa+/wI6DA5TduXBmB93tOTbvOcLTuw8ztS3LOy6czi+PDvLfv/M8r+w7Tld7lj9bfhkfeucCUmd4gJGZbXT3pWNu10Do3wwsd/c/iO//LrDM3W+r2ub5eJve+P42YBnwF8Av3P1r8fL7ge+7+yOjvd6Zhn49rdip+mzvYZ7fc5Qb33bBKT9kW/Ye4/vPv861i3u4ckE3x4aK/NMze9jVN8BbzpvKZXOmceREgZ19A5zf1c61i2dhZhSKZVY/s4fujizXXDyTjtzpf3j3Hh1k444+jg4WKZWdQrHMQKHIYLFMd0eW2VPbWDRrCkvOn0Y6ZZTd2b6/nyde3se2/f1A9APXlol6/U4Urh7doVz1mTEDw4j/xQfFWbx9tF31YyvLKttUnzLj0tmdXDhzCvuODbLn8CD7jg1SOQQil0kxe2qe1w6dGPnlN1wqU+/jm4rDIlVVW+W2GSO11atr5H1V3hAj/2H2xrrqLKrUUP1+46etuXHSC4z63NX3a2ut/KIbuV31erU6ctE042ODRVIG7TV/xVUeWx55npOfO2pLGwnfet/fsjPymag8z8jj4v+r2//EcNSx6cxn6B8q1m2aWid9P6ufFyi5U46D/nRRlq7avpKplc+WGeTSqZFfApXXzKRTI2fshTeO8K8+LieTMoo1x+mkU3bKsTtG/Y/B3O52/vi6xXx702v8fPtBli2awYN/+K4zCv5GQ7+RX/31Xr22/tG2aeSxmNmtwK3x3eNmtqWBuhoxC2jJ4bP/fJp16+vUVe/M/ffVWfalsynq9FrWVhV1jnY4qaZXmljLabS8nUZxLtalmsawE/hZVU07gYc/fsZPd2EjGzUS+r3A/Kr784A9o2zTGw/vdAF9DT4Wd7+P+hl3VsxsQyO/+ZrtXKxLNTXmXKwJzs26VFNjml1TI1Nc1gOLzWyRmeWIdsyurtlmNbAyvn0z8EOP/j5cDawws7yZLQIWA09OTOkiIjJeY/b03b1oZrcBjxFN2Vzl7pvN7G5gg7uvBu4HvmpmW4l6+Cvix242s4eBF4Ai8EeTMXNHREQa09DufHdfA6ypWXZX1e1B4JZRHvtXwF+dRY1nY8KHjCbIuViXamrMuVgTnJt1qabGNLWmMWfviIhIciTyNAwiIlJfYkPfzJab2RYz22pmt7eohvlmttbMXjSzzWb2x/HyGWb2uJm9Ev8/vQW1pc1sk5l9L76/yMzWxTV9I95p38x6us3sETN7KW6vq8+Rdvqv8ffueTN70Mzamt1WZrbKzPbFx8NUltVtG4v8bfy5f9bM3t7Emv46/v49a2bfNrPuqnV3xDVtMbMbJqOm0eqqWvenZuZmNiu+37K2ipf/l7g9NpvZZ6uWT25bRQdkJOuLaIfzNuAiIAc8AyxpQR3nA2+Pb08FXgaWAJ8Fbo+X3w7c04LaPgk8AHwvvv8wsCK+/QXgPzW5nq8AfxDfzgHdrW4nYC7wKtBe1UYfbXZbAdcCbweer1pWt22A3wK+T3SMzLuAdU2s6XogE9++p6qmJfHPYB5YFP9spptVV7x8PtFklJ3ArHOgrd4D/AuQj+/PblZbTeoPTau+gKuBx6ru3wHccQ7U9V2icxhtAc6Pl50PbGlyHfOAHwC/CXwv/tAfqPqBPan9mlDPtDhcrWZ5q9tpLrAbmEE06eF7wA2taCtgYU1o1G0b4IvAh+ptN9k11az7HeDr8e2Tfv7i8L26WW0VL3sEeBuwoyr0W9ZWRB2H99bZbtLbKqnDO5Uf1oreeFnLmNlC4EpgHTDH3V8HiP+f3eRyPgf8GVA5xnwmcNjdK+dxbnZ7XQTsB74UDzn9g5lNocXt5O6vAX8D7AJeB44AG2ltW1WM1jbnymf/94l60dDimszsRuA1d3+mZlUr67oU+I14mPAJM3tns2pKaug3dPqHZjGzTuBR4E/c/Wir6ohr+QCwz903Vi+us2kz2ytD9Ofv5939SqCf+GR9rRSPk99E9Gf2BcAU4P11Nj2XpsC1+nuJmd1JdFzO1yuL6mzWlJrMrAO4E7ir3uo6y5rVVhlgOtGw0n8DHjYza0ZNSQ39hk7/0AxmliUK/K+7+7fixb80s/Pj9ecDZ3aFlTPzbuBGM9sBPEQ0xPM5oNuiU2hA89urF+h193Xx/UeIfgm0sp0A3gu86u773X0Y+BZwDa1tq4rR2qaln30zWwl8APiIx+MTLa7pYqJf2s/En/l5wFNmdl6L6+oFvuWRJ4n+6p7VjJqSGvqNnDpi0sW/ue8HXnT3/121qvq0FSuJxvqbwt3vcPd57r6QqF1+6O4fAdYSnUKjFTXtBXab2WXxouuIjuJuWTvFdgHvMrOO+HtZqatlbVVltLZZDfzHeGbKu4AjlWGgyWbRxZb+HLjR3Qdqam3J6Vjc/Tl3n+3uC+PPfC/R5Iq9tLCtgO8Qdbgws0uJJi8coBltNVk7U1r9RbRn/mWivd93tqiGXyf60+xZ4On467eIxtB/QHTiyB8AM1pU37/ljdk7F8Ufrq3AN4lnFTSxliuADXFbfYfoT9+WtxPwl8BLRCdC/SrRrIqmthXwINE+hWGi0PrYaG1DNDxwb/y5fw5Y2sSathKNR1c+61+o2v7OuKYtwPub2VY163fwxo7cVrZVDvha/Ll6CvjNZrWVjsgVEQlIUod3RESkDoW+iEhAFPoiIgFR6IuIBEShLyISEIW+iEhAFPoiIgFR6IuIBOT/A47/oTTXzHSlAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "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_new)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "coords = np.array(list(zip(lon,lat)))\n", + "y = np.array(y_new).reshape((-1,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "x=x1\n", + "x_std = (x-x.mean(axis=0))/x.std(axis=0)\n", + "X=np.hstack([x1,x2])\n", + "X_std = (X-X.mean(axis=0))/X.std(axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Univariate example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### First example: checking GWR and MGWR models with one independent variable and constant = False" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "43.0" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw=Sel_BW(coords,y,x,family=Poisson(),offset=None,constant=False)\n", + "bw=bw.search()\n", + "gwr_model=GWR(coords,y,x,bw,family=Poisson(),offset=None,constant=False).fit()\n", + "bw" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0\n", + "Bandwidths: 43.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([43.])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector=Sel_BW(coords,y,x,multi=True,family=Poisson(),offset=None,constant=False)\n", + "selector.search(verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a66e228bf6954695b6860c9e95a66dc9", + "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_model=MGWR(coords,y,x,selector,family=Poisson(),offset=None,constant=False).fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Bandwidth: Random initialization check" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0201116\n", + "Bandwidths: 43.0\n", + "Current iteration: 2 ,SOC: 0.0\n", + "Bandwidths: 43.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([43.])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector.search(verbose=True,init_multi=600)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Parameters check" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "625" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum(((gwr_model.params-mgwr_model.params)==0.0)==True)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3458.604213385903, 3476.5331190431302)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_model.aic,mgwr_model.aic" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "625" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum((gwr_model.predy-mgwr_model.predy==0)==True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multivariate example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Second example for multiple bandwidths" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "103.0" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw=Sel_BW(coords,y,X,family=Poisson(),offset=None)\n", + "bw=bw.search()\n", + "gwr_model=GWR(coords,y,X,bw,family=Poisson(),offset=None).fit()\n", + "bw" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0056638\n", + "Bandwidths: 400.0, 43.0, 43.0\n", + "Current iteration: 2 ,SOC: 0.0011879\n", + "Bandwidths: 400.0, 48.0, 44.0\n", + "Current iteration: 3 ,SOC: 0.0001425\n", + "Bandwidths: 400.0, 48.0, 44.0\n", + "Current iteration: 4 ,SOC: 2.35e-05\n", + "Bandwidths: 400.0, 48.0, 44.0\n", + "Current iteration: 5 ,SOC: 6.6e-06\n", + "Bandwidths: 400.0, 48.0, 44.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([400., 48., 44.])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector=Sel_BW(coords,y,X,multi=True,family=Poisson(),offset=None)\n", + "selector.search(verbose=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Bandwidths: Random initialization check" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "selector.search(verbose=True,init_multi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "13269e2282da47199cf33ca4533bac1b", + "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_model=MGWR(coords,y,X,selector,family=Poisson(),offset=None).fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Parameters check" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([39.63245513])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max(gwr_model.predy-mgwr_model.predy)[:10]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(651.1442030497388, 838.3196815747232)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwr_model.aic, mgwr_model.aic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Global model parameter check" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "import statsmodels.api as sma" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "X_glob=sma.add_constant(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "poisson_mod = sma.Poisson(y, X_glob)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 1.604261\n", + " Iterations 7\n", + " Poisson Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y No. Observations: 625\n", + "Model: Poisson Df Residuals: 622\n", + "Method: MLE Df Model: 2\n", + "Date: Thu, 04 Jul 2019 Pseudo R-squ.: 0.7832\n", + "Time: 11:47:08 Log-Likelihood: -1002.7\n", + "converged: True LL-Null: -4624.4\n", + " LLR p-value: 0.000\n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.2894 0.036 7.972 0.000 0.218 0.361\n", + "x1 1.2009 0.019 62.905 0.000 1.163 1.238\n", + "x2 1.1628 0.021 54.264 0.000 1.121 1.205\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "poisson_res = poisson_mod.fit(method=\"newton\")\n", + "print(poisson_res.summary())" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "selector=Sel_BW(coords,y,X,multi=True,family=Poisson(),offset=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current iteration: 1 ,SOC: 0.0067699\n", + "Bandwidths: 625.0, 625.0, 625.0\n", + "Current iteration: 2 ,SOC: 0.0006156\n", + "Bandwidths: 625.0, 625.0, 625.0\n", + "Current iteration: 3 ,SOC: 0.0001351\n", + "Bandwidths: 625.0, 625.0, 625.0\n", + "Current iteration: 4 ,SOC: 4.2e-06\n", + "Bandwidths: 625.0, 625.0, 625.0\n" + ] + }, + { + "data": { + "text/plain": [ + "array([625., 625., 625.])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector.search(verbose=True,multi_bw_min=[625,625,625], multi_bw_max=[625,625,625])" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b2e6e5f2d10047799dbd2793c497f02c", + "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_model=MGWR(coords,y,X,selector,family=Poisson(),offset=None).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.24911341, 1.22606055, 1.19712663],\n", + " [0.25309895, 1.2283422 , 1.19713621],\n", + " [0.25724177, 1.23072827, 1.19708916],\n", + " [0.26154154, 1.23322148, 1.19697204],\n", + " [0.26599496, 1.23582348, 1.19676824]])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mgwr_model.params[:5]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### parameters similar for global Poisson model and forced global MGWR Poisson model" + ] + } + ], + "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 +}