black format repo

Author: jGaboardi

notebooks/Binomial_GLM.ipynb

@@ -17,14 +17,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#Load sample dataset - columbus dataset \n",
-    "db = ps.open(ps.get_path('columbus.dbf'),'r')\n",
+    "# Load sample dataset - columbus dataset\n",
+    "db = ps.open(ps.get_path(\"columbus.dbf\"), \"r\")\n",
     "\n",
-    "#Set dependent variable\n",
+    "# Set dependent variable\n",
     "y = np.array(db.by_col(\"HOVAL\"))\n",
-    "y = np.reshape(y, (49,1))\n",
+    "y = np.reshape(y, (49, 1))\n",
     "\n",
-    "#Set indepdent varibLES\n",
+    "# Set indepdent varibLES\n",
     "X = []\n",
     "X.append(db.by_col(\"INC\"))\n",
     "X.append(db.by_col(\"CRIME\"))\n",
@@ -37,12 +37,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#Estimate Gaussian GLM\n",
+    "# Estimate Gaussian GLM\n",
     "\n",
-    "#First instantiate a GLM model object\n",
-    "model = GLM(y, X) #Gaussian is the default family parameter so it doesn't need to be set\n",
+    "# First instantiate a GLM model object\n",
+    "model = GLM(\n",
+    "    y, X\n",
+    ")  # Gaussian is the default family parameter so it doesn't need to be set\n",
     "\n",
-    "#Then use the fit method to estimate coefficients and compute diagnostics\n",
+    "# Then use the fit method to estimate coefficients and compute diagnostics\n",
     "results = model.fit()"
    ]
   },
@@ -60,7 +62,7 @@
     }
    ],
    "source": [
-    "#Estimated prameters, intercept is always the first column on the left\n",
+    "# Estimated prameters, intercept is always the first column on the left\n",
     "print(results.params)"
    ]
   },
@@ -78,7 +80,7 @@
     }
    ],
    "source": [
-    "#Parameter standard errors\n",
+    "# Parameter standard errors\n",
     "print(results.bse)"
    ]
   },
@@ -96,7 +98,7 @@
     }
    ],
    "source": [
-    "#Parameter t-values\n",
+    "# Parameter t-values\n",
     "print(results.tvalues)"
    ]
   },
@@ -114,7 +116,7 @@
     }
    ],
    "source": [
-    "#Model AIC\n",
+    "# Model AIC\n",
     "print(results.aic)"
    ]
   }

notebooks/Gaussian_GLM.ipynb

@@ -18,16 +18,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#Load sample dataset - columbus dataset \n",
-    "db = ps.open(ps.get_path('columbus.dbf'),'r')\n",
+    "# Load sample dataset - columbus dataset\n",
+    "db = ps.open(ps.get_path(\"columbus.dbf\"), \"r\")\n",
     "\n",
-    "#Set dependent variable\n",
+    "# Set dependent variable\n",
     "y = np.array(db.by_col(\"HOVAL\"))\n",
-    "y = np.reshape(y, (49,1))\n",
-    "#Round dependent variable and convert to integer for the example since Poisson is for discrete data\n",
+    "y = np.reshape(y, (49, 1))\n",
+    "# Round dependent variable and convert to integer for the example since Poisson is for discrete data\n",
     "y = np.round(y).astype(int)\n",
     "\n",
-    "#Set indepdent varibLES\n",
+    "# Set indepdent varibLES\n",
     "X = []\n",
     "X.append(db.by_col(\"INC\"))\n",
     "X.append(db.by_col(\"CRIME\"))\n",
@@ -40,12 +40,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#Estimate Poisson GLM\n",
+    "# Estimate Poisson GLM\n",
     "\n",
-    "#First instantiate a GLM model object\n",
-    "model = GLM(y, X, family=Poisson()) #Set family to Poisson family object for Poisson GLM\n",
+    "# First instantiate a GLM model object\n",
+    "model = GLM(\n",
+    "    y, X, family=Poisson()\n",
+    ")  # Set family to Poisson family object for Poisson GLM\n",
     "\n",
-    "#Then use the fit method to estimate coefficients and compute diagnostics\n",
+    "# Then use the fit method to estimate coefficients and compute diagnostics\n",
     "results = model.fit()"
    ]
   },
@@ -63,7 +65,7 @@
     }
    ],
    "source": [
-    "#Estimated prameters, intercept is always the first column on the left\n",
+    "# Estimated prameters, intercept is always the first column on the left\n",
     "print(results.params)"
    ]
   },
@@ -81,7 +83,7 @@
     }
    ],
    "source": [
-    "#Parameter standard errors\n",
+    "# Parameter standard errors\n",
     "print(results.bse)"
    ]
   },
@@ -99,7 +101,7 @@
     }
    ],
    "source": [
-    "#Parameter t-values\n",
+    "# Parameter t-values\n",
     "print(results.tvalues)"
    ]
   },
@@ -117,7 +119,7 @@
     }
    ],
    "source": [
-    "#Model AIC\n",
+    "# Model AIC\n",
     "print(results.aic)"
    ]
   }

notebooks/Poisson_GLM.ipynb

@@ -1,4 +1,4 @@
-__version__ = '1.0.8'
+__version__ = "1.0.8"
 
 from . import glm
 from . import family

spglm/__init__.py

@@ -1,4 +1,3 @@
-
 from __future__ import print_function
 import numpy as np
 from scipy import stats
@@ -24,9 +23,10 @@ def __init__(self, model, params, **kwd):
     def initialize(self, model, params, **kwd):
         self.params = params
         self.model = model
-        if hasattr(model, 'k_constant'):
+        if hasattr(model, "k_constant"):
             self.k_constant = model.k_constant
 
+
 # TODO: public method?
 
 
@@ -176,61 +176,69 @@ class LikelihoodModelResults(Results):
                 True: converged. False: did not converge.
             allvecs : list
                 Results at each iteration.
-        """
+    """
 
     # by default we use normal distribution
     # can be overwritten by instances or subclasses
     use_t = False
 
-    def __init__(self, model, params, normalized_cov_params=None, scale=1.,
-                 **kwargs):
+    def __init__(self, model, params, normalized_cov_params=None, scale=1.0, **kwargs):
         super(LikelihoodModelResults, self).__init__(model, params)
         self.normalized_cov_params = normalized_cov_params
         self.scale = scale
 
         # robust covariance
         # We put cov_type in kwargs so subclasses can decide in fit whether to
         # use this generic implementation
-        if 'use_t' in kwargs:
-            use_t = kwargs['use_t']
+        if "use_t" in kwargs:
+            use_t = kwargs["use_t"]
             if use_t is not None:
                 self.use_t = use_t
-        if 'cov_type' in kwargs:
-            cov_type = kwargs.get('cov_type', 'nonrobust')
-            cov_kwds = kwargs.get('cov_kwds', {})
-
-            if cov_type == 'nonrobust':
-                self.cov_type = 'nonrobust'
-                self.cov_kwds = {'description': 'Standard Errors assume that the ' +
-                                 'covariance matrix of the errors is correctly ' +
-                                 'specified.'}
+        if "cov_type" in kwargs:
+            cov_type = kwargs.get("cov_type", "nonrobust")
+            cov_kwds = kwargs.get("cov_kwds", {})
+
+            if cov_type == "nonrobust":
+                self.cov_type = "nonrobust"
+                self.cov_kwds = {
+                    "description": "Standard Errors assume that the "
+                    + "covariance matrix of the errors is correctly "
+                    + "specified."
+                }
             else:
                 from statsmodels.base.covtype import get_robustcov_results
+
                 if cov_kwds is None:
                     cov_kwds = {}
                 use_t = self.use_t
                 # TODO: we shouldn't need use_t in get_robustcov_results
-                get_robustcov_results(self, cov_type=cov_type, use_self=True,
-                                      use_t=use_t, **cov_kwds)
+                get_robustcov_results(
+                    self, cov_type=cov_type, use_self=True, use_t=use_t, **cov_kwds
+                )
 
     def normalized_cov_params(self):
         raise NotImplementedError
 
-    def _get_robustcov_results(self, cov_type='nonrobust', use_self=True,
-                               use_t=None, **cov_kwds):
+    def _get_robustcov_results(
+        self, cov_type="nonrobust", use_self=True, use_t=None, **cov_kwds
+    ):
         from statsmodels.base.covtype import get_robustcov_results
+
         if cov_kwds is None:
             cov_kwds = {}
 
-        if cov_type == 'nonrobust':
-            self.cov_type = 'nonrobust'
-            self.cov_kwds = {'description': 'Standard Errors assume that the ' +
-                             'covariance matrix of the errors is correctly ' +
-                             'specified.'}
+        if cov_type == "nonrobust":
+            self.cov_type = "nonrobust"
+            self.cov_kwds = {
+                "description": "Standard Errors assume that the "
+                + "covariance matrix of the errors is correctly "
+                + "specified."
+            }
         else:
             # TODO: we shouldn't need use_t in get_robustcov_results
-            get_robustcov_results(self, cov_type=cov_type, use_self=True,
-                                  use_t=use_t, **cov_kwds)
+            get_robustcov_results(
+                self, cov_type=cov_type, use_self=True, use_t=use_t, **cov_kwds
+            )
 
     @cache_readonly
     def llf(self):
@@ -250,13 +258,14 @@ def tvalues(self):
     @cache_readonly
     def pvalues(self):
         if self.use_t:
-            df_resid = getattr(self, 'df_resid_inference', self.df_resid)
+            df_resid = getattr(self, "df_resid_inference", self.df_resid)
             return stats.t.sf(np.abs(self.tvalues), df_resid) * 2
         else:
             return stats.norm.sf(np.abs(self.tvalues)) * 2
 
-    def cov_params(self, r_matrix=None, column=None, scale=None, cov_p=None,
-                   other=None):
+    def cov_params(
+        self, r_matrix=None, column=None, scale=None, cov_p=None, other=None
+    ):
         """
         Returns the variance/covariance matrix.
         The variance/covariance matrix can be of a linear contrast
@@ -293,24 +302,30 @@ def cov_params(self, r_matrix=None, column=None, scale=None, cov_p=None,
         OR
         ``(scale) * (X.T X)^(-1)[column][:,column]`` if column is 1d
         """
-        if (hasattr(self, 'mle_settings') and
-                self.mle_settings['optimizer'] in ['l1', 'l1_cvxopt_cp']):
+        if hasattr(self, "mle_settings") and self.mle_settings["optimizer"] in [
+            "l1",
+            "l1_cvxopt_cp",
+        ]:
             dot_fun = nan_dot
         else:
             dot_fun = np.dot
 
-        if (cov_p is None and self.normalized_cov_params is None and
-                not hasattr(self, 'cov_params_default')):
-            raise ValueError('need covariance of parameters for computing '
-                             '(unnormalized) covariances')
+        if (
+            cov_p is None
+            and self.normalized_cov_params is None
+            and not hasattr(self, "cov_params_default")
+        ):
+            raise ValueError(
+                "need covariance of parameters for computing "
+                "(unnormalized) covariances"
+            )
         if column is not None and (r_matrix is not None or other is not None):
-            raise ValueError('Column should be specified without other '
-                             'arguments.')
+            raise ValueError("Column should be specified without other " "arguments.")
         if other is not None and r_matrix is None:
-            raise ValueError('other can only be specified with r_matrix')
+            raise ValueError("other can only be specified with r_matrix")
 
         if cov_p is None:
-            if hasattr(self, 'cov_params_default'):
+            if hasattr(self, "cov_params_default"):
                 cov_p = self.cov_params_default
             else:
                 if scale is None:
@@ -337,7 +352,7 @@ def cov_params(self, r_matrix=None, column=None, scale=None, cov_p=None,
         else:  # if r_matrix is None and column is None:
             return cov_p
 
-    def conf_int(self, alpha=.05, cols=None, method='default'):
+    def conf_int(self, alpha=0.05, cols=None, method="default"):
         """
         Returns the confidence interval of the fitted parameters.
 
@@ -396,7 +411,7 @@ def conf_int(self, alpha=.05, cols=None, method='default'):
 
         if self.use_t:
             dist = stats.t
-            df_resid = getattr(self, 'df_resid_inference', self.df_resid)
+            df_resid = getattr(self, "df_resid_inference", self.df_resid)
             q = dist.ppf(1 - alpha / 2, df_resid)
         else:
             dist = stats.norm