tests path sol

Author: statmlben

rehline/__init__.py

@@ -1,15 +1,17 @@
 # Import from internal C++ module
 from ._base import (ReHLine_solver, _BaseReHLine,
                     _make_constraint_rehline_param, _make_loss_rehline_param)
-from ._class import ReHLine, plqERM_Ridge, CQR_Ridge
+from ._class import CQR_Ridge, ReHLine, plqERM_Ridge
 from ._data import make_fair_classification
 from ._internal import rehline_internal, rehline_result
+from ._path_sol import plqERM_Ridge_path_sol
 
 __all__ = ("ReHLine_solver",
            "_BaseReHLine",
            "ReHLine",
            "plqERM_Ridge",
            "CQR_Ridge",
+           "plqERM_Ridge_path_sol",
            "_make_loss_rehline_param",
            "_make_constraint_rehline_param"
            "make_fair_classification")

rehline/_path_sol.py

@@ -1,8 +1,10 @@
-import numpy as np
 import time
+
 import matplotlib.pyplot as plt
-from rehline import plqERM_Ridge
-from rehline import _make_loss_rehline_param
+import numpy as np
+
+from ._base import _make_loss_rehline_param
+from ._class import plqERM_Ridge
 from ._loss import ReHLoss
 
 
@@ -11,7 +13,7 @@ def plqERM_Ridge_path_sol(
     y,
     *,
     loss,
-    constraint=[ ],
+    constraint=[],
     eps=1e-3,
     n_Cs=100,
     Cs=None,
@@ -139,35 +141,47 @@ def plqERM_Ridge_path_sol(
     U, V, Tau, S, T = _make_loss_rehline_param(loss, X, y)
     loss_obj = ReHLoss(U, V, S, T, Tau)
 
+    # Lambda_ws = np.empty(shape=(0, 0))
+    # Gamma_ws = np.empty(shape=(0, 0))
+    # xi_ws = np.empty(shape=(0, 0))
+
+    clf = plqERM_Ridge(
+        loss=loss, constraint=constraint, C=Cs[0],
+        max_iter=max_iter, tol=tol, shrink=shrink, verbose=verbose,
+        warm_start=warm_start
+    )
+
     for i, C in enumerate(Cs):
         if return_time:
             start_time = time.time()
 
-        clf = plqERM_Ridge(
-            loss=loss, constraint=constraint, C=C,
-            max_iter=max_iter, tol=tol, shrink=shrink, verbose=verbose,
-            warm_start=warm_start
-        )
+        clf.C = C
+
+        # clf = plqERM_Ridge(
+        #     loss=loss, constraint=constraint, C=C,
+        #     max_iter=max_iter, tol=tol, shrink=shrink, verbose=verbose,
+        #     warm_start=warm_start
+        # )
 
-        if warm_start and (i>0):
-            clf.Lambda = Lambda
-            clf.Gamma = Gamma
-            clf.xi = xi
+        # if (warm_start and (i>0)):
+        #     clf.Lambda = Lambda_ws
+        #     clf.Gamma = Gamma_ws
+        #     clf.xi = xi_ws
 
         clf.fit(X, y)
         coefs[:, i] = clf.coef_
 
         # Compute loss function parameters for ReHLoss
-        l2_norm = 0.5 * np.linalg.norm(clf.coef_) ** 2
+        l2_norm = np.linalg.norm(clf.coef_) ** 2
         score = clf.decision_function(X)
-        total_loss = loss_obj(score) + l2_norm
+        total_loss = loss_obj(score) + 0.5*l2_norm
         loss_values.append(round(total_loss, 4))
         L2_norms.append(round(np.linalg.norm(clf.coef_), 4))
 
-        if warm_start:
-            Lambda = clf.Lambda
-            Gamma = clf.Gamma
-            xi = clf.xi
+        # if warm_start:
+        #     Lambda_ws = clf.Lambda
+        #     Gamma_ws = clf.Gamma
+        #     xi_ws = clf.xi
 
         if return_time:
             elapsed_time = time.time() - start_time

tests/_test_path_sol.py

@@ -0,0 +1,64 @@
+import time
+
+import matplotlib.pyplot as plt
+import numpy as np
+## load datasets
+from sklearn.datasets import make_hastie_10_2
+
+from rehline import plqERM_Ridge_path_sol
+
+X, y = make_hastie_10_2()
+
+# define loss function
+loss = {'name': 'svm'}
+Cs = np.logspace(-20, 10, 50, base=2)  # Define a range of C values for the path
+
+# calculate with warm_start=False
+# Cs_values_cold, times_cold, n_iters_cold, loss_values_cold, L2_norms_cold, coefs_cold = plqERM_Ridge_path_sol(
+#     X, y,
+#     loss=loss,
+#     Cs=Cs,
+#     max_iter=5000000,
+#     tol=1e-4,
+#     verbose=0,
+#     warm_start=False,
+#     constraint=[],
+#     return_time=True,
+#     plot_path=True
+# )
+
+# calculate with warm_start=True
+Cs_values_warm, times_warm, n_iters_warm, loss_values_warm, L2_norms_warm, coefs_warm = plqERM_Ridge_path_sol(
+    X, y,
+    loss=loss,
+    Cs=Cs,
+    max_iter=1000000,
+    tol=1e-4,
+    verbose=1,
+    warm_start=True,
+    constraint=[],
+    return_time=True,
+    plot_path=True
+)
+
+
+# # Plot Cs vs times comparison
+# plt.figure(figsize=(10, 6))
+# plt.plot(Cs, times_warm, 'o-', label='Warm Start')
+# plt.plot(Cs, times_cold, 's-', label='Cold Start')
+# plt.xscale('log', base=2)
+# plt.xlabel('C values')
+# plt.ylabel('Time (seconds)')
+# plt.title('Computation Time vs. C Parameter')
+# plt.legend()
+# plt.grid(True)
+# plt.show()
+
+
+# # Print table comparing number of iterations
+# print("\nComparison of Number of Iterations:")
+# print("-" * 50)
+# print(f"{'C Value':^15} | {'Cold Start (iterations)':^20} | {'Warm Start (iterations)':^20}")
+# print("-" * 50)
+# for i, C in enumerate(Cs):
+#     print(f"{C:^15.4f} | {n_iters_cold[i]:^20d} | {n_iters_warm[i]:^20d}")