fixed calling utils_for_glm_tests to utils_for_glm_hglm_tests.

h2oai · Oct 21, 2024 · dc61200 · dc61200
1 parent 283b66b
commit dc61200
Show file tree

Hide file tree

Showing 13 changed files with 59 additions and 60 deletions.
diff --git a/...tdir_algos/glm/pyunit_GH_6722_beta_equality_loose_lessthan_linear_constraints_binomial.py b/...tdir_algos/glm/pyunit_GH_6722_beta_equality_loose_lessthan_linear_constraints_binomial.py
@@ -161,7 +161,7 @@ def test_constraints_binomial():
     constraint_alpha = [0.01]
     constraint_beta = [0.5, 0.9]
     constraint_c0 = [40]
-    h2o_glm_random_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_random_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                         family="binomial",
                                                                         linear_constraints=linear_constraints2,
                                                                         beta_constraints=beta_constraints,
@@ -174,12 +174,12 @@ def test_constraints_binomial():
                                                                         return_best=False)                                                             
     init_random_logloss = h2o_glm_random_init.model_performance()._metric_json['logloss']
     print("logloss with constraints and coefficients initialized random initial values: {0}, number of iterations"
-          " taken to build the model: {1}".format(init_random_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_random_init)))
+          " taken to build the model: {1}".format(init_random_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_random_init)))
     print(glm.getConstraintsInfo(h2o_glm_random_init))
 
 
     # GLM model with GLM coefficients with default initialization
-    h2o_glm_default_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_default_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                          family="binomial",
                                                                          linear_constraints=linear_constraints2,
                                                                          beta_constraints=beta_constraints,
@@ -191,7 +191,7 @@ def test_constraints_binomial():
                                                                          return_best=False)
     default_init_logloss = h2o_glm_default_init.model_performance()._metric_json['logloss']
     print("logloss with constraints and default coefficients initialization: {0}, number of iterations"
-          " taken to build the model: {1}".format(default_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_default_init)))
+          " taken to build the model: {1}".format(default_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_default_init)))
     print(glm.getConstraintsInfo(h2o_glm_default_init))
 
 

diff --git a/...testdir_algos/glm/pyunit_GH_6722_beta_linear_constraints_binomial_objective_likelihood.py b/...testdir_algos/glm/pyunit_GH_6722_beta_linear_constraints_binomial_objective_likelihood.py
@@ -94,7 +94,7 @@ def test_constraints_objective_likelihood():
     obj_optimal = h2o_glm_optimal_init.average_objective()
     print("logloss with constraints and coefficients initialized with glm model built without constraints: {0}, aic: "
           "{2}, llh: {3}, average_objective: {4}, number of iterations taken to build the model: "
-          "{1}".format(init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_optimal_init), aic_optimal,
+          "{1}".format(init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_optimal_init), aic_optimal,
                        ll_optimal, obj_optimal))
     print(glm.getConstraintsInfo(h2o_glm_optimal_init))
 
@@ -124,7 +124,7 @@ def test_constraints_objective_likelihood():
     init_random_logloss = h2o_glm_random_init.model_performance()._metric_json['logloss']
     print("logloss with constraints and coefficients initialized random initial values: {0}, aic: {2}, llh: {3}, "
           "average objective: {4}, number of iterations taken to build the model: "
-          "{1}".format(init_random_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_random_init), aic_random,
+          "{1}".format(init_random_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_random_init), aic_random,
                        ll_random, obj_random))
     print(glm.getConstraintsInfo(h2o_glm_random_init))
 
@@ -141,7 +141,7 @@ def test_constraints_objective_likelihood():
     default_init_logloss = h2o_glm_default_init.model_performance()._metric_json['logloss']
     print("logloss with constraints and default coefficients initialization: {0}, aic: {2}, llh: {3}, average objective:"
           " {4}, number of iterations taken to build the model: "
-          "{1}".format(default_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_default_init), aic_default,
+          "{1}".format(default_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_default_init), aic_default,
                        ll_default, obj_default))
     print(glm.getConstraintsInfo(h2o_glm_default_init))
 

diff --git a/h2o-py/tests/testdir_algos/glm/pyunit_GH_6722_equality_constraints_only_binomial.py b/h2o-py/tests/testdir_algos/glm/pyunit_GH_6722_equality_constraints_only_binomial.py
@@ -94,7 +94,7 @@ def test_equality_constraints_only_binomial():
     constraint_alpha = [0.01]
     constraint_beta = [0.1]
     constraint_c0 = [15, 20]
-    h2o_glm_random_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_random_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                         family="binomial",
                                                                         linear_constraints=linear_constraints2,
                                                                         startval=random_coef,
@@ -110,7 +110,7 @@ def test_equality_constraints_only_binomial():
     print(glm.getConstraintsInfo(h2o_glm_random_init))
 
     # GLM model with GLM coefficients with default initialization
-    h2o_glm_default_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_default_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                          family="binomial",
                                                                          linear_constraints=linear_constraints2,
                                                                          constraint_eta0=constraint_eta0,

diff --git a/...s/testdir_algos/glm/pyunit_GH_6722_equality_loose_lessthan_linear_constraints_binomial.py b/...s/testdir_algos/glm/pyunit_GH_6722_equality_loose_lessthan_linear_constraints_binomial.py
@@ -128,7 +128,7 @@ def test_equality_linear_constraints_binomial():
     constraint_alpha = [0.1]
     constraint_beta = [0.9]
     constraint_c0 = [10] # initial value
-    h2o_glm_random_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_random_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                         family="binomial",
                                                                         linear_constraints=linear_constraints2,
                                                                         startval=random_coef,
@@ -139,11 +139,11 @@ def test_equality_linear_constraints_binomial():
                                                                         constraint_c0=constraint_c0, return_best=False)
     init_random_logloss = h2o_glm_random_init.model_performance()._metric_json['logloss']
     print("logloss with constraints and coefficients initialized random initial values: {0}, number of iterations"
-          " taken to build the model: {1}".format(init_random_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_random_init)))
+          " taken to build the model: {1}".format(init_random_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_random_init)))
     print(glm.getConstraintsInfo(h2o_glm_random_init))
 
     # GLM model with GLM coefficients with default initialization
-    h2o_glm_default_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_default_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                          family="binomial",
                                                                          linear_constraints=linear_constraints2,
                                                                          constraint_eta0=constraint_eta0,
@@ -153,7 +153,7 @@ def test_equality_linear_constraints_binomial():
                                                                          constraint_c0=constraint_c0, return_best=False)
     default_init_logloss = h2o_glm_default_init.model_performance()._metric_json['logloss']
     print("logloss with constraints and default coefficients initialization: {0}, number of iterations"
-          " taken to build the model: {1}".format(default_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_default_init)))
+          " taken to build the model: {1}".format(default_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_default_init)))
     print(glm.getConstraintsInfo(h2o_glm_default_init))
 
     assert abs(logloss-init_logloss)<1e-6, "logloss from optimal GLM {0} and logloss from GLM with loose constraints " \

diff --git a/...stdir_algos/glm/pyunit_GH_6722_light_tight_beta_equality_lessthan_constraints_binomial.py b/...stdir_algos/glm/pyunit_GH_6722_light_tight_beta_equality_lessthan_constraints_binomial.py
@@ -132,7 +132,7 @@ def test_light_tight_linear_constraints_binomial():
     constraint_beta = [0.9]
     constraint_c0 = [5, 10] # initial value
     # GLM model with with GLM coefficients set to GLM model coefficients built without constraints
-    h2o_glm_optimal_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_optimal_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                          family="binomial",
                                                                          linear_constraints=linear_constraints2,
                                                                          beta_constraints=beta_constraints,
@@ -145,10 +145,10 @@ def test_light_tight_linear_constraints_binomial():
                                                                          return_best=False, epsilon=0.5)
     optimal_init_logloss = h2o_glm_optimal_init.model_performance()._metric_json['logloss']
     print("logloss with optimal GLM coefficient initializaiton: {0}, number of iterations taken to build the model: "
-          "{1}".format(optimal_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_optimal_init)))
+          "{1}".format(optimal_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_optimal_init)))
     print(glm.getConstraintsInfo(h2o_glm_optimal_init))
 
-    h2o_glm_default_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_default_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                          family="binomial",
                                                                          linear_constraints=linear_constraints2,
                                                                          beta_constraints=beta_constraints,
@@ -161,7 +161,7 @@ def test_light_tight_linear_constraints_binomial():
                                                                          return_best=False, epsilon=0.5)
     default_init_logloss = h2o_glm_default_init.model_performance()._metric_json['logloss']
     print("logloss with default GLM coefficient initializaiton: {0}, number of iterations taken to build the model: "
-          "{1}".format(default_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_default_init)))
+          "{1}".format(default_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_default_init)))
     print(glm.getConstraintsInfo(h2o_glm_default_init))
     random_coef = [0.9740393731418461, 0.9021970400494406, 0.8337282995102272, 0.20588758679724872, 0.12522385214612453,
                    0.6390730524643073, 0.7055779213989253, 0.9004255614099713, 0.4075431157767999, 0.161093231584713,
@@ -178,7 +178,7 @@ def test_light_tight_linear_constraints_binomial():
                    0.4941250734508458, 0.5446841276322587, 0.19222703209695946, 0.9232239752817498, 0.8824688635063289,
                    0.224690851359456, 0.5809304720756304, 0.36863807988348585]
 
-    h2o_glm_random_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_random_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                         family="binomial",
                                                                         linear_constraints=linear_constraints2,
                                                                         beta_constraints=beta_constraints,
@@ -192,7 +192,7 @@ def test_light_tight_linear_constraints_binomial():
                                                                         return_best=False, epsilon=0.5)
     random_init_logloss = h2o_glm_random_init.model_performance()._metric_json['logloss']
     print("logloss with random GLM coefficient initializaiton: {0}, number of iterations taken to build the model: "
-          "{1}".format(random_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_random_init)))
+          "{1}".format(random_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_random_init)))
     print(glm.getConstraintsInfo(h2o_glm_random_init))
 
     assert logloss <= optimal_init_logloss, "logloss from optimal GLM {0} should be lower than logloss from GLM with light tight" \

diff --git a/...ts/testdir_algos/glm/pyunit_GH_6722_light_tight_equality_lessthan_constraints_binomial.py b/...ts/testdir_algos/glm/pyunit_GH_6722_light_tight_equality_lessthan_constraints_binomial.py
@@ -111,7 +111,7 @@ def test_light_tight_linear_constraints_only_binomial():
     constraint_beta = [0.9]
     constraint_c0 = [10, 20] # initial value
     # GLM model with with GLM coefficients set to GLM model coefficients built without constraints
-    h2o_glm_optimal_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_optimal_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                          family="binomial",
                                                                          linear_constraints=linear_constraints2,
                                                                          init_optimal_glm=True,
@@ -123,10 +123,10 @@ def test_light_tight_linear_constraints_only_binomial():
                                                                          return_best=False)
     optimal_init_logloss = h2o_glm_optimal_init.model_performance()._metric_json['logloss']
     print("logloss with optimal GLM coefficient initializaiton: {0}, number of iterations taken to build the model: "
-          "{1}".format(optimal_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_optimal_init)))
+          "{1}".format(optimal_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_optimal_init)))
     print(glm.getConstraintsInfo(h2o_glm_optimal_init))
 
-    h2o_glm_default_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_default_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                          family="binomial",
                                                                          linear_constraints=linear_constraints2,
                                                                          init_optimal_glm=False,
@@ -139,7 +139,7 @@ def test_light_tight_linear_constraints_only_binomial():
                                                                          epsilon=5e-1)
     default_init_logloss = h2o_glm_default_init.model_performance()._metric_json['logloss']
     print("logloss with default GLM coefficient initializaiton: {0}, number of iterations taken to build the model: "
-          "{1}".format(default_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_default_init)))
+          "{1}".format(default_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_default_init)))
     print(glm.getConstraintsInfo(h2o_glm_default_init))
     random_coef = [0.9740393731418461, 0.9021970400494406, 0.8337282995102272, 0.20588758679724872, 0.12522385214612453,
                    0.6390730524643073, 0.7055779213989253, 0.9004255614099713, 0.4075431157767999, 0.161093231584713,
@@ -156,7 +156,7 @@ def test_light_tight_linear_constraints_only_binomial():
                    0.4941250734508458, 0.5446841276322587, 0.19222703209695946, 0.9232239752817498, 0.8824688635063289,
                    0.224690851359456, 0.5809304720756304, 0.36863807988348585]
 
-    h2o_glm_random_init = utils_for_glm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
+    h2o_glm_random_init = utils_for_glm_hglm_tests.constraint_glm_gridsearch(train, predictors, response, solver="IRLSM",
                                                                         family="binomial",
                                                                         linear_constraints=linear_constraints2,
                                                                         startval=random_coef,
@@ -170,7 +170,7 @@ def test_light_tight_linear_constraints_only_binomial():
                                                                         epsilon=5e-1)
     random_init_logloss = h2o_glm_random_init.model_performance()._metric_json['logloss']
     print("logloss with random GLM coefficient initializaiton: {0}, number of iterations taken to build the model: "
-          "{1}".format(random_init_logloss, utils_for_glm_tests.find_model_iterations(h2o_glm_random_init)))
+          "{1}".format(random_init_logloss, utils_for_glm_hglm_tests.find_model_iterations(h2o_glm_random_init)))
     print(glm.getConstraintsInfo(h2o_glm_random_init))
 
     assert abs(logloss - optimal_init_logloss)<1e-6, "logloss from optimal GLM {0} should be close to logloss from GLM with light tight" \