junshan-kit 2.5.1__py2.py3-none-any.whl → 2.8.5__py2.py3-none-any.whl

junshan_kit/FiguresHub.py

@@ -0,0 +1,290 @@
+"""
+----------------------------------------------------------------------
+>>> Author       : Junshan Yin
+>>> Last Updated : 2025-12-19
+----------------------------------------------------------------------
+"""
+import math, os
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib as mpl
+from collections import defaultdict
+from junshan_kit import kit, ParametersHub
+
+def marker_schedule(marker_schedule=None):
+
+    if marker_schedule == "SPBM":
+        based_marker = {
+            "ADAM": "s",  # square
+            "ALR-SMAG": "h",  # pixel marker
+            "Bundle": "o",  # circle
+            "SGD": "p",  # pentagon
+            "SPSmax": "4",  # tri-right
+            "SPBM-PF": "*",  # star
+            "SPBM-TR": "s",  # star
+            "SPBM-PF-NoneCut": "s",  # circle
+            "SPBM-TR-NoneCut": "s",  # circle
+        }
+        
+    else:
+        based_marker = {
+            "point": ".",  # point marker
+            "pixel": ",",  # pixel marker
+            "circle": "o",  # circle
+            "triangle_down": "v",  # down triangle
+            "triangle_up": "^",  # up triangle
+            "triangle_left": "<",  # left triangle
+            "triangle_right": ">",  # right triangle
+            "tri_down": "1",  # tri-down
+            "tri_up": "2",  # tri-up
+            "tri_left": "3",  # tri-left
+            "tri_right": "4",  # tri-right
+            "square": "s",  # square
+            "pentagon": "p",  # pentagon
+            "star": "*",  # star
+            "hexagon1": "h",  # hexagon 1
+            "hexagon2": "H",  # hexagon 2
+            "plus": "+",  # plus
+            "x": "x",  # x
+            "diamond": "D",  # diamond
+            "thin_diamond": "d",  # thin diamond
+            "vline": "|",  # vertical line
+            "hline": "_",  # horizontal line
+        }
+
+    return based_marker
+
+
+def colors_schedule(colors_schedule=None):
+
+    if colors_schedule == "SPBM":
+        based_color = {
+            "ADAM":      "#7f7f7f",  
+            "ALR-SMAG":  "#796378",  
+            "Bundle":    "#17becf",  
+            "SGD":       "#2ca02c",  
+            "SPSmax":    "#BA6262",  
+            "SPBM-PF":   "#1f77b4",  
+            "SPBM-TR":   "#d62728",  
+            "SPBM-PF-NoneCut": "#8c564b",
+            "SPBM-TR-NoneCut": "#e377c2",
+        }
+
+    else:
+        based_color = {
+            "ADAM":     "#1f77b4",
+            "ALR-SMAG": "#ff7f0e",
+            "Bundle":   "#2ca02c",
+            "SGD":      "#d62728",
+            "SPSmax":   "#9467bd",
+            "SPBM-PF":  "#8c564b",
+            "SPBM-TR":  "#e377c2",
+            "dddd":     "#7f7f7f",
+            "xxx":      "#bcbd22",
+            "ED":       "#17becf",
+        }
+    return based_color
+
+
+def Search_Paras(Paras, args, model_name, data_name, optimizer_name, metric_key = "training_loss"):
+
+    param_dict = Paras["Results_dict"][model_name][data_name][optimizer_name]
+
+    num_polts = len(param_dict)
+    cols = 3
+    rows = math.ceil(num_polts / cols)
+
+    fig, axes = plt.subplots(rows, cols, figsize=(5 * cols, 4 * rows))
+    axes = axes.flatten()
+
+    for idx, (param_str, info) in enumerate(param_dict.items()):
+        ax = axes[idx]
+        metric_list = info.get(metric_key, [])
+        # duration = info.get('duration', 0)
+        ax.plot(metric_list)
+        # ax.set_title(f"time:{duration:.8f}s - seed: {Paras['seed']}, ID: {Paras['time_str']} \n params = {param_str}", fontsize=10)
+        ax.set_title(f'time = {info["train_time"]:.2f}, seed: {Paras["seed"]}, ID: {Paras["time_str"]} \n params = {param_str}', fontsize=10)
+        ax.set_xlabel("epochs")
+        ax.set_ylabel(ParametersHub.fig_ylabel(metric_key))
+        ax.grid(True)
+        if Paras.get('use_log_scale', False) and any(k in metric_key for k in ['loss', 'grad']):
+            ax.set_yscale("log")
+
+
+    # Delete the redundant subfigures
+    for i in range(len(param_dict), len(axes)):
+        fig.delaxes(axes[i])
+
+    
+    plt.suptitle(f'{model_name} on {data_name} - {optimizer_name}, (training, test) = ({Paras['train_data_num']}/{Paras['train_data_all_num']}, {Paras['test_data_num']}/{Paras['test_data_all_num']}), {Paras["device"]}, batch_size: {Paras["batch_size"]}', fontsize=16)
+    plt.tight_layout(rect=(0, 0, 1, 0.9))
+
+    filename = f'{Paras["Results_folder"]}/{metric_key}_{ParametersHub.model_abbr(model_name)}_{data_name}_{optimizer_name}.pdf'
+    fig.savefig(filename)
+    print(f"✅ Saved: {filename}")
+    plt.close('all')
+
+
+def Read_Results_from_pkl(info_dict, Exp_name, model_name):
+    draw_data = defaultdict(dict)
+    for data_name, info in info_dict.items():
+        for optimizer_name, info_opt in info["optimizer"].items():
+            
+            pkl_path = f'{Exp_name}/seed_{info["seed"]}/{model_name}/{data_name}/{optimizer_name}/train_{info["train_test"][0]}_test_{info["train_test"][1]}/Batch_size_{info["batch_size"]}/epoch_{info["epochs"]}/{info_opt["ID"]}/Results_{ParametersHub.model_abbr(model_name)}_{data_name}_{optimizer_name}.pkl'
+
+            data_ = kit.read_pkl_data(pkl_path)
+
+            param_str = ParametersHub.opt_paras_str(info["optimizer"][optimizer_name])
+
+            # draw_data[data_name][optimizer_name] = data_[param_str][info["metric_key"]]
+            # draw_data[data_name][optimizer_name][param_str] = param_str
+            # Store both metric list and parameter string
+            draw_data[data_name][optimizer_name] = {
+                "metrics": data_[param_str][info["metric_key"]],
+                "param_str": param_str
+            }
+
+    return draw_data
+
+
+
+def Mul_Plot(model_name, info_dict, Exp_name = "SPBM", cols = 3, save_path = None, save_name = None, fig_show = False):
+    # matplotlib settings
+    mpl.rcParams['font.family'] = 'Times New Roman'
+    mpl.rcParams["mathtext.fontset"] = "stix"
+    mpl.rcParams["axes.unicode_minus"] = False
+    mpl.rcParams["font.size"] = 12
+    mpl.rcParams["font.family"] = "serif"
+    
+    # Read data
+    draw_data = defaultdict(dict)
+    for data_name, info in info_dict.items():
+        for optimizer_name, info_opt in info["optimizer"].items():
+            
+            pkl_path = f'{Exp_name}/seed_{info["seed"]}/{model_name}/{data_name}/{optimizer_name}/train_{info["train_test"][0]}_test_{info["train_test"][1]}/Batch_size_{info["batch_size"]}/epoch_{info["epochs"]}/{info_opt["ID"]}/Results_{ParametersHub.model_abbr(model_name)}_{data_name}_{optimizer_name}.pkl'
+
+            data_ = kit.read_pkl_data(pkl_path)
+
+            param_str = ParametersHub.opt_paras_str(info["optimizer"][optimizer_name])
+
+            draw_data[data_name][optimizer_name] = data_[param_str][info["metric_key"]]
+        
+    
+    # Draw figures
+    num_datasets = len(draw_data)
+    
+    nrows = math.ceil(num_datasets / cols)
+    
+    fig, axes = plt.subplots(nrows, cols, figsize=(5 * cols, 4 * nrows), squeeze=False)
+    axes = axes.flatten()
+
+    for idx, (data_name, info) in enumerate(draw_data.items()):
+        ax = axes[idx]
+        for optimizer_name, metric_list in info.items():
+            ax.plot(metric_list, label=optimizer_name, color = colors_schedule("SPBM")[optimizer_name])
+
+            # marker
+            if info_dict[data_name]["marker"] is not None:
+                x = np.array(info_dict[data_name]["marker"])
+
+                metric_list_arr = np.array(metric_list)
+
+                ax.scatter(x, metric_list_arr[x], marker=marker_schedule("SPBM")[optimizer_name], color = colors_schedule("SPBM")[optimizer_name])
+
+        ax.set_title(f'{data_name}', fontsize=12)
+        ax.set_xlabel("epochs", fontsize=12)
+        ax.set_ylabel(ParametersHub.fig_ylabel(info_dict[data_name]["metric_key"]), fontsize=12) 
+        if any(k in info_dict[data_name]["metric_key"] for k in ['loss', 'grad']):
+            ax.set_yscale("log")
+        ax.grid(True)
+
+    # Hide redundant axes
+    for ax in axes[num_datasets:]:
+        ax.axis('off')
+
+    # legend
+    all_handles, all_labels = [], []
+    for ax in axes[:num_datasets]:
+        h, l = ax.get_legend_handles_labels()
+        all_handles.extend(h)
+        all_labels.extend(l)
+    
+    # duplicate removal
+    unique = dict(zip(all_labels, all_handles))
+    handles = list(unique.values())
+    labels = list(unique.keys())
+    
+    fig.legend(
+        handles,
+        labels,
+        loc="lower center",
+        bbox_to_anchor=(0.5, -0.08),
+        ncol=len(handles),
+        fontsize=12
+    )
+
+    plt.tight_layout()
+    if save_path is None:
+        save_path_ = f'{model_name}.pdf'
+    else:
+        os.makedirs(save_path, exist_ok=True)
+        save_path_ = f'{save_path}/{save_name}.pdf'
+    plt.savefig(save_path_, bbox_inches="tight")
+    if fig_show:
+        plt.show()
+    plt.close()  # Colse the fig
+    
+
+
+def Opt_Paras_Plot(model_name, info_dict, Exp_name = "SPBM", save_path = None, save_name = None, fig_show = False):
+
+    mpl.rcParams['font.family'] = 'Times New Roman'
+    mpl.rcParams["mathtext.fontset"] = "stix"
+    mpl.rcParams["axes.unicode_minus"] = False
+    mpl.rcParams["font.size"] = 12
+    mpl.rcParams["font.family"] = "serif"
+
+    # Read data
+    draw_data = Read_Results_from_pkl(info_dict, Exp_name, model_name)
+
+    if len(draw_data) >1:
+        print('*' * 40)
+        print("Only one data can be drawn at a time.")
+        print(info_dict.keys())
+        print('*' * 40)
+        assert False
+
+    plt.figure(figsize=(9, 6))  # Optional: set figure size
+    
+    data_name = None  
+
+    for data_name, _info in draw_data.items():
+        for optimizer_name, metric_dict in _info.items():
+            plt.plot(metric_dict["metrics"], label=f'{optimizer_name}_{metric_dict["param_str"]}',
+                    color=colors_schedule("SPBM")[optimizer_name])
+
+    if data_name is not None:  
+        plt.title(f'{data_name}')
+
+    plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=1) 
+    plt.grid(True)
+
+    if any(k in info_dict[data_name]["metric_key"] for k in ['loss', 'grad']):
+        plt.yscale("log")
+
+    plt.tight_layout()  # Adjust layout so the legend fits
+    plt.xlabel("epochs")  # Or whatever your x-axis represents
+    plt.ylabel(f'{ParametersHub.fig_ylabel(info_dict[data_name]["metric_key"])}')  
+    if save_path is None:
+        save_path_ = f'{model_name}.pdf'
+    else:
+        os.makedirs(save_path, exist_ok=True)
+        save_path_ = f'{save_path}/{save_name}.pdf'
+    plt.savefig(save_path_, bbox_inches="tight")
+    if fig_show:
+        plt.show()
+    
+    plt.close()
+    
+
+

junshan_kit/ModelsHub.py

@@ -5,7 +5,7 @@ import torch.nn as nn
 
 
 # ---------------- Build ResNet18 - Caltech101 -----------------------
-def Build_ResNet18_CALTECH101_Resize_32():
+def Build_ResNet18_Caltech101_Resize_32():
     
     """
     1. Modify the first convolutional layer for smaller input (e.g., 32x32 instead of 224x224)
@@ -72,7 +72,7 @@ def Build_ResNet34_MNIST():
     return model
 
 # ---------------- Build ResNet34 - Caltech101 -----------------------
-def Build_ResNet34_CALTECH101_Resize_32():
+def Build_ResNet34_Caltech101_Resize_32():
     
     model = resnet34(weights=None)
     model.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
@@ -104,7 +104,7 @@ def Build_LeastSquares_CIFAR100():
         nn.Linear(3 * 32 * 32, 100))
 
 # ---------------- LeastSquares - Caltech101 ------------------
-def Build_LeastSquares_CALTECH101_Resize_32():
+def Build_LeastSquares_Caltech101_Resize_32():
     return nn.Sequential(
         nn.Flatten(),
         nn.Linear(3*32*32, 101)
@@ -204,9 +204,36 @@ def Build_LogRegressionBinaryL2_w8a():
 
 # ---------------------------------------------------------
 def Build_LogRegressionBinaryL2_Adult_Income_Prediction():
-    pass
+    return nn.Sequential(                   
+        nn.Linear(108, 1))
 
 
 def Build_LogRegressionBinaryL2_Credit_Card_Fraud_Detection():
-    pass
+    return nn.Sequential(                   
+        nn.Linear(30, 1))
 
+
+def Build_LogRegressionBinaryL2_Diabetes_Health_Indicators():
+    return nn.Sequential(                   
+        nn.Linear(52, 1))
+
+
+def Build_LogRegressionBinaryL2_Electric_Vehicle_Population():
+    return nn.Sequential(                   
+        nn.Linear(835, 1))
+
+def Build_LogRegressionBinaryL2_Global_House_Purchase():
+    return nn.Sequential(                   
+        nn.Linear(81, 1))
+
+def Build_LogRegressionBinaryL2_Health_Lifestyle():
+    return nn.Sequential(                   
+        nn.Linear(15, 1))
+
+def Build_LogRegressionBinaryL2_Homesite_Quote_Conversion():
+    return nn.Sequential(                   
+        nn.Linear(655, 1))
+
+def Build_LogRegressionBinaryL2_TN_Weather_2020_2025():
+    return nn.Sequential(                   
+        nn.Linear(121, 1))

junshan_kit/OptimizerHup/OptimizerFactory.py

@@ -0,0 +1,130 @@
+from junshan_kit.OptimizerHup import SPBM, SPBM_func
+import torch, time, os
+from torch.optim.optimizer import Optimizer
+from torch.nn.utils import parameters_to_vector, vector_to_parameters
+
+
+class SPSmax(Optimizer):
+    def __init__(self, params, model, hyperparams, Paras):
+        defaults = dict()
+        super().__init__(params, defaults)
+        self.model = model
+        self.c = hyperparams['c']
+        self.gamma = hyperparams['gamma']
+        if 'f_star' not in Paras or Paras['f_star'] is None:
+            self.f_star = 0
+        else:
+            self.f_star = Paras['f_star']
+        self.step_size = []
+
+    def step(self, closure=None):
+        if closure is None:
+            raise RuntimeError("Closure required for SPSmax")
+        
+        # Reset the gradient and perform forward computation
+        loss = closure()
+        
+        with torch.no_grad():
+            xk = parameters_to_vector(self.model.parameters())
+            # print(torch.norm(xk))
+            g_k = parameters_to_vector([p.grad if p.grad is not None else torch.zeros_like(p) for p in self.model.parameters()])
+
+            # Step-size
+            step_size = (loss - self.f_star) / ((self.c * torch.norm(g_k, p=2) ** 2) + 1e-8)
+            step_size = min(step_size, self.gamma)
+            self.step_size.append(step_size)
+
+            # Update
+            xk = xk - step_size * g_k
+            
+            # print(len(self.f_his))
+            vector_to_parameters(xk, self.model.parameters())
+
+
+        # emporarily return loss (tensor type)
+        return loss
+    
+
+class ALR_SMAG(Optimizer):
+    def __init__(self, params, model, hyperparams, Paras):
+        defaults = dict()
+        super().__init__(params, defaults)
+        self.model = model
+        self.c = hyperparams['c']
+        self.eta_max = hyperparams['eta_max']
+        self.beta = hyperparams['beta']
+        if 'f_star' not in Paras or Paras['f_star'] is None:
+            self.f_star = 0
+        else:
+            self.f_star = Paras['f_star']
+        self.step_size = []
+        self.d_k = torch.zeros_like(parameters_to_vector(self.model.parameters()))
+
+    def step(self, closure=None):
+        if closure is None:
+            raise RuntimeError("Closure required for SPSmax")
+        
+        # Reset the gradient and perform forward computation
+        loss = closure()
+        
+        with torch.no_grad():
+            xk = parameters_to_vector(self.model.parameters())
+            # print(torch.norm(xk))
+            g_k = parameters_to_vector([p.grad if p.grad is not None else torch.zeros_like(p) for p in self.model.parameters()])
+
+            self.d_k = self.beta * self.d_k + g_k
+            # Step-size
+            step_size = (loss - self.f_star) / ((self.c * torch.norm(self.d_k, p=2) ** 2) + 1e-8)
+            step_size = min(step_size, self.eta_max)
+            self.step_size.append(step_size)
+
+            # Update
+            xk = xk - step_size * g_k
+            
+            # print(len(self.f_his))
+            vector_to_parameters(xk, self.model.parameters())
+
+
+        # emporarily return loss (tensor type)
+        return loss
+    
+
+class Bundle(Optimizer):
+    def __init__(self, params, model, hyperparams, Paras):
+        defaults = dict()
+        super().__init__(params, defaults)
+        self.model = model
+        self.cutting_num = hyperparams['cutting_number']
+        self.delta = hyperparams['delta']
+        self.Paras = Paras
+
+        self.x_his, self.g_his, self.f_his = [], [], []
+
+    def step(self, closure=None):
+        if closure is None:
+            raise RuntimeError("Closure required for CuttingPlaneOptimizer")
+        
+        # Reset the gradient and perform forward computation
+        loss = closure()
+        
+        with torch.no_grad():
+            xk = parameters_to_vector(self.model.parameters())
+            # print(torch.norm(xk))
+            g_k = parameters_to_vector([p.grad if p.grad is not None else torch.zeros_like(p) for p in self.model.parameters()])
+
+            # Add cutting plane
+            x_his, f_his, g_his = SPBM_func.add_cutting(self.x_his, self.f_his, self.g_his,xk.detach().clone(), g_k.detach().clone(), loss.detach().clone(), self.cutting_num)
+
+            # the coefficient of dual problem
+            Gk, rk, ek = SPBM_func.get_var(x_his, f_his, g_his, self.delta)
+            
+            # SOVER (dual)
+            xk = SPBM_func.bundle(Gk, ek, xk, self.delta, self.Paras)
+            
+            # print(len(self.f_his))
+            vector_to_parameters(xk, self.model.parameters())
+
+        # loss（tensor）
+        return loss
+    
+