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

junshan_kit/Print_Info.py

@@ -1,4 +1,4 @@
-from junshan_kit import ParametersHub
+from junshan_kit import DataSets, ParametersHub
 
 
 # -------------------------------------------------------------
@@ -9,8 +9,8 @@ def training_group(training_group):
     print(f"-------------------------------------------------------")
 
 
-def training_info(args, use_color, data_name, optimizer_name, folder_path, hyperparams, Paras, model_name):
-    if use_color:
+def training_info(args, 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\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']}"
@@ -21,27 +21,43 @@ def training_info(args, use_color, data_name, optimizer_name, folder_path, hyper
         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"]}'
         )
-        print(f"\033[32m✅ \033[34mfolder_path:\033[32m {folder_path}")
+        print(f'\033[32m✅ \033[34mResults_folder:\033[32m {Paras["Results_folder"]}')
         print("\033[90m" + "-" * 115 + "\033[0m")
 
     else:
         print("-" * 115)
         print(
-            f"✅ Dataset: {data_name}, \tBatch-size: {Paras['batch_size'][data_name]}, \t(training, val, test) = ({Paras['training_samples']}, {Paras['val_samples']}, {Paras['test_samples']}), \tdevice: {Paras['device']}"
+            f"✅ Dataset: {data_name}, \tBatch-size: {args.bs}, \t(training, test) = ({Paras['train_data_num']}, {Paras['test_data_num']}), \tdevice: {Paras['device']}"
         )
         print(f"✅ Optimizer: {optimizer_name}, \tParams: {hyperparams}")
         print(
-            f'✅ model: {model_name}, \t model type: {Paras["model_type"][model_name]}, loss_fn: {Paras["loss_fn"]}'
+            f"✅ model: {model_name}, \tmodel type: {Paras['model_type'][model_name]}, \tloss_fn: {Paras['loss_fn']}"
         )
-        print(f"✅ folder_path: {folder_path}")
+        print(f"✅ Results_folder: {Paras['Results_folder']}")
         print("-" * 115)
         
 # <Step_7_2>
 
-def print_per_epoch_info(use_color, epoch, Paras, epoch_loss, training_loss, training_acc, test_loss, test_acc, run_time):
+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')
+
+    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}"
+        )
+
+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()]
-    if use_color:
+    if Paras["use_color"]:
         print(
             f'\033[34m epoch = \033[32m{epoch+1}/{epochs}\033[0m,\t\b'
             f'\033[34m epoch_loss = \033[32m{epoch_loss[epoch+1]:.4e}\033[0m,\t\b'
@@ -59,5 +75,35 @@ def print_per_epoch_info(use_color, epoch, Paras, epoch_loss, training_loss, tra
         f'time (ep, tr, te) = ({run_time["epoch"]:.2f}, {run_time["train"]:.2f}, {run_time["test"]:.2f})')
 
 
-def data_info():
-    print(ParametersHub.data_list.__doc__)
+def all_data_info():
+    print(ParametersHub.data_list.__doc__)
+
+def data_info_DHI():
+    data = DataSets.adult_income_prediction(print_info=True, export_csv=False)
+
+def data_info_CCFD():
+    data = DataSets.credit_card_fraud_detection(print_info=True, export_csv=False)
+
+def data_info_AIP():
+    data = DataSets.adult_income_prediction(print_info=True, export_csv=False)
+
+def data_info_EVP():
+    data = DataSets.electric_vehicle_population(print_info=True, export_csv=False)
+
+def data_info_GHP():
+    data = DataSets.global_house_purchase(print_info=True, export_csv=False)
+
+def data_info_HL():
+    data = DataSets.health_lifestyle(print_info=True, export_csv=False)
+
+def data_info_HQC():
+    data = DataSets.Homesite_Quote_Conversion(print_info=True)
+
+def data_info_IEEE_CIS():
+    data = DataSets.IEEE_CIS_Fraud_Detection(print_info=True)
+
+def data_info_MICP():
+    data = DataSets.medical_insurance_cost_prediction(print_info=True)
+
+def data_info_PPE():
+    data = DataSets.particle_physics_event_classification(print_info=True)

junshan_kit/TrainingHub.py

@@ -1,9 +1,11 @@
-import torch, time
+import torch, time, pickle
 import torch.nn as nn
 import numpy as np
 import torch.utils.data as Data
 from torch.nn.utils import parameters_to_vector
-from junshan_kit import DataHub, ParametersHub, TrainingHub, Evaluate_Metrics
+from junshan_kit import DataHub, TrainingHub, Evaluate_Metrics, DataProcessor, Print_Info, ParametersHub
+
+from junshan_kit.OptimizerHup import OptimizerFactory, SPBM
 
 def chosen_loss_fn(model_name, Paras):
     # ---------------------------------------
@@ -28,14 +30,13 @@ def chosen_loss_fn(model_name, Paras):
             assert False
             
     Paras["loss_fn"] = loss_fn
-
     return loss_fn, Paras
 
 
 def load_data(model_name, data_name, Paras):
     # load data
-    train_path = f"./exp_data/{data_name}/training_data"
-    test_path = f"./exp_data/{data_name}/test_data"
+    train_path = f"./exp_data/{data_name}/{data_name}_training"
+    test_path = f"./exp_data/{data_name}/{data_name}_test"
 
     if data_name == "MNIST":
         train_dataset, test_dataset, transform = DataHub.MNIST(Paras, model_name)
@@ -49,12 +50,28 @@ def load_data(model_name, data_name, Paras):
     elif data_name == "Credit_Card_Fraud_Detection":
         train_dataset, test_dataset, transform = DataHub.Credit_Card_Fraud_Detection(Paras)
     
+    elif data_name == "Diabetes_Health_Indicators":
+        train_dataset, test_dataset, transform = DataHub.Diabetes_Health_Indicators(Paras)
 
-    # elif data_name == "CALTECH101_Resize_32":
-    #     Paras["train_ratio"] = 0.7
-    #     train_dataset, test_dataset, transform = datahub.caltech101_Resize_32(
-    #         Paras["seed"], Paras["train_ratio"], split=True
-    #     )
+    elif data_name == "Electric_Vehicle_Population":
+        train_dataset, test_dataset, transform = DataHub.Electric_Vehicle_Population(Paras)
+
+    elif data_name == "Global_House_Purchase":
+        train_dataset, test_dataset, transform = DataHub.Global_House_Purchase(Paras)
+
+    elif data_name == "Health_Lifestyle":
+        train_dataset, test_dataset, transform = DataHub.Health_Lifestyle(Paras)
+
+    elif data_name == "Homesite_Quote_Conversion":
+        train_dataset, test_dataset, transform = DataHub.Homesite_Quote_Conversion(Paras)
+    
+    elif data_name == "TN_Weather_2020_2025":
+        train_dataset, test_dataset, transform = DataHub.TN_Weather_2020_2025(Paras)
+
+    elif data_name == "Caltech101_Resize_32":
+        train_dataset, test_dataset, transform = DataHub.Caltech101_Resize_32(
+            Paras, 0.7, split=True
+        )
 
     # elif data_name in ["Vowel", "Letter", "Shuttle", "w8a"]:
     #     Paras["train_ratio"] = Paras["split_train_data"][data_name]
@@ -62,19 +79,21 @@ def load_data(model_name, data_name, Paras):
     #         train_path + ".txt", test_path + ".txt", data_name
     #     )
 
-    # elif data_name in ["RCV1", "Duke", "Ijcnn"]:
-    #     Paras["train_ratio"] = Paras["split_train_data"][data_name]
-    #     train_dataset, test_dataset, transform = datahub.get_libsvm_bz2_data(
-    #         train_path + ".bz2", test_path + ".bz2", data_name, Paras
-    #     )
+    elif data_name in ["RCV1", "Duke", "Ijcnn"]:
+        train_dataset, test_dataset, transform = DataProcessor.get_libsvm_bz2_data(
+            train_path + ".bz2", test_path + ".bz2", data_name, Paras
+        )
 
     else:
         transform = None
         print(f"The data_name is error!")
         assert False
 
-    return train_dataset, test_dataset, transform
+    # Computing the number of data
+    Paras["train_data_num"] = len(train_dataset)
+    Paras["test_data_num"] = len(test_dataset)
 
+    return train_dataset, test_dataset, Paras
 
 def get_dataloader(data_name, train_dataset, test_dataset, Paras):
     ParametersHub.set_seed(Paras["seed"])
@@ -86,7 +105,7 @@ def get_dataloader(data_name, train_dataset, test_dataset, Paras):
             shuffle=True,
             batch_size=Paras["batch_size"],
             generator=g,
-            num_workers=4,
+            num_workers=0,
         )
     
     test_loader = Data.DataLoader(
@@ -94,7 +113,7 @@ def get_dataloader(data_name, train_dataset, test_dataset, Paras):
             shuffle=False,
             batch_size=Paras["batch_size"],
             generator=g,
-            num_workers=4,
+            num_workers=0,
         )
     
     return train_loader, test_loader
@@ -110,6 +129,42 @@ def chosen_optimizer(optimizer_name, model, hyperparams, Paras):
             betas=(hyperparams["beta1"], hyperparams["beta2"]),
             eps=hyperparams["epsilon"],
         )
+    
+    elif optimizer_name in ["Bundle"]:
+        optimizer = OptimizerFactory.Bundle(
+            model.parameters(), model, hyperparams, Paras
+        )
+    
+    elif optimizer_name in ["ALR-SMAG"]:
+        optimizer = OptimizerFactory.ALR_SMAG(
+            model.parameters(), model, hyperparams, Paras
+        )
+    
+    elif optimizer_name in ["SPBM-TR"]:
+        optimizer = SPBM.TR(model.parameters(), model, hyperparams, Paras)
+
+    elif optimizer_name in ["SPBM-TR-NoneLower"]:
+        optimizer = SPBM.TR_NoneLower(model.parameters(), model, hyperparams, Paras)
+    
+    elif optimizer_name in ["SPBM-TR-NoneSpecial"]:
+        optimizer = SPBM.TR_NoneSpecial(model.parameters(), model, hyperparams, Paras)
+    
+    elif optimizer_name in ["SPBM-TR-NoneCut"]:
+        optimizer = SPBM.TR_NoneCut(model.parameters(), model, hyperparams, Paras)
+
+    elif optimizer_name in ["SPBM-PF-NoneLower"]:
+        optimizer = SPBM.PF_NoneLower(model.parameters(), model, hyperparams, Paras)
+
+    elif optimizer_name in ["SPBM-PF"]:
+        optimizer = SPBM.PF(model.parameters(), model, hyperparams, Paras)
+    
+    elif optimizer_name in ["SPBM-PF-NoneCut"]:
+        optimizer = SPBM.PF_NoneCut(model.parameters(), model, hyperparams, Paras)
+
+    elif optimizer_name in ["SPSmax"]:
+        optimizer = OptimizerFactory.SPSmax(
+            model.parameters(), model, hyperparams, Paras
+        )
 
     else:
         raise NotImplementedError(f"{optimizer_name} is not supported.")
@@ -124,26 +179,56 @@ def load_model_dataloader(base_model_fun, initial_state_dict, data_name, train_d
     train_loader, test_loader = TrainingHub.get_dataloader(data_name, train_dataset, test_dataset, Paras)
 
     return model, train_loader, test_loader
-
+# <training>
 def train(train_loader, optimizer_name, optimizer, model, loss_fn, Paras):
+    train_time = time.time()
     metrics = ParametersHub.metrics()
     for epoch in range(Paras["epochs"]):
+        epoch_time = time.time()
         for index, (X, Y) in enumerate(train_loader):
             X, Y = X.to(Paras["device"]), Y.to(Paras["device"])
 
+            if epoch == 0 and index == 0:
+                # # compute gradient norm
+                # with torch.no_grad():
+                #     g_k = parameters_to_vector(
+                #         [
+                #             p.grad if p.grad is not None else torch.zeros_like(p)
+                #             for p in model.parameters()
+                #         ]
+                #     )
+                #     metrics["grad_norm"].append(torch.norm(g_k, p=2).detach().cpu().item())
+                #     print(metrics["grad_norm"][-1])
+                
+                # initial training loss
+                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.compute_epoch_loss(X, Y, model, loss_fn, Paras)
+                loss = Evaluate_Metrics.loss(X, Y, model, loss_fn, Paras)
                 loss.backward()
                 optimizer.step()
 
             elif optimizer_name in [
                 "Bundle",
-                "SBPM",
+                "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.compute_epoch_loss(X, Y, model, loss_fn, Paras)
+                    loss = Evaluate_Metrics.loss(X, Y, model, loss_fn, Paras)
                     loss.backward()
                     return loss
 
@@ -152,23 +237,88 @@ def train(train_loader, optimizer_name, optimizer, model, loss_fn, Paras):
             else:
                 loss = 0
                 raise NotImplementedError(f"{optimizer_name} is not supported.")
-            
-            if index == 0 and epoch == 0:
-                metrics["iter_loss"].append(loss.item())
-                metrics["epoch_loss"].append(loss.item())
-                with torch.no_grad():
-                    g_k = parameters_to_vector(
-                        [
-                            p.grad if p.grad is not None else torch.zeros_like(p)
-                            for p in model.parameters()
-                        ]
-                    )
-                    metrics["grad_norm"].append(torch.norm(g_k, p=2).detach().cpu().item())
-        
-            metrics["per_epoch_loss"].append(loss.item())
-        metrics["epoch_loss"].append(np.mean(metrics["per_epoch_loss"]).item())
+
+
+        # 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, epoch, metrics, time.time() - epoch_time)
+    
+    time_cost = time.time() - train_time
+    metrics["train_time"] = time_cost 
+
+    return metrics
+# <training>
+
+def Record_Results(hyperparams,data_name, model_name, optimizer_name, metrics, Paras):
+
+    keys = list(hyperparams.keys())
+    values = list(hyperparams.values())
+
+    param_str = "_".join(f"{k}_{v}" for k, v in zip(keys, values))
+
+    if model_name not in Paras["Results_dict"]:
+        Paras["Results_dict"][model_name] = {}
+
+    if data_name not in Paras["Results_dict"][model_name]:
+        Paras["Results_dict"][model_name][data_name] = {}
+
+    
+    if optimizer_name not in Paras["Results_dict"][model_name][data_name]:
+        Paras["Results_dict"][model_name][data_name][optimizer_name] = {}
+
+    
+    Paras["Results_dict"][model_name][data_name][optimizer_name][param_str] = {
+        "training_acc": metrics["training_acc"],
+        "training_loss": metrics["training_loss"],
+        "train_time": metrics["train_time"]
+    }
+
+    return Paras  
+
+
+def Save_Results(Paras, model_name, data_name, optimizer_name):
+    """
+    Save the result dictionary for a specific (model, dataset, optimizer) combination.
+
+    Parameters
+    ----------
+    Paras : dict or Namespace
+        A container holding all experiment-related information, where:
+            - Paras["Results_folder"] : str
+                Directory to save result files.
+            - Paras["Results_dict"] : dict
+                Nested dictionary storing experiment results.
+
+    model_name : str
+        Full name of the model (e.g., "LeastSquares").
+
+    data_name : str
+        Name of the dataset used in the experiment.
+
+    optimizer_name : str
+        Name of the optimizer for which the results are saved.
+
+    Notes
+    -----
+    The function generates a filename in the format:
+        Results_{model_abbr}_{dataset_abbr}_{optimizer}.pkl
+    and dumps the corresponding result dictionary to disk.
+    """
+
+    # Construct the output file path using model/dataset abbreviations
+    filename = (
+        f'{Paras["Results_folder"]}/'
+        f'Results_{ParametersHub.model_abbr(model_name)}_'
+        f'{data_name}_'
+        f'{optimizer_name}.pkl'
+    )
+
+    # Save the nested results dict to disk
+    with open(filename, "wb") as f:
+        pickle.dump(Paras["Results_dict"][model_name][data_name][optimizer_name], f)
+

junshan_kit/kit.py

@@ -4,9 +4,9 @@
 >>> Last Updated : 2025-10-13
 ----------------------------------------------------------------------
 """
-
+import subprocess, smtplib
 import zipfile
-import os, time, openml
+import os, time, openml, pickle
 
 from selenium import webdriver
 from selenium.webdriver.common.by import By
@@ -258,54 +258,43 @@ def download_openml_data(data_name):
     return X, y, categorical_indicator, attribute_names
 
 
-def import_data_path_to_ignore():
-    def get_folder_size(folder_path):
-        """Recursively calculate the total size of a folder (in bytes)."""
-        total_size = 0
-        for root, dirs, files in os.walk(folder_path):
-            for f in files:
-                try:
-                    total_size += os.path.getsize(os.path.join(root, f))
-                except Exception:
-                    pass
-        return total_size
-
-    def list_and_ignore_large_folders(folder_path, limit_mb=99):
-        """List folder sizes and append large ones (> limit_mb) to .gitignore."""
-        gitignore_path = os.path.join(os.getcwd(), ".gitignore")
-        ignore_list = []
-
-        # Read existing .gitignore entries to avoid duplicates
-        if os.path.exists(gitignore_path):
-            with open(gitignore_path, "r", encoding="utf-8") as f:
-                existing_ignores = set(line.strip() for line in f if line.strip())
-        else:
-            existing_ignores = set()
-
-        for entry in os.scandir(folder_path):
-            if entry.is_dir():
-                folder_size_mb = get_folder_size(entry.path) / (1024 * 1024)
-                print(f"{entry.path}/ - {folder_size_mb:.2f} MB")
-
-                if folder_size_mb > limit_mb:
-                    rel_path = os.path.relpath(entry.path, start=os.getcwd())
-                    if rel_path not in existing_ignores:
-                        ignore_list.append(rel_path)
-            elif entry.is_file():
-                file_size_mb = os.path.getsize(entry.path) / (1024 * 1024)
-                print(f"{entry.path} - {file_size_mb:.2f} MB")
-
-        # Append new paths to .gitignore
-        if ignore_list:
-            with open(gitignore_path, "a", encoding="utf-8") as f:
-                for p in ignore_list:
-                    f.write(p + "\n")
-            print(f"\n✅ The following paths have been added to .gitignore:\n" + "\n".join(ignore_list))
-        else:
-            print("\nNo folders exceed the size limit (99 MB).")
-
-    folder_path = "./exp_data"
-    list_and_ignore_large_folders(folder_path, limit_mb=99)
+def read_pkl_data(file_path):
+    """
+    Read data from a pickle file at the specified path
+    
+    Args:
+        file_path (str): Path to the pickle file
+        
+    Returns:
+        object: Data object loaded from the pickle file
+    """
+    with open(file_path, 'rb') as f:
+        data = pickle.load(f)
+    
+    return data
+
+
+def git_commit_push(commit_message, repo_path="."):
+    try:
+        subprocess.run(["git", "-C", repo_path, "add", "."], check=True)
+        subprocess.run(["git", "-C", repo_path, "commit", "-q", "-m", commit_message], check=True)  
+        subprocess.run(["git", "-C", repo_path, "push", "-q"], check=True) 
+        print("Submitted and pushed successfully!")
+    except subprocess.CalledProcessError as e:
+        print(f"Git Command execution failed: {e}")
+
+    
+def seed_meg(meg, Subject, from_email, to_email, from_pwd):
+    from email.mime.text import MIMEText
+    msg = MIMEText(meg)
+    msg["Subject"] = Subject
+    msg["From"] = from_email
+    msg["To"] = to_email
+
+    server = smtplib.SMTP_SSL("smtp.qq.com", 465)
+    server.login(from_email, from_pwd)
+    server.sendmail(from_email, [to_email], msg.as_string())
+    server.quit()
 
 
 

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

@@ -1,9 +1,15 @@
 Metadata-Version: 2.4
 Name: junshan_kit
-Version: 2.5.1
+Version: 2.7.3
 Summary: This is an optimization tool.
 Author-email: Junshan Yin <junshanyin@163.com>
+Requires-Dist: cvxpy==1.6.5
 Requires-Dist: kaggle==1.7.4.5
 Requires-Dist: kagglehub==0.3.13
+Requires-Dist: matplotlib==3.10.3
+Requires-Dist: numpy==2.2.6
 Requires-Dist: openml==0.15.1
+Requires-Dist: scikit-learn==1.7.1
 Requires-Dist: selenium==4.36.0
+Requires-Dist: torch==2.6.0
+Requires-Dist: torchvision==0.21.0

junshan_kit-2.7.3.dist-info/RECORD

@@ -0,0 +1,20 @@
+junshan_kit/BenchmarkFunctions.py,sha256=tXgZGg-CjTNz78nMyVEQflVFIJDgmmePytXjY_RT9BM,120
+junshan_kit/Check_Info.py,sha256=Z6Ls2S7Fl4h8S9s0NB8jP_YpSLZInvQAeyjIXzq5Bpc,1872
+junshan_kit/DataHub.py,sha256=6RCNr8dBTqK-8ey4m-baMU1qOsJP6swOFkaraGdk0fM,6801
+junshan_kit/DataProcessor.py,sha256=W2bzugcYnwQC403GdvSmGDBhfz8X1KxJBkOAVg1vHHk,14385
+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/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/__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_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.5.1.dist-info → junshan_kit-2.7.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

junshan_kit-2.5.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-junshan_kit/DataHub.py,sha256=D9G2vjCNvDLer4qoKdowgWJChLMQQn7cVhAPZLvRrbE,3332
-junshan_kit/DataProcessor.py,sha256=-6qjG52NDYq746vBPpc0uW2cfbc4syqSWZIzTxJt6fE,11806
-junshan_kit/DataSets.py,sha256=hwGnJsb-Lj90lk6VBwmsDBb3-IA_WgUWzAKayHyq2AI,13391
-junshan_kit/Evaluate_Metrics.py,sha256=Ic3VejsKtGT23ac7QKjRZ3WAETO1KP6JR-EaeiwblJE,1266
-junshan_kit/ModelsHub.py,sha256=z9NyC4PTxo3wCxa2XxOfcjrw9NcDs0LCjBGCp6Z-90s,7084
-junshan_kit/ParametersHub.py,sha256=usM2vu7fBP0n97rNEeJMxhzxRRGHhJMjELrnyJiVvTk,11520
-junshan_kit/Print_Info.py,sha256=yiGc6Qlprj0ds6w2DP7ScAgTBZwswxXqxuIrQ3_liL8,3111
-junshan_kit/TrainingHub.py,sha256=QOQ5BDctGysMbbSOEy6gR-ng0bSmrZl4iJZmj6n52m0,5960
-junshan_kit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-junshan_kit/kit.py,sha256=F9f5qqn9ve-UVoYtXlFmNGl4YJ3eEy6T1yRrC0s-Wpw,12367
-junshan_kit-2.5.1.dist-info/METADATA,sha256=_gNNCaPWuspBXCD0Ce0maEYKtbO8eaoDXQIhmK2osOI,267
-junshan_kit-2.5.1.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-junshan_kit-2.5.1.dist-info/RECORD,,