Pep8 compliant (almost)

Author: perellonieto

dirichletcal/__init__.py

@@ -20,7 +20,6 @@ def __init__(self, matrix_type='full', l2=0.0, comp_l2=False,
         self.comp_l2 = comp_l2
         self.initializer = initializer
 
-
     def __setup(self):
         if isinstance(self.l2, list):
             self.l2_grid = self.l2
@@ -32,16 +31,15 @@ def __setup(self):
             self.comp_l2 = [self.comp_l2]
         self.calibrator_ = None
 
-
     def fit(self, x, y, x_val=None, y_val=None, **kwargs):
         self.__setup()
 
         if self.matrix_type == 'diagonal':
             self.calibrator_ = DiagonalDirichletCalibrator(
-                l2=self.l2, initializer=self.initializer)
+               reg_lambda=self.l2, initializer=self.initializer)
         elif self.matrix_type == 'full':
             self.calibrator_ = FullDirichletCalibrator(
-                reg_lambda_list=self.l2_grid, reg_mu_list=self.comp_l2,
+                reg_lambda=self.l2, reg_mu=self.comp_l2,
                 initializer=self.initializer)
         else:
             raise ValueError
@@ -62,25 +60,29 @@ def fit(self, x, y, x_val=None, y_val=None, **kwargs):
 
     @property
     def l2_(self):
-        if (self.calibrator_ is not None) and (hasattr(self.calibrator_, 'l2')):
+        if ((self.calibrator_ is not None) and (hasattr(self.calibrator_,
+                                                        'l2'))):
             return self.calibrator_.l2
         return None
 
     @property
     def weights_(self):
-        if (self.calibrator_ is not None) and (hasattr(self.calibrator_, 'weights_')):
+        if ((self.calibrator_ is not None) and (hasattr(self.calibrator_,
+                                                        'weights_'))):
             return self.calibrator_.weights_
         return None
 
     @property
     def coef_(self):
-        if (self.calibrator_ is not None) and (hasattr(self.calibrator_, 'coef_')):
+        if ((self.calibrator_ is not None) and (hasattr(self.calibrator_,
+                                                        'coef_'))):
             return self.calibrator_.coef_
         return None
 
     @property
     def intercept_(self):
-        if (self.calibrator_ is not None) and (hasattr(self.calibrator_, 'intercept_')):
+        if (self.calibrator_ is not None) and (hasattr(self.calibrator_,
+                                                       'intercept_')):
             return self.calibrator_.intercept_
         return None
 

dirichletcal/calib/diagdirichlet.py

@@ -1,13 +1,29 @@
 import numpy as np
-
 from .multinomial import MultinomialRegression
 from .fulldirichlet import FullDirichletCalibrator
 from ..utils import clip_for_log
+from sklearn.metrics import log_loss
 
 
 class DiagonalDirichletCalibrator(FullDirichletCalibrator):
+    def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
+
+        self.weights_ = self.weights_init
+
+        if X_val is None:
+            X_val = X.copy()
+            y_val = y.copy()
+
+        _X = np.copy(X)
+        _X = np.log(clip_for_log(_X))
+        _X_val = np.copy(X_val)
+        _X_val = np.log(clip_for_log(X_val))
+
+        self.calibrator_ = MultinomialRegression(
+            method='Diag', reg_lambda=self.reg_lambda, reg_mu=self.reg_mu,
+            reg_norm=self.reg_norm, ref_row=self.ref_row,
+            optimizer=self.optimizer)
+        self.calibrator_.fit(_X, y, *args, **kwargs)
+        self.final_loss = log_loss(y_val, self.calibrator_.predict_proba(_X_val))
 
-     def fit(self, X, y, *args, **kwargs):
-        X_ = np.log(clip_for_log(X))
-        self.calibrator_ = MultinomialRegression(method='Diag', l2=self.l2).fit(X_, y, *args, **kwargs)
         return self

dirichletcal/calib/fulldirichlet.py

@@ -1,13 +1,10 @@
-import logging
 from sklearn.base import BaseEstimator, RegressorMixin
 
 import numpy as np
 from .multinomial import MultinomialRegression
 from ..utils import clip_for_log
 from sklearn.metrics import log_loss
 
-from .multinomial import _get_identity_weights
-
 
 class FullDirichletCalibrator(BaseEstimator, RegressorMixin):
     def __init__(self, reg_lambda=0.0, reg_mu=None, weights_init=None,
@@ -28,7 +25,7 @@ def __init__(self, reg_lambda=0.0, reg_mu=None, weights_init=None,
                 implements a quasi Newton method
         """
         self.reg_lambda = reg_lambda
-        self.reg_mu = reg_mu  # Complementary L2 regularization. (Off-diagonal regularization)
+        self.reg_mu = reg_mu  # Complementary L2 regularization. (Off-diagonal)
         self.weights_init = weights_init  # Input weights for initialisation
         self.initializer = initializer
         self.reg_norm = reg_norm
@@ -39,8 +36,6 @@ def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
 
         self.weights_ = self.weights_init
 
-        k = np.shape(X)[1]
-
         if X_val is None:
             X_val = X.copy()
             y_val = y.copy()
@@ -50,14 +45,12 @@ def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
         _X_val = np.copy(X_val)
         _X_val = np.log(clip_for_log(X_val))
 
-        self.calibrator_ = MultinomialRegression(method='Full',
-                                        reg_lambda=self.reg_lambda,
-                                        reg_mu=self.reg_mu,
-                                        reg_norm=self.reg_norm,
-                                        ref_row=self.ref_row,
-                                        optimizer=self.optimizer)
+        self.calibrator_ = MultinomialRegression(
+            method='Full', reg_lambda=self.reg_lambda, reg_mu=self.reg_mu,
+            reg_norm=self.reg_norm, ref_row=self.ref_row,
+            optimizer=self.optimizer)
         self.calibrator_.fit(_X, y, *args, **kwargs)
-        final_loss = log_loss(y_val, self.calibrator_.predict_proba(_X_val))
+        self.final_loss = log_loss(y_val, self.calibrator_.predict_proba(_X_val))
 
         return self
 

dirichletcal/calib/matrixscaling.py

@@ -1,20 +1,17 @@
-import logging
 from sklearn.base import BaseEstimator, RegressorMixin
 
 import numpy as np
 from .multinomial import MultinomialRegression
 from ..utils import clip_for_log
 from sklearn.metrics import log_loss
 
-from .multinomial import _get_identity_weights
-
 
 class MatrixScaling(BaseEstimator, RegressorMixin):
-    def __init__(self, reg_lambda_list=[0.0], reg_mu_list=[None], 
-                 logit_input=False, logit_constant=None, 
+    def __init__(self, reg_lambda_list=[0.0], reg_mu_list=[None],
+                 logit_input=False, logit_constant=None,
                  weights_init=None, initializer='identity'):
         self.weights_init = weights_init
-        self.logit_input=logit_input
+        self.logit_input = logit_input
         self.logit_constant = logit_constant
         self.reg_lambda_list = reg_lambda_list
         self.reg_mu_list = reg_mu_list
@@ -36,7 +33,7 @@ def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
             X_val = X.copy()
             y_val = y.copy()
 
-        if self.logit_input == False:
+        if not self.logit_input:
             _X = np.copy(X)
             _X = np.log(clip_for_log(_X))
             _X_val = np.copy(X_val)
@@ -51,14 +48,19 @@ def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
             _X = np.copy(X)
             _X_val = np.copy(X_val)
 
+        final_cal = np.nan
+        final_loss = np.nan
+        final_reg_lambda = np.nan
+        final_reg_mu = np.nan
+
         for i in range(0, len(self.reg_lambda_list)):
             for j in range(0, len(self.reg_mu_list)):
-                tmp_cal = MultinomialRegression(method='Full', 
-                                                reg_lambda=self.reg_lambda_list[i],
-                                                reg_mu=self.reg_mu_list[j])
+                tmp_cal = MultinomialRegression(
+                    method='Full', reg_lambda=self.reg_lambda_list[i],
+                    reg_mu=self.reg_mu_list[j])
                 tmp_cal.fit(_X, y, *args, **kwargs)
                 tmp_loss = log_loss(y_val, tmp_cal.predict_proba(_X_val))
-                
+
                 if (i + j) == 0:
                     final_cal = tmp_cal
                     final_loss = tmp_loss
@@ -88,7 +90,7 @@ def intercept_(self):
     def predict_proba(self, S):
         k = np.shape(S)[1]
 
-        if self.logit_input == False:
+        if not self.logit_input:
             _S = np.log(clip_for_log(np.copy(S)))
             if self.logit_constant is None:
                 _S = _S - _S[:, -1].reshape(-1, 1).repeat(k, axis=1)
@@ -102,7 +104,7 @@ def predict_proba(self, S):
     def predict(self, S):
         k = np.shape(S)[1]
 
-        if self.logit_input == False:
+        if not self.logit_input:
             _S = np.log(clip_for_log(np.copy(S)))
             if self.logit_constant is None:
                 _S = _S - _S[:, -1].reshape(-1, 1).repeat(k, axis=1)

dirichletcal/calib/multinomial.py

@@ -32,7 +32,7 @@ def __init__(self, weights_0=None, method='Full', initializer='identity',
                 implements a quasi Newton method
         """
         if method not in ['Full', 'Diag', 'FixDiag']:
-            raise(ValueError('method {} not avaliable'.format(method)))
+            raise(ValueError(f"method {method} not avaliable"))
 
         self.weights_0 = weights_0
         self.method = method
@@ -68,7 +68,6 @@ def predict(self, S):
 
         return np.asarray(self.predict_proba(S))
 
-
     def fit(self, X, y, *args, **kwargs):
 
         self.__setup()
@@ -99,8 +98,8 @@ def fit(self, X, y, *args, **kwargs):
 
         self.weights_0_ = self._get_initial_weights(self.initializer)
 
-        if (self.optimizer == 'newton'
-            or (self.optimizer == 'auto' and k <= 36)):
+        if (self.optimizer == 'newton' or
+           (self.optimizer == 'auto' and k <= 36)):
             weights = _newton_update(self.weights_0_, X_, XXT, target, k,
                                      self.method, reg_lambda=self.reg_lambda,
                                      reg_mu=self.reg_mu, ref_row=self.ref_row,
@@ -141,6 +140,8 @@ def _get_initial_weights(self, ref_row, initializer='identity'):
 
         k = len(self.classes)
 
+        weights_0 = self.weights_0_
+
         if self.weights_0_ is None:
             if initializer == 'identity':
                 weights_0 = _get_identity_weights(k, ref_row, self.method)
@@ -185,33 +186,33 @@ def _objective(params, *args):
 
 
 def _get_weights(params, k, ref_row, method):
-        ''' Reshapes the given params (weights) into the full matrix including 0
-        '''
+    '''Reshapes the given params (weights) into the full matrix including 0
+    '''
 
-        if method in ['Full', None]:
-            raw_weights = params.reshape(-1, k+1)
-            # weights = np.zeros([k, k+1])
-            # weights[:-1, :] = params.reshape(-1, k + 1)
+    if method in ['Full', None]:
+        raw_weights = params.reshape(-1, k+1)
+        # weights = np.zeros([k, k+1])
+        # weights[:-1, :] = params.reshape(-1, k + 1)
 
-        elif method == 'Diag':
-            raw_weights = np.hstack([np.diag(params[:k]),
-                                     params[k:].reshape(-1, 1)])
-            # weights[:, :-1][np.diag_indices(k)] = params[:]
+    elif method == 'Diag':
+        raw_weights = np.hstack([np.diag(params[:k]),
+                                 params[k:].reshape(-1, 1)])
+        # weights[:, :-1][np.diag_indices(k)] = params[:]
 
-        elif method == 'FixDiag':
-            raw_weights = np.hstack([np.eye(k) * params[0], np.zeros((k, 1))])
-            # weights[np.dgag_indices(k - 1)] = params[0]
-            # weights[np.diag_indices(k)] = params[0]
-        else:
-            raise(ValueError("Unknown calibration method {}".format(method)))
+    elif method == 'FixDiag':
+        raw_weights = np.hstack([np.eye(k) * params[0], np.zeros((k, 1))])
+        # weights[np.dgag_indices(k - 1)] = params[0]
+        # weights[np.diag_indices(k)] = params[0]
+    else:
+        raise(ValueError(f"Unknown calibration method {method}"))
 
-        if ref_row:
-            weights = raw_weights - np.repeat(
-                raw_weights[-1, :].reshape(1, -1), k, axis=0)
-        else:
-            weights = raw_weights
+    if ref_row:
+        weights = raw_weights - np.repeat(
+            raw_weights[-1, :].reshape(1, -1), k, axis=0)
+    else:
+        weights = raw_weights
 
-        return weights
+    return weights
 
 
 def _get_identity_weights(n_classes, ref_row, method):

dirichletcal/calib/tempscaling.py

@@ -1,17 +1,14 @@
-import logging
 from sklearn.base import BaseEstimator, RegressorMixin
 
 import numpy as np
 from .multinomial import MultinomialRegression
 from ..utils import clip_for_log
 from sklearn.metrics import log_loss
 
-from .multinomial import _get_identity_weights
-
 
 class TemperatureScaling(BaseEstimator, RegressorMixin):
-    def __init__(self, reg_lambda_list=[0.0], reg_mu_list=[None], 
-                 logit_input=False, logit_constant=None, 
+    def __init__(self, reg_lambda_list=[0.0], reg_mu_list=[None],
+                 logit_input=False, logit_constant=None,
                  weights_init=None, initializer='identity',
                  ref_row=True):
         self.weights_init = weights_init
@@ -28,7 +25,6 @@ def __setup(self):
         self.reg_mu = None
         self.weights_ = self.weights_init
 
-
     def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
 
         self.__setup()
@@ -39,7 +35,7 @@ def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
             X_val = X.copy()
             y_val = y.copy()
 
-        if self.logit_input == False:
+        if not self.logit_input:
             _X = np.copy(X)
             _X = np.log(clip_for_log(_X))
             _X_val = np.copy(X_val)
@@ -54,15 +50,19 @@ def fit(self, X, y, X_val=None, y_val=None, *args, **kwargs):
             _X = np.copy(X)
             _X_val = np.copy(X_val)
 
+        final_cal = np.nan
+        final_loss = np.nan
+        final_reg_lambda = np.nan
+        final_reg_mu = np.nan
+
         for i in range(0, len(self.reg_lambda_list)):
             for j in range(0, len(self.reg_mu_list)):
-                tmp_cal = MultinomialRegression(method='FixDiag', 
-                                                reg_lambda=self.reg_lambda_list[i],
-                                                reg_mu=self.reg_mu_list[j],
-                                                ref_row=self.ref_row)
+                tmp_cal = MultinomialRegression(
+                    method='FixDiag', reg_lambda=self.reg_lambda_list[i],
+                    reg_mu=self.reg_mu_list[j], ref_row=self.ref_row)
                 tmp_cal.fit(_X, y, *args, **kwargs)
                 tmp_loss = log_loss(y_val, tmp_cal.predict_proba(_X_val))
-                
+
                 if (i + j) == 0:
                     final_cal = tmp_cal
                     final_loss = tmp_loss
@@ -92,7 +92,7 @@ def intercept_(self):
     def predict_proba(self, S):
         k = np.shape(S)[1]
 
-        if self.logit_input == False:
+        if not self.logit_input:
             _S = np.log(clip_for_log(np.copy(S)))
             if self.logit_constant is None:
                 _S = _S - _S[:, -1].reshape(-1, 1).repeat(k, axis=1)
@@ -106,7 +106,7 @@ def predict_proba(self, S):
     def predict(self, S):
         k = np.shape(S)[1]
 
-        if self.logit_input == False:
+        if not self.logit_input:
             _S = np.log(clip_for_log(np.copy(S)))
             if self.logit_constant is None:
                 _S = _S - _S[:, -1].reshape(-1, 1).repeat(k, axis=1)