fixed some small bugs and cleaned up

Author: davidsebfischer

batchglm/train/tf/glm_nb/estimator.py

@@ -185,29 +185,29 @@ def init_par(
                 logger.info("Should train r: %s", self._train_scale)
 
         if init_model is not None:
+            # Locations model:
             if isinstance(init_a, str) and (init_a.lower() == "auto" or init_a.lower() == "init_model"):
-                # location
                 my_loc_names = set(self.input_data.design_loc_names.values)
                 my_loc_names = my_loc_names.intersection(init_model.input_data.design_loc_names.values)
 
                 init_loc = np.zeros([self.input_data.num_loc_params, self.input_data.num_features])
                 for parm in my_loc_names:
                     init_idx = np.where(init_model.input_data.design_loc_names == parm)
-                    my_idx = np.where(input_data.design_loc_names == parm)
+                    my_idx = np.where(self.input_data.design_loc_names == parm)
                     init_loc[my_idx] = init_model.par_link_loc[init_idx]
 
                 init_a = init_loc
                 logger.info("Using initialization based on input model for mean")
 
+            # Scale model:
             if isinstance(init_b, str) and (init_b.lower() == "auto" or init_b.lower() == "init_model"):
-                # scale
-                my_scale_names = set(input_data.design_scale_names.values)
+                my_scale_names = set(self.input_data.design_scale_names.values)
                 my_scale_names = my_scale_names.intersection(init_model.input_data.design_scale_names.values)
 
                 init_scale = np.zeros([self.input_data.num_scale_params, self.input_data.num_features])
                 for parm in my_scale_names:
                     init_idx = np.where(init_model.input_data.design_scale_names == parm)
-                    my_idx = np.where(input_data.design_scale_names == parm)
+                    my_idx = np.where(self.input_data.design_scale_names == parm)
                     init_scale[my_idx] = init_model.par_link_scale[init_idx]
 
                 init_b = init_scale

batchglm/train/tf/glm_nb/fim.py

@@ -32,11 +32,11 @@ def _W_bb(
         digamma_r = tf.math.digamma(x=r)
         digamma_r_plus_mu = tf.math.digamma(x=r_plus_mu)
 
-        const1 = tf.multiply(scalar_two, tf.add(  # [observations, features]
+        const1 = tf.multiply(scalar_two, tf.add(
             digamma_r,
             digamma_r_plus_mu
         ))
-        const2 = tf.multiply(r, tf.add(  # [observations, features]
+        const2 = tf.multiply(r, tf.add(
             tf.math.polygamma(a=scalar_one, x=r),
             tf.math.polygamma(a=scalar_one, x=r_plus_mu)
         ))

batchglm/train/tf/glm_nb/hessians.py

@@ -16,9 +16,9 @@ def _W_ab(
             r,
     ):
         const = tf.multiply(
-            mu * r,  # [observations, features]
+            mu * r,
             tf.divide(
-                X - mu,  # [observations, features]
+                X - mu,
                 tf.square(mu + r)
             )
         )
@@ -31,7 +31,7 @@ def _W_aa(
             r,
     ):
         const = tf.negative(tf.multiply(
-            mu,  # [observations, features]
+            mu,
             tf.divide(
                 (X / r) + 1,
                 tf.square((mu / r) + 1)
@@ -51,11 +51,11 @@ def _W_bb(
         r_plus_mu = r + mu
         r_plus_x = r + X
         # Define graphs for individual terms of constant term of hessian:
-        const1 = tf.add(  # [observations, features]
+        const1 = tf.add(
             tf.math.digamma(x=r_plus_x),
             r * tf.math.polygamma(a=scalar_one, x=r_plus_x)
         )
-        const2 = tf.negative(tf.add(  # [observations, features]
+        const2 = tf.negative(tf.add(
             tf.math.digamma(x=r),
             r * tf.math.polygamma(a=scalar_one, x=r)
         ))
@@ -66,11 +66,11 @@ def _W_bb(
             ),
             tf.square(r_plus_mu)
         ))
-        const4 = tf.add(  # [observations, features]
+        const4 = tf.add(
             tf.log(r),
             scalar_two - tf.log(r_plus_mu)
         )
-        const = tf.add_n([const1, const2, const3, const4])  # [observations, features]
+        const = tf.add_n([const1, const2, const3, const4])
         const = tf.multiply(r, const)
         return const
 

batchglm/unit_test/base_glm/test_extreme_values_glm.py

@@ -1,10 +1,15 @@
 import abc
+import logging
 from typing import List
 import unittest
 import numpy as np
 
+import batchglm.api as glm
 from batchglm.models.base_glm import _Estimator_GLM, InputData, _Simulator_GLM
 
+glm.setup_logging(verbosity="WARNING", stream="STDOUT")
+logger = logging.getLogger(__name__)
+
 
 class _Test_ExtremValues_GLM_Estim():
 
@@ -23,7 +28,7 @@ def estimate(
                 "convergence_criteria": "all_converged_ll",
                 "stopping_criteria": 1e-4,
                 "use_batching": False,
-                "optim_algo": "Newton",
+                "optim_algo": "IRLS",
             },
         ])