diff --git a/mgwr/gwr.py b/mgwr/gwr.py
index f771c43..4f01c15 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=Gaussian(), offset=None,
+                 sigma2_v1=True, kernel='bisquare', fixed=False, constant=True,
                  spherical=False, hat_matrix=False):
         """
         Initialize class
@@ -1448,17 +1448,20 @@ 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
+        self.family = family
+        if offset is None:
+            self.offset = np.ones((len(y), 1))
+        else:
+            self.offset = offset * 1.0
         GWR.__init__(self, coords, y, X, self.bw_init, family=self.family,
-                     sigma2_v1=sigma2_v1, kernel=kernel, fixed=fixed,
-                     constant=constant, spherical=spherical,
+                     offset=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 +1486,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)
+                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 +1512,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 +1538,25 @@ 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
         """
         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)))
+        else:
+            predy = np.sum(self.X * params, axis=1).reshape(-1, 1)
 
         try:
             from tqdm.autonotebook import tqdm  #progress bar
@@ -1692,7 +1714,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..bfd7a25 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,7 +165,7 @@ 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,
+def multi_bw(init, y, X, n, k, family, offset, tol, max_iter, rss_score, gwr_func,
              bw_func, sel_func, multi_bw_min, multi_bw_max, bws_same_times,
              verbose=False):
     """
@@ -180,7 +181,10 @@ 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))
+    else:
+        XB = np.multiply(param, X)
     if rss_score:
         rss = np.sum((err)**2)
     iters = 0
@@ -230,7 +234,10 @@ 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)))
+            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..cfb997f 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
@@ -391,10 +391,10 @@ 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,
-                           bws_same_times, verbose=self.verbose)
+        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, bw_func, sel_func, multi_bw_min,
+                           multi_bw_max, bws_same_times, verbose=self.verbose)
 
     def _init_section(self, X_glob, X_loc, coords, constant):
         if len(X_glob) > 0:
diff --git a/notebooks/Real_data_example_Poisson-MGWR.ipynb b/notebooks/Real_data_example_Poisson-MGWR.ipynb
new file mode 100644
index 0000000..42f09bf
--- /dev/null
+++ b/notebooks/Real_data_example_Poisson-MGWR.ipynb
@@ -0,0 +1,660 @@
+{
+ "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": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x24954356b70>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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": "9e794a65abd04853812f0d9e76d8032c",
+       "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": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Current iteration: 1 ,SOC: 0.0012671\n",
+      "Bandwidths: 43.0\n",
+      "Current iteration: 2 ,SOC: 0.0\n",
+      "Bandwidths: 43.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([43.])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "selector.search(verbose=True,init_multi=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Parameter check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "262"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y.shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "262"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sum(((gwr_model.params-mgwr_model.params)==0.0)==True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(619.7791467932716, 593.285603349239)"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gwr_model.aic,mgwr_model.aic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "262"
+      ]
+     },
+     "execution_count": 15,
+     "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": 16,
+   "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": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "107.0"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bw"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "selector=Sel_BW(coords,y,X_std,multi=True,family=Poisson(),offset=off)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "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": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "selector.search(verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Bandwidths: Random initialization check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Current iteration: 1 ,SOC: 0.0007503\n",
+      "Bandwidths: 43.0, 43.0, 43.0, 83.0, 44.0\n",
+      "Current iteration: 2 ,SOC: 0.0003131\n",
+      "Bandwidths: 127.0, 64.0, 77.0, 84.0, 44.0\n",
+      "Current iteration: 3 ,SOC: 0.0001606\n",
+      "Bandwidths: 261.0, 66.0, 105.0, 83.0, 44.0\n",
+      "Current iteration: 4 ,SOC: 8.07e-05\n",
+      "Bandwidths: 261.0, 66.0, 105.0, 84.0, 44.0\n",
+      "Current iteration: 5 ,SOC: 6.02e-05\n",
+      "Bandwidths: 261.0, 66.0, 134.0, 84.0, 44.0\n",
+      "Current iteration: 6 ,SOC: 4.91e-05\n",
+      "Bandwidths: 261.0, 66.0, 212.0, 83.0, 44.0\n",
+      "Current iteration: 7 ,SOC: 3.65e-05\n",
+      "Bandwidths: 261.0, 66.0, 261.0, 83.0, 44.0\n",
+      "Current iteration: 8 ,SOC: 2.91e-05\n",
+      "Bandwidths: 261.0, 66.0, 261.0, 83.0, 44.0\n",
+      "Current iteration: 9 ,SOC: 2.63e-05\n",
+      "Bandwidths: 230.0, 66.0, 261.0, 83.0, 44.0\n",
+      "Current iteration: 10 ,SOC: 2.6e-05\n",
+      "Bandwidths: 261.0, 66.0, 261.0, 84.0, 44.0\n",
+      "Current iteration: 11 ,SOC: 1.42e-05\n",
+      "Bandwidths: 261.0, 66.0, 261.0, 84.0, 44.0\n",
+      "Current iteration: 12 ,SOC: 1.09e-05\n",
+      "Bandwidths: 261.0, 66.0, 261.0, 84.0, 44.0\n",
+      "Current iteration: 13 ,SOC: 8.4e-06\n",
+      "Bandwidths: 261.0, 66.0, 261.0, 84.0, 44.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([261.,  66., 261.,  84.,  44.])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "selector.search(verbose=True, init_multi=50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8a19051703d147b698f328ae003150e6",
+       "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": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(300.34506038726374, 368.06775592811084)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mgwr_model.aicc,gwr_model.aicc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(300.1097583063385, 363.3233070483762)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mgwr_model.aic,gwr_model.aic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(317.9895317310377, 446.3004709644055)"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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_Poisson-MGWR.ipynb b/notebooks/Simulated_data_example_Poisson-MGWR.ipynb
new file mode 100644
index 0000000..3685531
--- /dev/null
+++ b/notebooks/Simulated_data_example_Poisson-MGWR.ipynb
@@ -0,0 +1,1081 @@
+{
+ "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": [
+    "### 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": [
+       "([], <a list of 0 Text yticklabel objects>)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "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": [
+       "([], <a list of 0 Text yticklabel objects>)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "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": [
+       "([], <a list of 0 Text yticklabel objects>)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 288x288 with 2 Axes>"
+      ]
+     },
+     "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": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1e9b0c42160>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1e9b0bd0f60>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.distplot(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1e9b0d159e8>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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, rss_score=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "67a571e062b6464dabc78e26c823ee55",
+       "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.023205\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": [
+       "(4330.024596599273, 4266.854231511965)"
+      ]
+     },
+     "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": [
+       "162.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.0063221\n",
+      "Bandwidths: 455.0, 455.0, 60.0\n",
+      "Current iteration: 2 ,SOC: 0.0007777\n",
+      "Bandwidths: 624.0, 457.0, 61.0\n",
+      "Current iteration: 3 ,SOC: 1.78e-05\n",
+      "Bandwidths: 624.0, 457.0, 61.0\n",
+      "Current iteration: 4 ,SOC: 2.1e-06\n",
+      "Bandwidths: 624.0, 457.0, 61.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([624., 457.,  61.])"
+      ]
+     },
+     "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": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Current iteration: 1 ,SOC: 0.0117993\n",
+      "Bandwidths: 402.0, 134.0, 77.0\n",
+      "Current iteration: 2 ,SOC: 0.0043856\n",
+      "Bandwidths: 624.0, 44.0, 60.0\n",
+      "Current iteration: 3 ,SOC: 0.0005842\n",
+      "Bandwidths: 624.0, 44.0, 60.0\n",
+      "Current iteration: 4 ,SOC: 0.0001745\n",
+      "Bandwidths: 624.0, 44.0, 60.0\n",
+      "Current iteration: 5 ,SOC: 6.19e-05\n",
+      "Bandwidths: 624.0, 44.0, 60.0\n",
+      "Current iteration: 6 ,SOC: 2.25e-05\n",
+      "Bandwidths: 624.0, 44.0, 60.0\n",
+      "Current iteration: 7 ,SOC: 8.2e-06\n",
+      "Bandwidths: 624.0, 44.0, 60.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([624.,  44.,  60.])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "selector.search(verbose=True,init_multi=600)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9a326ef5659a4d61964973f11973d49f",
+       "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([134.83018867])"
+      ]
+     },
+     "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": [
+       "(696.7491366565467, 3247.395870625656)"
+      ]
+     },
+     "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.705962\n",
+      "         Iterations 8\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, 15 Aug 2019   Pseudo R-squ.:                  0.8344\n",
+      "Time:                        11:29:38   Log-Likelihood:                -1066.2\n",
+      "converged:                       True   LL-Null:                       -6438.5\n",
+      "                                        LLR p-value:                     0.000\n",
+      "==============================================================================\n",
+      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
+      "------------------------------------------------------------------------------\n",
+      "const          0.2623      0.034      7.721      0.000       0.196       0.329\n",
+      "x1             1.2202      0.016     74.727      0.000       1.188       1.252\n",
+      "x2             1.2113      0.020     62.057      0.000       1.173       1.250\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.0058148\n",
+      "Bandwidths: 625.0, 625.0, 625.0\n",
+      "Current iteration: 2 ,SOC: 0.0009443\n",
+      "Bandwidths: 625.0, 625.0, 625.0\n",
+      "Current iteration: 3 ,SOC: 0.0001478\n",
+      "Bandwidths: 625.0, 625.0, 625.0\n",
+      "Current iteration: 4 ,SOC: 3e-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": "a17bc7e57c594d6091d7300a50fd21ad",
+       "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": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.31376269, 1.19092495, 1.17748787])"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.mean(mgwr_model.params,axis=0)"
+   ]
+  },
+  {
+   "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
+}