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

junshan_kit/Print_Info.py

@@ -0,0 +1,109 @@
+from junshan_kit import DataSets, ParametersHub
+
+
+# -------------------------------------------------------------
+def training_group(training_group):
+    print(f"--------------------- training_group ------------------")
+    for g in training_group:
+        print(g)
+    print(f"-------------------------------------------------------")
+
+
+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']}"
+        )
+        print(
+            f"\033[32m✅ \033[34mOptimizer:\033[32m {optimizer_name}, \t\033[34mParams:\033[32m {hyperparams}"
+        )
+        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[34mResults_folder:\033[32m {Paras["Results_folder"]}')
+        print("\033[90m" + "-" * 115 + "\033[0m")
+
+    else:
+        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']}"
+        )
+        print(f"✅ Optimizer: {optimizer_name}, \tParams: {hyperparams}")
+        print(
+            f"✅ model: {model_name}, \tmodel type: {Paras['model_type'][model_name]}, \tloss_fn: {Paras['loss_fn']}"
+        )
+        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')
+
+    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 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'
+            f'\033[34m train_loss = \033[32m{training_loss[epoch+1]:.4e}\033[0m,\t\b'
+            f'\033[34m train_acc = \033[32m{100 * training_acc[epoch+1]:.2f}%\033[0m,\t\b'
+            f'\033[34m test_acc = \033[32m{100 * test_acc[epoch+1]:.2f}%\033[0m,\t\b'
+            f'\033[34m time (ep, tr, te) = \033[32m({run_time["epoch"]:.2f}, {run_time["train"]:.2f}, {run_time["test"]:.2f})\033[0m')
+    else:
+        print(
+        f'epoch = {epoch+1}/{epochs},\t'
+        f'epoch_loss = {epoch_loss[epoch+1]:.4e},\t'
+        f'train_loss = {training_loss[epoch+1]:.4e},\t'
+        f'train_acc = {100 * training_acc[epoch+1]:.2f}%,\t'
+        f'test_acc = {100 * test_acc[epoch+1]:.2f}%,\t'
+        f'time (ep, tr, te) = ({run_time["epoch"]:.2f}, {run_time["train"]:.2f}, {run_time["test"]:.2f})')
+
+
+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

@@ -0,0 +1,324 @@
+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, TrainingHub, Evaluate_Metrics, DataProcessor, Print_Info, ParametersHub
+
+from junshan_kit.OptimizerHup import OptimizerFactory, SPBM
+
+def chosen_loss_fn(model_name, Paras):
+    # ---------------------------------------
+    # There have an addition parameter
+    if model_name == "LogRegressionBinaryL2":
+        Paras["lambda"] = 1e-3
+    # ---------------------------------------
+
+    if model_name in ["LeastSquares"]:
+        loss_fn = nn.MSELoss()
+
+    else:
+        if Paras["model_type"][model_name] == "binary":
+            loss_fn = nn.BCEWithLogitsLoss()
+
+        elif Paras["model_type"][model_name] == "multi":
+            loss_fn = nn.CrossEntropyLoss()
+
+        else:
+            loss_fn = nn.MSELoss()
+            print("\033[91m The loss function is error!\033[0m")
+            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}/{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)
+
+    elif data_name == "CIFAR100":
+        train_dataset, test_dataset, transform = DataHub.CIFAR100(Paras, model_name)
+
+    elif data_name == "Adult_Income_Prediction":
+        train_dataset, test_dataset, transform = DataHub.Adult_Income_Prediction(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 == "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]
+    #     train_dataset, test_dataset, transform = datahub.get_libsvm_data(
+    #         train_path + ".txt", test_path + ".txt", data_name
+    #     )
+
+    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
+
+    # 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"])
+    g = torch.Generator()
+    g.manual_seed(Paras["seed"])
+    
+    train_loader = Data.DataLoader(
+            dataset=train_dataset,
+            shuffle=True,
+            batch_size=Paras["batch_size"],
+            generator=g,
+            num_workers=0,
+        )
+    
+    test_loader = Data.DataLoader(
+            dataset=test_dataset,
+            shuffle=False,
+            batch_size=Paras["batch_size"],
+            generator=g,
+            num_workers=0,
+        )
+    
+    return train_loader, test_loader
+
+def chosen_optimizer(optimizer_name, model, hyperparams, Paras):
+    if optimizer_name == "SGD":
+        optimizer = torch.optim.SGD(model.parameters(), lr=hyperparams["alpha"])
+
+    elif optimizer_name == "ADAM":
+        optimizer = torch.optim.Adam(
+            model.parameters(),
+            lr=hyperparams["alpha"],
+            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.")
+
+    return optimizer
+
+def load_model_dataloader(base_model_fun, initial_state_dict, data_name, train_dataset, test_dataset, Paras):
+    ParametersHub.set_seed(Paras["seed"])
+    model = base_model_fun()
+    model.load_state_dict(initial_state_dict)
+    model.to(Paras["device"])
+    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.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, 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
+import os, time, openml, pickle
 
 from selenium import webdriver
 from selenium.webdriver.common.by import By
@@ -35,7 +35,7 @@ def unzip_file(zip_path: str, unzip_folder: str):
     with zipfile.ZipFile(zip_path, 'r') as zip_ref:
         zip_ref.extractall(unzip_folder)
 
-    print(f"✅ Extracted '{zip_path}' to '{os.path.abspath(unzip_folder)}'")
+    print(f"- Extracted '{zip_path}' to '{os.path.abspath(unzip_folder)}'")
 
 
 # =============================================================
@@ -73,13 +73,13 @@ class JianguoyunDownloaderChrome:
         self.driver = webdriver.Chrome(options=self.chrome_options)
 
     def open_page(self):
-        print(f"🌐 Opening page: {self.url}")
+        print(f">>> Opening page: {self.url}")
         self.driver.get(self.url)
-        print(f"✅ Page loaded: {self.driver.title}")
+        print(f">>> Page loaded: {self.driver.title}")
 
     def click_download_button(self):
         """Find and click the 'Download' button (supports English and Chinese)."""
-        print("🔍 Searching for the download button...")
+        print(">>> Searching for the download button...")
         wait = WebDriverWait(self.driver, 30)
 
         try:
@@ -97,33 +97,33 @@ class JianguoyunDownloaderChrome:
 
             # Click using JavaScript to avoid overlay or interaction issues
             self.driver.execute_script("arguments[0].click();", button)
-            print(f"✅ Download button clicked. Files will be saved to: {self.download_path}")
+            print(f">>> Download button clicked. Files will be saved to: {self.download_path}")
 
             # If the cloud service opens a new tab, switch to it
             time.sleep(3)
             if len(self.driver.window_handles) > 1:
                 self.driver.switch_to.window(self.driver.window_handles[-1])
-                print("📂 Switched to the new download tab.")
+                print(">>> Switched to the new download tab.")
 
         except Exception as e:
-            print("❌ Failed to find or click the download button:", e)
+            print(">>> Failed to find or click the download button:", e)
             raise
 
 
     def wait_for_downloads(self, timeout=3600):
-        print("⏳ Waiting for downloads to finish...")
+        print(">>> Waiting for downloads to finish...")
         start_time = time.time()
         while time.time() - start_time < timeout:
             downloading = [f for f in os.listdir(self.download_path) if f.endswith(".crdownload")]
             if not downloading:
-                print("✅ Download completed!")
+                print(">>> Download completed!")
                 return
             time.sleep(2)
-        print("⚠️ Timeout: download not completed within 1 hour")
+        print(">>> Timeout: download not completed within 1 hour")
 
     def close(self):
         self.driver.quit()
-        print("🚪 Browser closed.")
+        print(">>> Browser closed.")
 
     def run(self):
         print('*' * 60)
@@ -132,7 +132,7 @@ class JianguoyunDownloaderChrome:
             self.click_download_button()
             self.wait_for_downloads()
         except Exception as e:
-            print("❌ Error:", e)
+            print(">>> Error:", e)
         finally:
             self.close()
         print('*' * 60)
@@ -169,13 +169,13 @@ class JianguoyunDownloaderFirefox:
         self.driver = webdriver.Firefox(service=service, options=options)
 
     def open_page(self):
-        print(f"🌐 Opening page: {self.url}")
+        print(f">>> Opening page: {self.url}")
         self.driver.get(self.url)
-        print(f"✅ Page loaded: {self.driver.title}")
+        print(f">>> Page loaded: {self.driver.title}")
 
     def click_download_button(self):
         """Find and click the 'Download' button (supports English and Chinese)."""
-        print("🔍 Searching for the download button...")
+        print(">>> Searching for the download button...")
         wait = WebDriverWait(self.driver, 30)
 
         try:
@@ -193,21 +193,21 @@ class JianguoyunDownloaderFirefox:
 
             # Click using JavaScript to avoid overlay or interaction issues
             self.driver.execute_script("arguments[0].click();", button)
-            print(f"✅ Download button clicked. Files will be saved to: {self.download_path}")
+            print(f">>> Download button clicked. Files will be saved to: {self.download_path}")
 
             # If the cloud service opens a new tab, switch to it
             time.sleep(3)
             if len(self.driver.window_handles) > 1:
                 self.driver.switch_to.window(self.driver.window_handles[-1])
-                print("📂 Switched to the new download tab.")
+                print(">>> Switched to the new download tab.")
 
         except Exception as e:
-            print("❌ Failed to find or click the download button:", e)
+            print(">>> Failed to find or click the download button:", e)
             raise
 
     def wait_for_download(self, timeout=3600):
         """Wait until all downloads are finished (auto-detects browser type)."""
-        print("⏳ Waiting for downloads to finish...")
+        print(">>> Waiting for downloads to finish...")
         start_time = time.time()
 
         # Determine the temporary file extension based on the browser type
@@ -216,13 +216,13 @@ class JianguoyunDownloaderFirefox:
         while time.time() - start_time < timeout:
             downloading = [f for f in os.listdir(self.download_path) if f.endswith(temp_ext)]
             if not downloading:
-                print("✅ Download completed!")
+                print(">>> Download completed!")
                 return True
             time.sleep(2)
 
 
     def close(self):
-        print("🛑 Closing browser...")
+        print(">>> Closing browser...")
         self.driver.quit()
 
     def run(self):
@@ -232,11 +232,70 @@ class JianguoyunDownloaderFirefox:
             self.click_download_button()
             self.wait_for_download(timeout=3600)
         except Exception as e:
-            print("❌ Error:", e)
+            print(">>> Error:", e)
         finally:
             self.close()
         print('*' * 60)
 
 
+def download_openml_data(data_name):
+    """
+    Returns
+    -------
+    X : ndarray, dataframe, or sparse matrix, shape (n_samples, n_columns)
+        Dataset
+    y : ndarray or pd.Series, shape (n_samples, ) or None
+        Target column
+    categorical_indicator : boolean ndarray
+        Mask that indicate categorical features.
+    attribute_names : List[str]
+        List of attribute names.
+    """
+    openml.config.set_root_cache_directory(f"./exp_data/{data_name}")
+    dataset = openml.datasets.get_dataset(f'{data_name}', download_data=True)
+    X, y, categorical_indicator, attribute_names = dataset.get_data(dataset_format="dataframe")
+
+    return X, y, categorical_indicator, attribute_names
+
+
+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.2.8.dist-info → junshan_kit-2.7.3.dist-info}/METADATA

@@ -1,11 +1,15 @@
 Metadata-Version: 2.4
 Name: junshan_kit
-Version: 2.2.8
+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: pandas==2.3.3
+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,,