junshan-kit 2.7.3__py2.py3-none-any.whl → 2.8.6__py2.py3-none-any.whl

junshan_kit/Check_Info.py

@@ -7,22 +7,23 @@
 
 from junshan_kit import ModelsHub
 
-def check_args(self, args, parser, allowed_models, allowed_optimizers, allowed_datasets):
+def check_args(args, parser, allowed_models, allowed_optimizers, allowed_datasets):
     # Parse and validate each train_group
     for cfg in args.train:
-        try:
-            model, dataset, optimizer = cfg.split("-")
+        model, dataset, optimizer = cfg.split("-")
+
+        if model not in allowed_models:
+            parser.error(f"Invalid model '{model}'. Choose from {allowed_models}")
+
+        if optimizer not in allowed_optimizers:
+            parser.error(f"Invalid optimizer '{optimizer}'. Choose from {allowed_optimizers}")
 
-            if model not in allowed_models:
-                parser.error(f"Invalid model '{model}'. Choose from {allowed_models}")
-            if optimizer not in allowed_optimizers:
-                parser.error(f"Invalid optimizer '{optimizer}'. Choose from {allowed_optimizers}")
-            if dataset not in allowed_datasets:
-                parser.error(f"Invalid dataset '{dataset}'. Choose from {allowed_datasets}")
+        if dataset not in allowed_datasets:
+            print(type(allowed_datasets), allowed_datasets)
+            parser.error(f"Invalid dataset '{dataset}'. Choose from {allowed_datasets}")
 
-        except ValueError:
-            parser.error(f"Invalid format '{cfg}'. Use model-dataset-optimizer")
 
+    # Check if the model-dataset-optimizer combination exists
     for cfg in args.train:
         model_name, dataset_name, optimizer_name = cfg.split("-")
         try:
@@ -31,8 +32,15 @@ def check_args(self, args, parser, allowed_models, allowed_optimizers, allowed_d
         except:
             print(getattr(ModelsHub, f"Build_{args.model_name_mapping[model_name]}_{args.data_name_mapping[dataset_name]}"))
             assert False
+        
+    # Check epochs or iterations
+    if args.e is None and args.iter is None:
+        parser.error("one of --e or --iter must be specified")
+    
+    if args.e is not None and args.iter is not None:
+        parser.error("one of --e or --iter must be specified")
 
-def check_subset_info(self, args, parser):
+def check_subset_info(args, parser):
         total = sum(args.subset)
         if args.subset[0]>1:
             # CHECK

junshan_kit/DataProcessor.py

@@ -8,9 +8,11 @@
 import pandas as pd
 import numpy as np
 import torch, bz2
+from typing import Optional
 from torch.utils.data import random_split, Subset
 from sklearn.datasets import load_svmlight_file
 from sklearn.preprocessing import StandardScaler
+from junshan_kit import ParametersHub
 
 
 class CSV_TO_Pandas:
@@ -386,7 +388,7 @@ def get_libsvm_bz2_data(train_path, test_path, data_name, Paras, split = True):
     transform = "-1 → 0 for binary, y-1 for multi-class"
     train_data = LibSVMDataset_bz2(train_path)
 
-    if data_name in ["Duke", "Ijcnn"]:
+    if data_name in ["Duke", "Ijcnn", "RCV1"]:
         test_data = LibSVMDataset_bz2(test_path)
         split = False
     else:
@@ -410,3 +412,48 @@ def get_libsvm_bz2_data(train_path, test_path, data_name, Paras, split = True):
     # assert False
 
     return train_dataset, test_dataset, transform
+
+
+def subset(dataset, ratio_or_num, seed=None) -> Subset:
+    """
+    Randomly sample a subset from a dataset.
+
+    Parameters
+    ----------
+    dataset : torch.utils.data.Dataset
+        The dataset to sample from.
+    ratio_or_num : float or int
+        If float in (0, 1], treated as sampling ratio.
+        Otherwise, treated as absolute number of samples.
+    seed : int, optional
+        Random seed for reproducibility.
+
+    Returns
+    -------
+    torch.utils.data.Subset
+        A randomly sampled subset of the dataset.
+    """
+
+    if ratio_or_num < 0:
+        raise ValueError(f"ratio_or_num must be non-negative, got {ratio_or_num}")
+
+    dataset_len = len(dataset)
+
+    # Determine number of samples
+    if isinstance(ratio_or_num, float) and 0 < ratio_or_num <= 1:
+        num = max(1, int(round(dataset_len * ratio_or_num)))
+    else:
+        num = int(ratio_or_num)
+
+    # Clamp to valid range
+    num = min(max(num, 1), dataset_len)
+
+    # Create and seed generator
+    generator = torch.Generator()
+    if seed is not None:
+        generator.manual_seed(seed)
+
+    # Random sampling
+    indices = torch.randperm(dataset_len, generator=generator)[:num].tolist()
+
+    return Subset(dataset, indices)

junshan_kit/FiguresHub.py

@@ -1,7 +1,7 @@
 """
 ----------------------------------------------------------------------
 >>> Author       : Junshan Yin
->>> Last Updated : 2025-11-14
+>>> Last Updated : 2025-12-19
 ----------------------------------------------------------------------
 """
 import math, os
@@ -22,6 +22,8 @@ def marker_schedule(marker_schedule=None):
             "SPSmax": "4",  # tri-right
             "SPBM-PF": "*",  # star
             "SPBM-TR": "s",  # star
+            "SPBM-PF-NoneCut": "s",  # circle
+            "SPBM-TR-NoneCut": "s",  # circle
         }
         
     else:
@@ -64,6 +66,8 @@ def colors_schedule(colors_schedule=None):
             "SPSmax":    "#BA6262",  
             "SPBM-PF":   "#1f77b4",  
             "SPBM-TR":   "#d62728",  
+            "SPBM-PF-NoneCut": "#8c564b",
+            "SPBM-TR-NoneCut": "#e377c2",
         }
 
     else:
@@ -85,6 +89,10 @@ def colors_schedule(colors_schedule=None):
 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]
+    if Paras["epochs"] is not None:
+        xlabel = "epochs"
+    else:
+        xlabel = "iterations"
 
     num_polts = len(param_dict)
     cols = 3
@@ -100,7 +108,7 @@ def Search_Paras(Paras, args, model_name, data_name, optimizer_name, metric_key
         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_xlabel(xlabel)
         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']):
@@ -112,7 +120,7 @@ def Search_Paras(Paras, args, model_name, data_name, optimizer_name, metric_key
         fig.delaxes(axes[i])
 
     
-    plt.suptitle(f'{model_name} on {data_name} - {optimizer_name} (training/test samples: {Paras["train_data_num"]}/{Paras["test_data_num"]}), {Paras["device"]}', fontsize=16)
+    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'
@@ -123,24 +131,28 @@ def Search_Paras(Paras, args, model_name, data_name, optimizer_name, metric_key
 
 def Read_Results_from_pkl(info_dict, Exp_name, model_name):
     draw_data = defaultdict(dict)
+    xlabels = {}
     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'
+            if hasattr(info, "epochs") and info["epochs"] is not None:
+                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'
+                xlabels[data_name] = "epochs"
+
+            else:
+                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"]}/iter_{info["iter"]}/{info_opt["ID"]}/Results_{ParametersHub.model_abbr(model_name)}_{data_name}_{optimizer_name}.pkl'
+                xlabels[data_name] = "iterations"
 
             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
+    return draw_data, xlabels
 
 
 
@@ -151,13 +163,20 @@ def Mul_Plot(model_name, info_dict, Exp_name = "SPBM", cols = 3, save_path = Non
     mpl.rcParams["axes.unicode_minus"] = False
     mpl.rcParams["font.size"] = 12
     mpl.rcParams["font.family"] = "serif"
+    xlabels = {}
     
     # 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'
+            if hasattr(info, "epochs") and info["epochs"] is not None:
+                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'
+                xlabels[data_name] = "epochs"
+
+            else:
+                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"]}/iter_{info["iter"]}/{info_opt["ID"]}/Results_{ParametersHub.model_abbr(model_name)}_{data_name}_{optimizer_name}.pkl'
+                xlabels[data_name] = "iterations"
 
             data_ = kit.read_pkl_data(pkl_path)
 
@@ -188,7 +207,7 @@ def Mul_Plot(model_name, info_dict, Exp_name = "SPBM", cols = 3, save_path = Non
                 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_xlabel(xlabels[data_name], 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")
@@ -220,19 +239,19 @@ def Mul_Plot(model_name, info_dict, Exp_name = "SPBM", cols = 3, save_path = Non
     )
 
     plt.tight_layout()
-    if save_name is None:
-        save_path = f'{model_name}.pdf'
+    if save_path is None:
+        save_path_ = f'{model_name}.pdf'
     else:
-        os.makedirs(save_name, exist_ok=True)
-        save_path = f'{save_name}/{save_name}.pdf'
-    plt.savefig(save_path, bbox_inches="tight")
+        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", svae_path = None, save_name = None, fig_show = False):
+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"
@@ -241,7 +260,7 @@ def Opt_Paras_Plot(model_name, info_dict, Exp_name = "SPBM", svae_path = None, s
     mpl.rcParams["font.family"] = "serif"
 
     # Read data
-    draw_data = Read_Results_from_pkl(info_dict, Exp_name, model_name)
+    draw_data, xlabels = Read_Results_from_pkl(info_dict, Exp_name, model_name)
 
     if len(draw_data) >1:
         print('*' * 40)
@@ -269,18 +288,18 @@ def Opt_Paras_Plot(model_name, info_dict, Exp_name = "SPBM", svae_path = None, s
         plt.yscale("log")
 
     plt.tight_layout()  # Adjust layout so the legend fits
-    plt.xlabel("epochs")  # Or whatever your x-axis represents
+    plt.xlabel(xlabels[data_name])  # Or whatever your x-axis represents
     plt.ylabel(f'{ParametersHub.fig_ylabel(info_dict[data_name]["metric_key"])}')  
-    if save_name is None:
-        save_path = f'{model_name}.pdf'
+    if save_path is None:
+        save_path_ = f'{model_name}.pdf'
     else:
-        os.makedirs(save_name, exist_ok=True)
-        save_path = f'{save_name}/{save_name}.pdf'
-    plt.savefig(save_path, bbox_inches="tight")
-
+        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/OptimizerHup/SPBM.py

@@ -226,7 +226,6 @@ class TR_NoneCut(Optimizer):
         super().__init__(params, defaults)
         self.model = model
         self.cutting_num = hyperparams['cutting_number']
-        self.M = hyperparams['M']
         self.delta = hyperparams['delta']
         self.Paras = Paras
 
@@ -254,7 +253,9 @@ class TR_NoneCut(Optimizer):
             Gk, rk, ek = SPBM_func.get_var(x_his, f_his, g_his, self.delta)
             
             # SOVER (dual)
-            xk = SPBM_func.subproblem_tr_NoneLower(Gk, ek, xk, rk, self.Paras)
+            # xk = SPBM_func.subproblem_tr_NoneLower(Gk, ek, xk, rk, self.Paras)
+
+            xk = SPBM_func.subproblem_tr_2(Gk, ek, xk, rk, self.Paras)
             
             # print(len(self.f_his))
             vector_to_parameters(xk, self.model.parameters())
@@ -312,7 +313,6 @@ class PF_NoneCut(Optimizer):
         super().__init__(params, defaults)
         self.model = model
         self.cutting_num = hyperparams['cutting_number']
-        self.M = hyperparams['M']
         self.delta = hyperparams['delta']
         self.Paras = Paras
 
@@ -340,7 +340,9 @@ class PF_NoneCut(Optimizer):
             Gk, rk, ek = SPBM_func.get_var(x_his, f_his, g_his, self.delta)
             
             # SOVER (dual)
-            xk = SPBM_func.subproblem_pf_NoneLower(Gk, ek, xk, self.delta, self.Paras)
+            # xk = SPBM_func.subproblem_pf_NoneLower(Gk, ek, xk, self.delta, self.Paras)
+
+            xk = SPBM_func.subproblem_pf(Gk, ek, xk, self.delta, self.Paras)
             
             # print(len(self.f_his))
             vector_to_parameters(xk, self.model.parameters())

junshan_kit/ParametersHub.py

@@ -49,7 +49,7 @@ class args:
             "HL",
             "HQC",
             "TN_Weather",
-        ],
+        ]
 # <allowed_datasets>  
         data_name_mapping = {
             "MNIST": "MNIST",
@@ -59,6 +59,8 @@ class args:
             "AIP": "Adult_Income_Prediction",
             "CCFD": "Credit_Card_Fraud_Detection",
             "Ijcnn": "Ijcnn",
+            "RCV1": "RCV1",
+            "w8a": "w8a",
             "DHI":"Diabetes_Health_Indicators",
             "EVP": "Electric_Vehicle_Population",
             "GHP": "Global_House_Purchase",
@@ -101,10 +103,15 @@ class args:
         parser.add_argument(
             "--e",
             type=int,
-            required=True,
             help="Number of training epochs. Example: --e 50"
         )
 
+        parser.add_argument(
+            "--iter",
+            type=int,
+            help="Number of iteration. Example: --iter 50"
+        )
+
         parser.add_argument(
             "--seed",
             type=int,
@@ -166,6 +173,13 @@ class args:
             # required=True,
             help = "search_grid: 1: "
         )
+
+        parser.add_argument(
+            "--OptParas",
+            type=int,
+            nargs=1,
+            help="Number of optimization steps for parameter tuning (default: 1)"
+        )
 # <args_from_command>
 
         args = parser.parse_args()
@@ -173,20 +187,25 @@ class args:
         args.data_name_mapping = data_name_mapping
         args.optimizers_name_mapping = optimizers_mapping
 
+# <Check_Info>    
+        Check_Info.check_args(args, parser, allowed_models, allowed_optimizers, allowed_datasets)
         return args
 # <args>
 
 def UpdateOtherParas(args, OtherParas):
+    # <time_str>
     if args.time_str is not None:
         time_str = args.time_str[0]
     else:
         time_str = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
     
+    # <user_search_grid> 
     if args.user_search_grid is not None:
         OtherParas["user_search_grid"] = args.user_search_grid[0]
     else:
         OtherParas["user_search_grid"] = None
 
+    # <send_email>
     if args.send_email is not None:
         OtherParas["from_email"] = args.send_email[0]
         OtherParas["to_email"] = args.send_email[1]
@@ -195,6 +214,11 @@ def UpdateOtherParas(args, OtherParas):
     else:
         OtherParas["send_email"] = False
     
+    if args.OptParas is not None:
+        OtherParas["SeleParasOn"] = False
+    else:
+        OtherParas["SeleParasOn"] = True
+    
     OtherParas["time_str"] = time_str
     OtherParas["results_folder_name"] = f'Results_{OtherParas["exp_name"]}'
 
@@ -231,9 +255,6 @@ def set_paras(args, OtherParas):
         # batch-size 
         "batch_size": args.bs,
 
-        # epochs
-        "epochs": args.e,
-
         # split_train_data
         "split_train_data": args.s,
 
@@ -246,7 +267,8 @@ def set_paras(args, OtherParas):
         # type: bool
         "user_search_grid": OtherParas["user_search_grid"],
     }
-
+    Paras["iter"] = args.iter
+    Paras["epochs"] = args.e
     Paras = model_list(Paras)
     Paras = model_type(Paras)
     Paras = data_list(Paras)
@@ -428,7 +450,6 @@ def optimizer_paras_dict(Paras, OtherParas)->dict:
     # ----------- SPBM-TR-NoneCut -----------
     "SPBM-TR-NoneCut": {
         "params": {
-            "M": [1e-5],
             "delta": (
                 [2**i for i in range(-8, 9)]
                 if OtherParas["SeleParasOn"]
@@ -453,7 +474,6 @@ def optimizer_paras_dict(Paras, OtherParas)->dict:
     # ----------- SPBM-PF-NoneCut -----------
     "SPBM-PF-NoneCut": {
         "params": {
-            "M": [1e-5],
             "delta": (
                 [2**i for i in range(-8, 9)]
                 if OtherParas["SeleParasOn"]
@@ -485,7 +505,15 @@ def hyperparas_and_path(Paras, model_name, data_name, optimizer_name, params_gir
 
     keys, values = list(params_gird.keys()), list(params_gird.values())
 
-    Paras["Results_folder"] = f'./{Paras["results_folder_name"]}/seed_{Paras["seed"]}/{model_name}/{data_name}/{optimizer_name}/train_{Paras["train_data_num"]}_test_{Paras["test_data_num"]}/Batch_size_{Paras["batch_size"]}/epoch_{Paras["epochs"]}/{Paras["time_str"]}'
+    if Paras["epochs"] is not None:
+        Paras["Results_folder"] = f'./{Paras["results_folder_name"]}/seed_{Paras["seed"]}/{model_name}/{data_name}/{optimizer_name}/train_{Paras["train_data_num"]}_test_{Paras["test_data_num"]}/Batch_size_{Paras["batch_size"]}/epoch_{Paras["epochs"]}/{Paras["time_str"]}'
+    
+    elif Paras["iter"] is not None:
+        Paras["Results_folder"] = f'./{Paras["results_folder_name"]}/seed_{Paras["seed"]}/{model_name}/{data_name}/{optimizer_name}/train_{Paras["train_data_num"]}_test_{Paras["test_data_num"]}/Batch_size_{Paras["batch_size"]}/iter_{Paras["iter"]}/{Paras["time_str"]}'
+    
+    else:
+        assert "one of --e or --iter must be specified"
+
     os.makedirs(Paras["Results_folder"], exist_ok=True)
 
     return keys, values, Paras
@@ -588,10 +616,12 @@ def opt_paras_str(opt_paras_dict):
 def set_marker_point(epoch_num: int) -> list:
     marker_point = {
         1: [0],
+        3: [0, 2],
         4: [0, 2, 4],
         6: [0, 2, 4, 6],
         8: [0, 2, 4, 6, 8],
         10: [0, 2, 4, 6, 8, 10],
+        50: [0, 10, 20, 30, 40, 50],
         100: [0, 20, 40, 60, 80, 100],
         200: [0, 40, 80, 120, 160, 200],
     }

junshan_kit/Print_Info.py

@@ -9,51 +9,75 @@ def training_group(training_group):
     print(f"-------------------------------------------------------")
 
 
-def training_info(args, data_name, optimizer_name, hyperparams, Paras, model_name):
-    if Paras["use_color"]:
-        print("\033[90m" + "-" * 115 + "\033[0m")
+def training_info(data_name, optimizer_name, hyperparams, Paras, model_name):
+    if Paras['use_color']:
+        print('\033[90m' + '-' * 115 + '\033[0m')
+        print(
+            f'\033[32m✅ \033[34mDataset:\033[32m {data_name}, \t'
+            f'\033[34mBatch-size:\033[32m {Paras["batch_size"]}, \t'
+            f'\033[34m(training, test) = \033[32m '
+            f'({Paras["train_data_num"]}/{Paras["train_data_all_num"]}, '
+            f'{Paras["test_data_num"]}/{Paras["test_data_all_num"]}), \t'
+            f'\033[34mdevice:\033[32m {Paras["device"]}'
+        )
         print(
-            f"\033[32m✅ \033[34mDataset:\033[32m {data_name}, \t\033[34mBatch-size:\033[32m {args.bs}, \t\033[34m(training, test) = \033[32m ({Paras['train_data_num']}, {Paras['test_data_num']}), \t\033[34m device:\033[32m {Paras['device']}"
+            f'\033[32m✅ \033[34mOptimizer:\033[32m {optimizer_name}, \t'
+            f'\033[34mParams:\033[32m {hyperparams}'
         )
         print(
-            f"\033[32m✅ \033[34mOptimizer:\033[32m {optimizer_name}, \t\033[34mParams:\033[32m {hyperparams}"
+            f'\033[32m✅ \033[34mmodel:\033[32m {model_name}, \t'
+            f'\033[34mmodel type:\033[32m {Paras["model_type"][model_name]}, \t'
+            f'\033[34mloss_fn:\033[32m {Paras["loss_fn"]}'
         )
         print(
-            f'\033[32m✅ \033[34mmodel:\033[32m {model_name}, \t\033[34mmodel type:\033[32m {Paras["model_type"][model_name]},\t\033[34m loss_fn:\033[32m {Paras["loss_fn"]}'
+            f'\033[32m✅ \033[34mResults_folder:\033[32m {Paras["Results_folder"]}'
         )
-        print(f'\033[32m✅ \033[34mResults_folder:\033[32m {Paras["Results_folder"]}')
-        print("\033[90m" + "-" * 115 + "\033[0m")
+        print('\033[90m' + '-' * 115 + '\033[0m')
 
     else:
-        print("-" * 115)
+        print('-' * 115)
         print(
-            f"✅ Dataset: {data_name}, \tBatch-size: {args.bs}, \t(training, test) = ({Paras['train_data_num']}, {Paras['test_data_num']}), \tdevice: {Paras['device']}"
+            f'✅ Dataset: {data_name}, \t'
+            f'Batch-size: {Paras["batch_size"]}, \t'
+            f'(training, test) = '
+            f'({Paras["train_data_num"]}/{Paras["train_data_all_num"]}, '
+            f'{Paras["test_data_num"]}/{Paras["test_data_all_num"]}), \t'
+            f'device: {Paras["device"]}'
         )
-        print(f"✅ Optimizer: {optimizer_name}, \tParams: {hyperparams}")
+        print(f'✅ Optimizer: {optimizer_name}, \tParams: {hyperparams}')
         print(
-            f"✅ model: {model_name}, \tmodel type: {Paras['model_type'][model_name]}, \tloss_fn: {Paras['loss_fn']}"
+            f'✅ model: {model_name}, \t'
+            f'model type: {Paras["model_type"][model_name]}, \t'
+            f'loss_fn: {Paras["loss_fn"]}'
         )
-        print(f"✅ Results_folder: {Paras['Results_folder']}")
-        print("-" * 115)
-        
+        print(f'✅ Results_folder: {Paras["Results_folder"]}')
+        print('-' * 115)
 # <Step_7_2>
 
-def per_epoch_info(Paras, epoch, metrics, time):
-    if Paras["use_color"]:
-        print(
-            f'\033[34m epoch = \033[32m{epoch+1}/{Paras["epochs"]}\033[0m,\t\b'
-            f'\033[34m training_loss = \033[32m{metrics["training_loss"][epoch+1]:.4e}\033[0m,\t\b'
-            f'\033[34m training_acc = \033[32m{100 * metrics["training_acc"][epoch+1]:.2f}\033[0m,\t\b'
-            f'\033[34m time = \033[32m{time:.2f}\033[0m,\t\b')
+def per_epoch_info(Paras, epoch, metrics, epoch_time):
+    if Paras.get('epochs') is not None:
+        progress = f'{epoch + 1}/{Paras["epochs"]}'
+        progress_label = 'epoch'
+    else:
+        progress = f'{epoch + 1}/{Paras["iter"]}'
+        progress_label = 'iter'
 
+    if Paras['use_color']:
+        print(
+            f'\033[34m {progress_label} = \033[32m{progress}\033[0m,\t'
+            f'\033[34m training_loss = \033[32m{metrics["training_loss"][epoch + 1]:.4e}\033[0m,\t'
+            f'\033[34m training_acc = \033[32m{100 * metrics["training_acc"][epoch + 1]:.2f}%\033[0m,\t'
+            f'\033[34m time = \033[32m{epoch_time:.2f}s\033[0m'
+        )
     else:
         print(
-            f"epoch = {epoch+1}/{Paras['epochs']},\t"
-            f"training_loss = {metrics['training_loss'][epoch+1]:.4e},\t"
-            f"training_acc = {100 * metrics['training_acc'][epoch+1]:.2f}%,\t"
-            f"time = {time:.2f}"
+            f'{progress_label} = {progress},\t'
+            f'training_loss = {metrics["training_loss"][epoch + 1]:.4e},\t'
+            f'training_acc = {100 * metrics["training_acc"][epoch + 1]:.2f}%,\t'
+            f'time = {epoch_time:.2f}s'
         )
 
+
 def print_per_epoch_info(epoch, Paras, epoch_loss, training_loss, training_acc, test_loss, test_acc, run_time):
     epochs = Paras["epochs"][Paras["data_name"]]
     # result = [(k, f"{v:.4f}") for k, v in run_time.items()]

junshan_kit/TrainingHub.py

@@ -90,8 +90,8 @@ def load_data(model_name, data_name, Paras):
         assert False
 
     # Computing the number of data
-    Paras["train_data_num"] = len(train_dataset)
-    Paras["test_data_num"] = len(test_dataset)
+    Paras["train_data_num"], Paras["test_data_num"] = len(train_dataset), len(test_dataset)
+    Paras["train_data_all_num"], Paras["test_data_all_num"] = len(train_dataset), len(test_dataset)
 
     return train_dataset, test_dataset, Paras
 
@@ -238,7 +238,6 @@ def train(train_loader, optimizer_name, optimizer, model, loss_fn, Paras):
                 loss = 0
                 raise NotImplementedError(f"{optimizer_name} is not supported.")
 
-
         # Evaluation
         training_loss, training_acc = Evaluate_Metrics.get_loss_acc(train_loader, model, loss_fn, Paras)
 
@@ -254,6 +253,67 @@ def train(train_loader, optimizer_name, optimizer, model, loss_fn, Paras):
     return metrics
 # <training>
 
+# <training_iteration>
+def train_iteration(train_loader, optimizer_name, optimizer, model, loss_fn, Paras):
+    train_time = time.time()
+    metrics = ParametersHub.metrics()
+    for iter in range(Paras["iter"]):
+        iter_time = time.time()
+        for index, (X, Y) in enumerate(train_loader):
+            X, Y = X.to(Paras["device"]), Y.to(Paras["device"])
+
+            if iter == 0 and index == 0:
+                initial_time = time.time()
+                initial_loss, initial_correct = Evaluate_Metrics.get_loss_acc(train_loader, model, loss_fn, Paras)
+                metrics["training_loss"].append(initial_loss)
+                metrics["training_acc"].append(initial_correct)
+
+                Print_Info.per_epoch_info(Paras, -1, metrics, time.time() - initial_time)
+
+            # Update the model
+            if optimizer_name in ["SGD", "ADAM"]:
+                optimizer.zero_grad()
+                loss = Evaluate_Metrics.loss(X, Y, model, loss_fn, Paras)
+                loss.backward()
+                optimizer.step()
+
+            elif optimizer_name in [
+                "Bundle",
+                "SPBM-TR",
+                "SPBM-PF",
+                "ALR-SMAG",
+                "SPSmax",
+                "SPBM-TR-NoneSpecial",
+                "SPBM-TR-NoneLower",
+                "SPBM-TR-NoneCut",
+                "SPBM-PF-NoneCut",
+            ]:
+                def closure():
+                    optimizer.zero_grad()
+                    loss = Evaluate_Metrics.loss(X, Y, model, loss_fn, Paras)
+                    loss.backward()
+                    return loss
+
+                loss = optimizer.step(closure)
+
+            else:
+                loss = 0
+                raise NotImplementedError(f"{optimizer_name} is not supported.")
+
+        # Evaluation
+        training_loss, training_acc = Evaluate_Metrics.get_loss_acc(train_loader, model, loss_fn, Paras)
+
+        metrics["training_loss"].append(training_loss)
+        metrics["training_acc"].append(training_acc)
+
+        Print_Info.per_epoch_info(Paras, iter, metrics, time.time() - iter_time)
+    
+    time_cost = time.time() - train_time
+    metrics["train_time"] = time_cost 
+
+    return metrics
+# <training_iteration>
+
 def Record_Results(hyperparams,data_name, model_name, optimizer_name, metrics, Paras):
 
     keys = list(hyperparams.keys())

{junshan_kit-2.7.3.dist-info → junshan_kit-2.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junshan_kit
-Version: 2.7.3
+Version: 2.8.6
 Summary: This is an optimization tool.
 Author-email: Junshan Yin <junshanyin@163.com>
 Requires-Dist: cvxpy==1.6.5

{junshan_kit-2.7.3.dist-info → junshan_kit-2.8.6.dist-info}/RECORD

@@ -1,20 +1,20 @@
 junshan_kit/BenchmarkFunctions.py,sha256=tXgZGg-CjTNz78nMyVEQflVFIJDgmmePytXjY_RT9BM,120
-junshan_kit/Check_Info.py,sha256=Z6Ls2S7Fl4h8S9s0NB8jP_YpSLZInvQAeyjIXzq5Bpc,1872
+junshan_kit/Check_Info.py,sha256=CTJgzyTYA_kPbBnm3x5oH148SzbULYQnePyY8S_bpsI,2106
 junshan_kit/DataHub.py,sha256=6RCNr8dBTqK-8ey4m-baMU1qOsJP6swOFkaraGdk0fM,6801
-junshan_kit/DataProcessor.py,sha256=W2bzugcYnwQC403GdvSmGDBhfz8X1KxJBkOAVg1vHHk,14385
+junshan_kit/DataProcessor.py,sha256=Uc9ixhnVmGf5PoGIe3vvhobH_ADtDAosG9MTjnB1KDQ,15677
 junshan_kit/DataSets.py,sha256=DcpwWRm1_B29hIDjOhvaeKAYYeBknEW2QqsS_qm8Hxs,13367
 junshan_kit/Evaluate_Metrics.py,sha256=PQBGU8fETIvDon1VMdouZ1dhG2n7XHYGbzs2EQUA9FM,3392
-junshan_kit/FiguresHub.py,sha256=116cvRUGUcBqIAs0_xiRzZCzgnPaqmgI5kvNu6cAd_Q,10181
+junshan_kit/FiguresHub.py,sha256=Z9mVN3Pnklt1JhkFPd7LO-46kZnf8JRrjfJEy38H3IE,11407
 junshan_kit/ModelsHub.py,sha256=xM6cwLecq9vukrt1c9l7l9dy7mQn3yq0ZwrRg5f_CfM,7995
-junshan_kit/ParametersHub.py,sha256=RSgsSlH0bgehn27lleKfboT1MuLAyIMxZ5FWC-ANbhA,19822
-junshan_kit/Print_Info.py,sha256=uBLpeynOYSZTN8LbJupSH1SuLZ-7cMU3Yp3IlVJWB1s,4772
-junshan_kit/TrainingHub.py,sha256=WV3cUz4JsEdGTpbTqgnU3WmlKeob8RAOuL993EsADj0,11469
+junshan_kit/ParametersHub.py,sha256=pDtVEL9nx3UBtNfKfZyvXf9KXjC-OJkBwursOlSigvs,20935
+junshan_kit/Print_Info.py,sha256=xhxcq1XayMZIbNjrG_74sAa8VCNvw5osPjXQhxkgN_M,5393
+junshan_kit/TrainingHub.py,sha256=eK06q_xtcj4E6qkV-EHT2-UKv-yDDXUwx9n1EivdetQ,13775
 junshan_kit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 junshan_kit/kit.py,sha256=tQGoJJQZW9BeadX2cuwhvOxX2riHBZG0iFExelS4MIY,11487
 junshan_kit/OptimizerHup/OptimizerFactory.py,sha256=x1_cE5ZSkKffdY0uCIirocBNj2X-u_R-V5jNawJ1EfA,4607
-junshan_kit/OptimizerHup/SPBM.py,sha256=2Yg8Fmc8OkYOrjevD8eAGfI-m-fefoOldybtlp4ZEEs,13730
+junshan_kit/OptimizerHup/SPBM.py,sha256=h449QddeN0MvUIQeKcNxFsdxdBuhN354sGc_sN2LZR8,13816
 junshan_kit/OptimizerHup/SPBM_func.py,sha256=5Fz6eHYIVGMoR_CBDA_Xk_1dnPRq3K16DUNoNaWQ2Ag,17301
 junshan_kit/OptimizerHup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-junshan_kit-2.7.3.dist-info/METADATA,sha256=_mIq2RLQUdQECGnjRK4qABiPr41BGiK-aCkk4EQVKik,455
-junshan_kit-2.7.3.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
-junshan_kit-2.7.3.dist-info/RECORD,,
+junshan_kit-2.8.6.dist-info/METADATA,sha256=PzbDtkti_zBXqS4nZyt3o770Ocx5kBlriB3_LdytvIs,455
+junshan_kit-2.8.6.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
+junshan_kit-2.8.6.dist-info/RECORD,,