junshan-kit 2.8.5__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/FiguresHub.py

@@ -89,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
@@ -104,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']):
@@ -127,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
 
 
 
@@ -155,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)
 
@@ -192,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")
@@ -245,7 +260,7 @@ def Opt_Paras_Plot(model_name, info_dict, Exp_name = "SPBM", save_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)
@@ -273,7 +288,7 @@ def Opt_Paras_Plot(model_name, info_dict, Exp_name = "SPBM", save_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_path is None:
         save_path_ = f'{model_name}.pdf'

junshan_kit/ParametersHub.py

@@ -49,7 +49,7 @@ class args:
             "HL",
             "HQC",
             "TN_Weather",
-        ],
+        ]
 # <allowed_datasets>  
         data_name_mapping = {
             "MNIST": "MNIST",
@@ -103,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,
@@ -182,6 +187,8 @@ 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>
 
@@ -248,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,
 
@@ -263,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)
@@ -500,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
@@ -603,6 +616,7 @@ 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],

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['train_data_all_num']}, {Paras['test_data_num']}/{Paras['test_data_all_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['train_data_all_num']}, {Paras['test_data_num']}/{Paras['test_data_all_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

@@ -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.8.5.dist-info → junshan_kit-2.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junshan_kit
-Version: 2.8.5
+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.8.5.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=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=TVbo9ioEECrH_iJjpt0HgkCoiAdFEcTdtiUtzDNYrJY,10455
+junshan_kit/FiguresHub.py,sha256=Z9mVN3Pnklt1JhkFPd7LO-46kZnf8JRrjfJEy38H3IE,11407
 junshan_kit/ModelsHub.py,sha256=xM6cwLecq9vukrt1c9l7l9dy7mQn3yq0ZwrRg5f_CfM,7995
-junshan_kit/ParametersHub.py,sha256=_LvkdV95vKSU4h2LtF7W63EaF5mRBg85ZHf0ymb28tA,20248
-junshan_kit/Print_Info.py,sha256=7pfd_mGEuQdQGyz6kcSSvjVRCrPgi5RafQgi7ZSS9VU,4890
-junshan_kit/TrainingHub.py,sha256=unoI8zzm0oekUxz-3retHCFhxwx6j8e6Tp9VQDywTPg,11565
+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=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.8.5.dist-info/METADATA,sha256=vxUXFvPqaGc2liYh0A3B4CmlbdlrK1CVdRNx0i7RoRA,455
-junshan_kit-2.8.5.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
-junshan_kit-2.8.5.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,,