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

junshan_kit/ParametersHub.py

@@ -1,60 +1,110 @@
 import numpy as np
-import sys, os, torch, random
+import sys, os, torch, random, glob
 import argparse
-import junshan_kit.ModelsHub as ModelsHub
+from datetime import datetime
+script_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.join(script_dir, 'src'))
+from junshan_kit import ModelsHub, Check_Info
 
 
-class check_args:
+class args: 
     def __init__(self):
         pass
-
+    
+    # <args>
     def get_args(self):
         parser = argparse.ArgumentParser(description="Combined config argument example")
 
-        allowed_models = ["LS", "LRL2","ResNet18"]
-        allowed_optimizers = ["ADAM", "SGD", "Bundle"]
+# <allowed_models>
+        allowed_models = ["LS", "LRBL2", "ResNet18"]
+# <allowed_models>
+
+# <allowed_optimizers>
+        allowed_optimizers = [
+            "ADAM",
+            "ALR_SMAG",
+            "Bundle",
+            "SGD", 
+            "SPBM_TR",
+            "SPBM_PF",
+            "SPSmax",
+            "SPBM_TR_NoneSpecial",
+            "SPBM_TR_NoneLower",
+            "SPBM_PF_NoneLower",
+        ]
+# <allowed_optimizers>
+
+# <allowed_datasets>
+        allowed_datasets = [
+            "MNIST", 
+            "CIFAR100",
+            "Caltech101",
+            "AIP", 
+            "CCFD",
+            "Duke",
+            "Ijcnn",
+            "DHI",
+            "EVP",
+            "GHP",
+            "HL",
+            "HQC",
+            "TN_Weather",
+        ],
+# <allowed_datasets>  
+        data_name_mapping = {
+            "MNIST": "MNIST",
+            "CIFAR100": "CIFAR100",
+            "Caltech101": "Caltech101_Resize_32",
+            "Duke": "Duke",
+            "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",
+            "HL": "Health_Lifestyle",
+            "HQC": "Homesite_Quote_Conversion",
+            "TN_Weather": "TN_Weather_2020_2025",
+        }
 
-        allowed_datasets = ["MNIST", 
-                            "CIFAR100",
-                            "AIP", 
-                            "CCFD",
-                            ]
-        
         optimizers_mapping = {
             "ADAM": "ADAM",
             "SGD": "SGD",
-            "Bundle": "Bundle"
+            "Bundle": "Bundle",
+            "ALR_SMAG": "ALR-SMAG",
+            "SPBM_TR": "SPBM-TR",
+            "SPBM_PF": "SPBM-PF",
+            "SPSmax": "SPSmax",
+            "SPBM_TR_NoneSpecial": "SPBM-TR-NoneSpecial",
+            "SPBM_TR_NoneLower": "SPBM-TR-NoneLower",
+            "SPBM_TR_NoneCut": "SPBM-TR-NoneCut",
+            "SPBM_PF_NoneSpecial": "SPBM-PF-NoneSpecial",
+            "SPBM_PF_NoneLower": "SPBM-PF-NoneLower",
+            "SPBM_PF_NoneCut": "SPBM-PF-NoneCut"
         }
 
         model_mapping = {
             "LS": "LeastSquares",
-            "LRL2": "LogRegressionBinaryL2",
+            "LRBL2": "LogRegressionBinaryL2",
             "ResNet18": "ResNet18"
         }
-        
-        data_name_mapping = {
-            "MNIST": "MNIST",
-            "CIFAR100": "CIFAR100",
-            "AIP": "Adult_Income_Prediction",
-            "CCFD": "Credit_Card_Fraud_Detection"
-        }
 
-        
-
-        # Single combined argument that can appear multiple times
+# <args_from_command>
         parser.add_argument(
             "--train",
             type=str,
             nargs="+",                   # Allow multiple configs
             required=True,
-            help = f"Format: model-dataset-optimizer (e.g., ResNet18-CIFAR10-Adam). model: {model_mapping}, \n datasets: {allowed_datasets}, optimizers: {allowed_optimizers},"
+            help = f"Format: model-dataset-optimizer (e.g., ResNet18-CIFAR100-ADAM). model: {allowed_models},\n datasets: {allowed_datasets},\n optimizers: {allowed_optimizers},"
         )
 
         parser.add_argument(
-        "--e",
-        type=int,
-        required=True,
-        help="Number of training epochs. Example: --e 50"
+            "--e",
+            type=int,
+            required=True,
+            help="Number of training epochs. Example: --e 50"
         )
 
         parser.add_argument(
@@ -88,63 +138,84 @@ class check_args:
         )
 
         parser.add_argument(
-        "--subset",
-        type=float,
-        nargs=2,
-        # required=True,
-        help = "Two subset ratios (train, test), e.g., --subset 0.7 0.3 or --subset 500 500"
+            "--subset",
+            type=float,
+            nargs=2,
+            # required=True,
+            help = "Two subset ratios (train, test), e.g., --subset 0.7 0.3 or --subset 500 500"
         )
 
-        args = parser.parse_args()
-        args.model_name_mapping = model_mapping
-        args.data_name_mapping = data_name_mapping
-        args.optimizers_name_mapping = optimizers_mapping
+        parser.add_argument(
+            "--time_str",
+            type=str,
+            nargs=1,
+            # required=True,
+            help = "the str of time"
+        )
 
+        parser.add_argument(
+            "--send_email",
+            type=str,
+            nargs=3,
+            # required=True,
+            help = "from_email to_email, from_pwd"
+        )
 
-        if args.subset is not None:
-            self.check_subset_info(args, parser)
+        parser.add_argument(
+            "--user_search_grid",
+            type=int,
+            nargs=1,
+            # 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>
 
-        self.check_args(args, parser, allowed_models, allowed_optimizers, allowed_datasets)
+        args = parser.parse_args()
+        args.model_name_mapping = model_mapping
+        args.data_name_mapping = data_name_mapping
+        args.optimizers_name_mapping = optimizers_mapping
 
         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")
     
-    def check_subset_info(self, args, parser):
-        total = sum(args.subset)
-        if args.subset[0]>1:
-            # CHECK
-            for i in args.subset:
-                if i < 1:
-                    parser.error(f"Invalid --subset {args.subset}: The number of subdata must > 1")    
-        else:
-            if abs(total - 1.0) != 0.0:  
-                parser.error(f"Invalid --subset {args.subset}: the values must sum to 1.0 (current sum = {total:.6f}))")
-
-
-    def check_args(self, 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("-")
-            
-                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}")
-
-            except ValueError:
-                parser.error(f"Invalid format '{cfg}'. Use model-dataset-optimizer")
-
-        for cfg in args.train:
-            model_name, dataset_name, optimizer_name = cfg.split("-")
-            try:
-                f = getattr(ModelsHub, f"Build_{args.model_name_mapping[model_name]}_{args.data_name_mapping[dataset_name]}")
-
-            except:
-                print(getattr(ModelsHub, f"Build_{args.model_name_mapping[model_name]}_{args.data_name_mapping[dataset_name]}"))
-                assert False
+    # <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]
+        OtherParas["from_pwd"] = args.send_email[2]
+        OtherParas["send_email"] = True
+    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"]}'
+
+    return OtherParas
 
 def get_train_group(args):
     training_group = []
@@ -163,8 +234,10 @@ def set_paras(args, OtherParas):
         # Print loss every N epochs.
         "epoch_log_interval": 1,
 
+        "use_log_scale": True,
+        
         # Timestamp string for result saving.
-        "time_str": ["time_str"],
+        "time_str": OtherParas["time_str"],
 
         # Random seed
         "seed": args.seed,
@@ -182,18 +255,23 @@ def set_paras(args, OtherParas):
         "split_train_data": args.s,
 
         # select_subset
-        "select_subset": args.subset
+        "select_subset": args.subset,
+
+        # Results_dict
+        "Results_dict": {},
+
+        # type: bool
+        "user_search_grid": OtherParas["user_search_grid"],
     }
 
     Paras = model_list(Paras)
     Paras = model_type(Paras)
     Paras = data_list(Paras)
-    Paras = optimizer_dict(Paras, OtherParas)
+    Paras = optimizer_paras_dict(Paras, OtherParas)
     Paras = device(Paras)
         
     return Paras
 
-
 def set_seed(seed=42):
     torch.manual_seed(seed)
     torch.cuda.manual_seed_all(seed)
@@ -234,34 +312,6 @@ def model_type(Paras) -> dict:
     return Paras
 
 def data_list(Paras) -> dict:
-    """
-    Attach a predefined list of dataset names to the parameter dictionary.
-
-    The predefined datasets include:
-    - Duke:
-        - classes: 2
-        - data: 42 (38 + 4)
-        - features: 7,129
-    - Ijcnn:
-        - classes: 2
-        - data: (35,000 + 91,701)
-        - features: 22
-    - w8a:
-        - classes: 2
-        - data: (49,749 + 14,951)
-        - features: 300
-    - RCV1
-    - Shuttle
-    - Letter
-    - Vowel
-    - MNIST
-    - CIFAR100
-    - CALTECH101_Resize_32
-    - Adult Income Prediction
-        - 
-    - Credit_Card_Fraud_Detection
-    """
-
     data_list = [
         "Duke",
         "Ijcnn",
@@ -272,15 +322,21 @@ def data_list(Paras) -> dict:
         "Vowel",
         "MNIST",
         "CIFAR100",
-        "CALTECH101_Resize_32",
+        "Caltech101_Resize_32",
         "Adult_Income_Prediction",
-        "Credit_Card_Fraud_Detection"
+        "Credit_Card_Fraud_Detection",
+        "Diabetes_Health_Indicators",
+        "Electric_Vehicle_Population",
+        "Global_House_Purchase",
+        "Health_Lifestyle",
+        "Homesite_Quote_Conversion",
+        "TN_Weather_2020_2025"
     ]
     Paras["data_list"] = data_list
     return Paras
 
 
-def optimizer_dict(Paras, OtherParas)->dict:
+def optimizer_paras_dict(Paras, OtherParas)->dict:
     optimizer_dict = {
     # ----------------- ADAM --------------------
     "ADAM": {
@@ -289,7 +345,7 @@ def optimizer_dict(Paras, OtherParas)->dict:
             "alpha": (
                 [0.5 * 1e-3, 1e-3, 2 * 1e-3]
                 if OtherParas["SeleParasOn"]
-                else [0.0005]
+                else [1e-3]
             ),
             "epsilon": [1e-8],
             "beta1": [0.9],
@@ -314,7 +370,7 @@ def optimizer_dict(Paras, OtherParas)->dict:
             "delta": (
                 [2**i for i in range(-8, 9)]
                 if OtherParas["SeleParasOn"]
-                else [0.25]
+                else [0.01]
             ),
             "cutting_number": [10],
         },
@@ -323,7 +379,7 @@ def optimizer_dict(Paras, OtherParas)->dict:
     "SGD": {
         "params": {
             "alpha": (
-                [2**i for i in range(-8, 9)] if OtherParas["SeleParasOn"] else [0.5]
+                [2**i for i in range(-8, 9)] if OtherParas["SeleParasOn"] else [0.001]
             )
         }
     },
@@ -386,6 +442,18 @@ def optimizer_dict(Paras, OtherParas)->dict:
             "cutting_number": [10],
         },
     },
+    # ----------- SPBM-TR-NoneCut -----------
+    "SPBM-TR-NoneCut": {
+        "params": {
+            "delta": (
+                [2**i for i in range(-8, 9)]
+                if OtherParas["SeleParasOn"]
+                else [1]
+            ),
+            "cutting_number": [10],
+        },
+    },
+
     # ------------- SPBM-PF-NoneLower -----------
     "SPBM-PF-NoneLower": {
         "params": {
@@ -398,13 +466,22 @@ def optimizer_dict(Paras, OtherParas)->dict:
             "cutting_number": [10],
         },
     },
+    # ----------- SPBM-PF-NoneCut -----------
+    "SPBM-PF-NoneCut": {
+        "params": {
+            "delta": (
+                [2**i for i in range(-8, 9)]
+                if OtherParas["SeleParasOn"]
+                else [1]
+            ),
+            "cutting_number": [10],
+        },
+    },
     }
 
-    Paras["optimizer_dict"] = optimizer_dict
+    Paras["optimizer_search_grid"] = optimizer_dict
     return Paras
 
-
-
 def metrics()->dict:
     metrics = {
         "epoch_loss": [],
@@ -416,4 +493,214 @@ def metrics()->dict:
         "grad_norm": [],
         "per_epoch_loss": []
     }
-    return metrics
+    return metrics
+
+
+def hyperparas_and_path(Paras, model_name, data_name, optimizer_name, params_gird):
+
+    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"]}'
+    os.makedirs(Paras["Results_folder"], exist_ok=True)
+
+    return keys, values, Paras
+
+
+def fig_ylabel(str_name):
+
+    ylabel = {
+        "training_loss": "training loss",
+        "test_loss": "test loss",
+        "training_acc": "training accuracy",
+        "test_acc": "test accuracy",
+        "grad_norm": "grad norm",
+        "per_epoch_loss": "per epoch loss",
+        "epoch_loss": "epoch loss",
+    }
+    return ylabel[str_name]
+
+def model_abbr(model_name):
+    name_map = {
+        "LogRegressionBinaryL2": "LRBL2",
+        "ResNet18": "ResNet18",
+        "ResNet34": "ResNet34",
+        "LstSquares": "LS"
+    }
+    return name_map[model_name]
+
+def dataset_abbr(model_name):
+    name_map = {
+        "MNIST": "MNIST",
+        "CIFAR100": "CIFAR100",
+        "Duke": "Duke",
+        "Ijcnn": "Ijcnn",
+        "Adult_Income_Prediction": "AIP",
+        "Credit_Card_Frau_Detection": "CCFD",
+        "Diabetes_Health_Indicators": "DHI",
+        "Electric_Vehicle_Population": "EVP",
+        "Global_House_Purchase": "GHP",
+        "Health_Lifestyle": "HL",
+    }
+    return name_map[model_name]
+
+def model_full_name(model_name):
+    model_mapping = {
+        "LS": "LeastSquares",
+        "LRBL2": "LogRegressionBinaryL2",
+        "ResNet18": "ResNet18",
+    }
+    return model_mapping[model_name]
+# <optimizers_full_name>
+def optimizers_full_name(optimizer_name):
+    name_map = {
+        "ADAM": "ADAM",
+        "SGD": "SGD",
+        "Bundle": "Bundle",
+        "ALR_SMAG": "ALR-SMAG",
+        "SPBM_TR": "SPBM-TR",
+        "SPBM_PF": "SPBM-PF",
+        "SPSmax": "SPSmax",
+        "SPBM_TR_NoneSpecial": "SPBM-TR-NoneSpecial",
+        "SPBM_TR_NoneLower": "SPBM-TR-NoneLower",
+        "SPBM_TR_NoneCut": "SPBM-TR-NoneCut",
+        "SPBM_PF_NoneSpecial": "SPBM-PF-NoneSpecial",
+        "SPBM_PF_NoneLower": "SPBM-PF-NoneLower",
+        "SPBM_PF_NoneCut": "SPBM-PF-NoneCut"
+    }
+    return name_map[optimizer_name]
+# <optimizers_full_name>
+
+# <dataset_full_name>
+def dataset_full_name(dataset_name):
+    name_map = {
+        "MNIST": "MNIST",
+        "CIFAR100": "CIFAR100",
+        "Caltech101": "Caltech101_Resize_32",
+        "Duke": "Duke",
+        "AIP": "Adult_Income_Prediction",
+        "CCFD": "Credit_Card_Fraud_Detection",
+        "Ijcnn": "Ijcnn",
+        "DHI":"Diabetes_Health_Indicators",
+        "EVP": "Electric_Vehicle_Population",
+        "GHP": "Global_House_Purchase",
+        "HL": "Health_Lifestyle",
+        "HQC": "Homesite_Quote_Conversion",
+        "TN_Weather": "TN_Weather_2020_2025",
+        }
+    return name_map[dataset_name]
+# <dataset_full_name>
+
+def opt_paras_str(opt_paras_dict):
+    # Example: "k1_v1_k2_v2_..."
+
+    keys = list(opt_paras_dict.keys())
+    values = list(opt_paras_dict.values())
+
+    param_str = "_".join(f"{k}_{v}" for k, v in zip(keys, values) if k != "ID")
+
+    return param_str
+# <set_marker_point>
+def set_marker_point(epoch_num: int) -> list:
+    marker_point = {
+        1: [0],
+        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],
+    }
+    if epoch_num not in marker_point:
+        raise ValueError(f"No marker defined for epoch {epoch_num}")
+    
+    return marker_point[epoch_num]
+
+# <set_marker_point>
+# <results_path_to_info>
+def results_path_to_info(path_list):
+    info_dict = {}
+
+    for path in path_list:
+        parts = path.split("/")
+        seed = parts[1]
+        model_name = parts[2]
+        data_name = parts[3]
+        optimizer = parts[4]
+        train_test = parts[5].split("_")
+        batch_size = parts[6].split("_")[2]
+        epochs = parts[7].split("_")[1]
+        ID = parts[8]
+
+        if model_name not in info_dict:
+            info_dict[model_name] = {}
+        
+        if data_name not in info_dict[model_name]:
+            info_dict[model_name][data_name] = {}
+        
+        if optimizer not in info_dict[model_name][data_name]:
+            info_dict[model_name][data_name][optimizer] = {}
+
+        info_dict[model_name][data_name][optimizer][ID] = {
+            "seed": seed.split("_")[1],
+            "epochs": int(epochs),
+            "train_test": (train_test[1], train_test[3]),
+            "batch_size": batch_size,
+            "marker": set_marker_point(int(epochs)),
+            "optimizer":{
+                f"{optimizer}":{
+                    "ID": ID,
+                    }
+                }
+        }
+
+    return info_dict
+# <results_path_to_info>
+
+# <update_info_dict>
+def update_info_dict(draw_data_list, draw_data, results_dict, model_name, info_dict, metric_key_dict):
+    for data_name in draw_data_list:
+        for i in draw_data[data_name]:
+            optimizer_name, ID, Opt_Paras = i
+
+            if data_name not in results_dict[model_name].keys():
+                print('*' * 40)
+                print(f'{data_name} not in results')
+                print('*' * 40)
+                assert False
+
+            # Check if optimizer_name exists in results_dict
+            if optimizer_name not in results_dict[model_name][data_name]:
+                print('*' * 40)
+                print(f'({data_name}, {optimizer_name}, {ID}) not in results_dict and \n {optimizer_name} is error.')
+                print('*' * 40)
+                assert False
+
+            # Check if ID exists in results_dict
+            if ID not in results_dict[model_name][data_name][optimizer_name]:
+                print('*' * 60)
+                print(f'({data_name}, {optimizer_name}, {ID}) not in results_dict and \n {ID} is error.')
+                print('*' * 60)
+                assert False
+
+            # Initialize info_dict[data_name] if it does not exist
+            if data_name not in info_dict:
+                info_dict[data_name] = results_dict[model_name][data_name][optimizer_name][ID].copy()
+
+            # Update optimizer parameters
+            if "optimizer" not in info_dict[data_name]:
+                info_dict[data_name]["optimizer"] = {}
+            info_dict[data_name]["optimizer"][optimizer_name] = Opt_Paras
+            info_dict[data_name]["optimizer"][optimizer_name]["ID"] = ID
+
+            # Update metric_key
+            info_dict[data_name]["metric_key"] = metric_key_dict[data_name]
+    
+    return info_dict
+# <update_info_dict>
+
+def get_results_all_pkl_path(results_folder):
+
+    pattern = os.path.join(results_folder, "**", "*.pkl")
+
+    return glob.glob(pattern, recursive=True)