gpbench 1.0.0__py3-none-any.whl

gpbench/method_reg/MVP/MVP.py

@@ -0,0 +1,182 @@
+import os
+import time
+import psutil
+import argparse
+import random
+import torch
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import KFold, train_test_split
+from scipy.stats import pearsonr
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from torch.utils.data import DataLoader, TensorDataset
+from .base_MVP import MVP
+from . import MVP_Hyperparameters
+import pynvml
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="MVP regression")
+    parser.add_argument('--methods', type=str, default='MVP/')
+    parser.add_argument('--species', type=str, default='Wheat/')
+    parser.add_argument('--phe', type=str, default='')
+    parser.add_argument('--data_dir', type=str, default='../../data/')
+    parser.add_argument('--result_dir', type=str, default='result/')
+    
+    parser.add_argument('--epochs', type=int, default=100)
+    parser.add_argument('--batch_size', type=int, default=64)
+    parser.add_argument('--learning_rate', type=float, default=0.01)
+    parser.add_argument('--patience', type=int, default=10)
+    parser.add_argument('--nb_filters', type=int, default=32)
+    return parser.parse_args()
+
+
+def load_data(args):
+    xData = np.load(os.path.join(args.data_dir, args.species, 'genotype.npz'))["arr_0"]
+    yData = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_0"]
+    names = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_1"]
+
+    nsample = xData.shape[0]
+    nsnp = xData.shape[1]
+    print("Number of samples: ", nsample)
+    print("Number of SNPs: ", nsnp)
+    return xData, yData, nsample, nsnp, names
+
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def get_gpu_mem_by_pid(pid, handle=None):
+    if handle is None:
+        return 0.0
+    try:
+        procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
+        for p in procs:
+            if p.pid == pid:
+                return p.usedGpuMemory / 1024**2
+        return 0.0
+    except Exception:
+        return 0.0
+
+
+def run_nested_cv(args, data, label, n_features, device, gpu_handle=None):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+    os.makedirs(result_dir, exist_ok=True)
+    print("Starting 10-fold cross-validation...")
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_mse, all_mae, all_r2, all_pcc = [], [], [], []
+    time_star = time.time()
+    
+    for fold, (train_index, test_index) in enumerate(kf.split(data)):
+        print(f"Running fold {fold}...")
+        process = psutil.Process(os.getpid())
+        fold_start_time = time.time()
+
+        X_train, X_test = data[train_index], data[test_index]
+        y_train, y_test = label[train_index], label[test_index]
+
+        X_train_sub, X_valid, y_train_sub, y_valid = train_test_split(
+            X_train, y_train, test_size=0.1, random_state=42
+        )
+
+        x_train_tensor = torch.from_numpy(X_train_sub).float().unsqueeze(2).unsqueeze(3)
+        y_train_tensor = torch.from_numpy(y_train_sub).float().unsqueeze(1)
+        
+        x_valid_tensor = torch.from_numpy(X_valid).float().unsqueeze(2).unsqueeze(3)
+        y_valid_tensor = torch.from_numpy(y_valid).float().unsqueeze(1)
+        
+        x_test_tensor = torch.from_numpy(X_test).float().unsqueeze(2).unsqueeze(3)
+        y_test_tensor = torch.from_numpy(y_test).float()
+
+        train_data = TensorDataset(x_train_tensor, y_train_tensor)
+        valid_data = TensorDataset(x_valid_tensor, y_valid_tensor)
+        test_data = TensorDataset(x_test_tensor, y_test_tensor)
+
+        train_loader = DataLoader(train_data, args.batch_size, shuffle=True, 
+                                  num_workers=4, pin_memory=True if torch.cuda.is_available() else False)
+        valid_loader = DataLoader(valid_data, args.batch_size, shuffle=False,
+                                 num_workers=4, pin_memory=True if torch.cuda.is_available() else False)
+        test_loader = DataLoader(test_data, args.batch_size, shuffle=False,
+                                num_workers=4, pin_memory=True if torch.cuda.is_available() else False)
+
+        model = MVP(input_size=n_features, nb_filters=args.nb_filters)
+        model.train_model(train_loader, valid_loader, args.epochs, args.learning_rate, args.patience, device)
+        y_pred = model.predict(test_loader)
+
+        mse = mean_squared_error(y_test, y_pred)
+        r2 = r2_score(y_test, y_pred)
+        mae = mean_absolute_error(y_test, y_pred)
+        pcc, _ = pearsonr(y_test, y_pred)
+
+        all_mse.append(mse)
+        all_r2.append(r2)
+        all_mae.append(mae)
+        all_pcc.append(pcc)
+
+        fold_time = time.time() - fold_start_time
+        fold_gpu_mem = get_gpu_mem_by_pid(os.getpid(), gpu_handle)
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        print(f'Fold {fold}:  Corr={pcc:.4f}, MAE={mae:.4f}, MSE={mse:.4f}, R2={r2:.4f}, '
+              f'Time={fold_time:.2f}s, GPU={fold_gpu_mem:.2f}MB, CPU={fold_cpu_mem:.2f}MB')
+        
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.reset_peak_memory_stats()
+        results_df = pd.DataFrame({'Y_test': y_test, 'Y_pred': y_pred})
+        results_df.to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+    print("\n===== Cross-validation summary =====")
+    print(f"Average PCC: {np.mean(all_pcc):.4f} ± {np.std(all_pcc):.4f}")
+    print(f"Average MAE: {np.mean(all_mae):.4f} ± {np.std(all_mae):.4f}")
+    print(f"Average MSE: {np.mean(all_mse):.4f} ± {np.std(all_mse):.4f}")
+    print(f"Average R2 : {np.mean(all_r2):.4f} ± {np.std(all_r2):.4f}")
+    print(f"Time: {time.time() - time_star:.2f}s")
+
+
+def MVP_reg():
+    set_seed(42)
+    gpu_handle = None
+    try:
+        if torch.cuda.is_available():
+            pynvml.nvmlInit()
+            gpu_handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+    except Exception as e:
+        print(f"Warning: GPU monitoring initialization failed: {e}")
+        gpu_handle = None
+    
+    args = parse_args()
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    all_species =['Cotton/']
+
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        X, Y, nsamples, nsnp, names = load_data(args)
+        for j in range(len(names)):
+            args.phe = names[j]
+            print("starting run " + args.methods + args.species + args.phe)
+            label = Y[:, j]
+            label = np.nan_to_num(label, nan=np.nanmean(label))
+            best_params = MVP_Hyperparameters.Hyperparameter(X, label, nsnp)
+            args.learning_rate = best_params['learning_rate']
+            args.batch_size = best_params['batch_size']
+            args.patience = best_params['patience']
+            args.nb_filters = best_params['nb_filters']
+            start_time = time.time() 
+            if torch.cuda.is_available():
+                torch.cuda.reset_peak_memory_stats()
+            process = psutil.Process(os.getpid())
+            run_nested_cv(args, data=X, label=label, n_features=nsnp, device=device, gpu_handle=gpu_handle)
+            elapsed_time = time.time() - start_time
+            print(f"running time: {elapsed_time:.2f} s")
+            print("successfully") 
+
+
+if __name__ == "__main__":
+    MVP_reg()

gpbench/method_reg/MVP/MVP_Hyperparameters.py

@@ -0,0 +1,126 @@
+import os
+import time
+import psutil
+import random
+import torch
+import numpy as np
+import optuna
+from sklearn.model_selection import KFold, train_test_split
+from scipy.stats import pearsonr
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from torch.utils.data import DataLoader, TensorDataset
+from optuna.exceptions import TrialPruned
+from .base_MVP import MVP
+
+
+def run_nested_cv_with_early_stopping(data, label, n_features, learning_rate, patience, batch_size, nb_filters, num_round=100):
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("Starting 10-fold cross-validation...")
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+    all_mse, all_mae, all_r2, all_pcc = [], [], [], []
+    
+    for fold, (train_index, test_index) in enumerate(kf.split(data)):
+        print(f"Running fold {fold}...")
+        process = psutil.Process(os.getpid())
+        fold_start_time = time.time()
+        
+        X_train, X_test = data[train_index], data[test_index]
+        y_train, y_test = label[train_index], label[test_index]
+
+        X_train_sub, X_valid, y_train_sub, y_valid = train_test_split(
+            X_train, y_train, test_size=0.1, random_state=42
+        )
+
+        x_train_tensor = torch.from_numpy(X_train_sub).float().unsqueeze(2).unsqueeze(3)  # (N, n_features, 1, 1)
+        y_train_tensor = torch.from_numpy(y_train_sub).float().unsqueeze(1)  # (N, 1)
+        
+        x_valid_tensor = torch.from_numpy(X_valid).float().unsqueeze(2).unsqueeze(3)
+        y_valid_tensor = torch.from_numpy(y_valid).float().unsqueeze(1)  # (N, 1)
+        
+        x_test_tensor = torch.from_numpy(X_test).float().unsqueeze(2).unsqueeze(3)
+        y_test_tensor = torch.from_numpy(y_test).float()
+        
+        train_data = TensorDataset(x_train_tensor, y_train_tensor)
+        valid_data = TensorDataset(x_valid_tensor, y_valid_tensor)
+        test_data = TensorDataset(x_test_tensor, y_test_tensor)
+
+        train_loader = DataLoader(train_data, batch_size, shuffle=True,
+                                  num_workers=4, pin_memory=True if torch.cuda.is_available() else False)
+        valid_loader = DataLoader(valid_data, batch_size, shuffle=False,
+                                 num_workers=4, pin_memory=True if torch.cuda.is_available() else False)
+        test_loader = DataLoader(test_data, batch_size, shuffle=False,
+                                num_workers=4, pin_memory=True if torch.cuda.is_available() else False)
+
+        model = MVP(input_size=n_features, nb_filters=nb_filters)
+        model.train_model(train_loader, valid_loader, num_round, learning_rate, patience, device)
+        y_pred = model.predict(test_loader)
+
+        mse = mean_squared_error(y_test, y_pred)
+        r2 = r2_score(y_test, y_pred)
+        mae = mean_absolute_error(y_test, y_pred)
+        pcc, _ = pearsonr(y_test, y_pred)
+
+        if np.isnan(pcc) or np.isinf(pcc):
+            print(f"Fold {fold} resulted in NaN/Inf PCC, pruning the trial...")
+            raise TrialPruned()
+
+        all_mse.append(mse)
+        all_r2.append(r2)
+        all_mae.append(mae)
+        all_pcc.append(pcc)
+
+        fold_time = time.time() - fold_start_time
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        print(f'Fold {fold}:  Corr={pcc:.4f}, MAE={mae:.4f}, MSE={mse:.4f}, R2={r2:.4f}, '
+              f'Time={fold_time:.2f}s, CPU={fold_cpu_mem:.2f}MB')
+
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            del model
+        
+    print("\n===== CV Summary =====")
+    print(f"PCC : {np.mean(all_pcc):.4f} ± {np.std(all_pcc):.4f}")
+    print(f"MAE : {np.mean(all_mae):.4f} ± {np.std(all_mae):.4f}")
+    print(f"MSE : {np.mean(all_mse):.4f} ± {np.std(all_mse):.4f}")
+    print(f"R2  : {np.mean(all_r2):.4f} ± {np.std(all_r2):.4f}")
+        
+    return float(np.mean(all_pcc)) if all_pcc else 0.0
+
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def Hyperparameter(data, label, n_features):
+    set_seed(42)
+    def objective(trial):
+        learning_rate = trial.suggest_float("learning_rate", 1e-4, 0.1, log=True)
+        batch_size = trial.suggest_categorical("batch_size", [16, 32, 64])
+        patience = trial.suggest_int("patience", 1, 10)
+        nb_filters = trial.suggest_categorical("nb_filters", [8, 16, 32])
+        try:
+            corr_score = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                n_features=n_features,
+                learning_rate=learning_rate,
+                patience=patience,
+                batch_size=batch_size,
+                nb_filters=nb_filters
+            )
+        except TrialPruned:
+            return float("-inf")
+        return corr_score
+    
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+
+    print("best params:", study.best_params)
+    print("successfully")
+    return study.best_params

gpbench/method_reg/MVP/__init__.py

@@ -0,0 +1,5 @@
+from .MVP import MVP_reg
+
+MVP = MVP_reg
+
+__all__ = ["MVP","MVP_reg"]

gpbench/method_reg/MVP/base_MVP.py

@@ -0,0 +1,113 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class MVP(nn.Module):
+    def __init__(self, input_size, nb_filters=32):
+        super().__init__()
+        self.input_size = input_size
+        self.nb_filters = nb_filters
+        self.kernel_size = (3, 1)
+
+        self.conv2d1 = nn.Conv2d(in_channels=1, out_channels=nb_filters, 
+                                 kernel_size=self.kernel_size, padding='same')
+        self.conv2d2 = nn.Conv2d(in_channels=nb_filters, out_channels=nb_filters, 
+                                 kernel_size=self.kernel_size, padding='same')
+        self.relu = nn.ReLU()
+        
+        flattened_dim = nb_filters * input_size * 1
+        self.fc1 = nn.Linear(flattened_dim, 512)
+        self.fc2 = nn.Linear(512, 1)
+        
+    def forward(self, x):
+        if x.dim() == 4 and x.size(1) != 1:
+            x = x.view(x.size(0), 1, x.size(1), x.size(2))
+        elif x.dim() == 2:
+            x = x.unsqueeze(1).unsqueeze(3)
+        elif x.dim() == 5:
+            x = x.squeeze(-1)
+        
+        for i in range(2):
+            x_res = x
+            if i == 0:
+                x = self.conv2d1(x) 
+            else:
+                x = self.conv2d2(x)
+            x = self.relu(x)
+            x = self.conv2d2(x)
+            x = x + x_res
+            x = self.relu(x)
+        
+        x = x.view(x.shape[0], -1)
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.fc2(x)
+        
+        return x
+    
+    def train_model(self, train_loader, valid_loader, num_epochs, learning_rate, patience, device):
+        optimizer = torch.optim.Adam(self.parameters(), lr=learning_rate, weight_decay=1e-5)
+        criterion = nn.MSELoss()
+        self.to(device)
+
+        best_loss = float('inf')
+        best_state = None
+        trigger_times = 0
+
+        for epoch in range(num_epochs):
+            self.train()
+            train_loss = 0.0
+            for inputs, labels in train_loader:
+                inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True).float()
+                if labels.dim() == 1:
+                    labels = labels.unsqueeze(1)
+                
+                optimizer.zero_grad()
+                outputs = self(inputs)
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()
+                train_loss += loss.item() * inputs.size(0)
+
+            self.eval()
+            valid_loss = 0.0
+            with torch.no_grad():
+                for inputs, labels in valid_loader:
+                    inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True).float()
+                    if labels.dim() == 1:
+                        labels = labels.unsqueeze(1)
+                    
+                    outputs = self(inputs)
+                    loss = criterion(outputs, labels)
+                    valid_loss += loss.item() * inputs.size(0)
+
+            train_loss /= len(train_loader.dataset)
+            valid_loss /= len(valid_loader.dataset)
+
+            if valid_loss < best_loss:
+                best_loss = valid_loss
+                best_state = self.state_dict()
+                trigger_times = 0
+            else:
+                trigger_times += 1
+                if trigger_times >= patience:
+                    print(f"Early stopping at epoch {epoch+1}")
+                    break
+
+        if best_state is not None:
+            self.load_state_dict(best_state)
+        return best_loss
+        
+    def predict(self, test_loader):
+        self.eval()
+        device = next(self.parameters()).device
+        y_pred = []
+        with torch.no_grad():
+            for inputs, _ in test_loader:
+                inputs = inputs.to(device, non_blocking=True)
+                outputs = self(inputs)
+                y_pred.append(outputs.cpu().numpy())
+        y_pred = np.concatenate(y_pred, axis=0)
+        y_pred = np.squeeze(y_pred)
+        return y_pred

gpbench/method_reg/RF/RF_GPU.py

@@ -0,0 +1,174 @@
+import os
+import time
+import psutil
+import pynvml
+import argparse
+import random
+from sklearn.preprocessing import StandardScaler
+import torch
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import KFold
+from scipy.stats import pearsonr
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from . import RF_Hyperparameters
+import cupy as cp
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser")
+    parser.add_argument('--methods', type=str, default='RandomForest/', help='Method name')
+    parser.add_argument('--species', type=str, default='Cattle/', help='Species name')
+    parser.add_argument('--phe', type=str, default='', help='Dataset name')
+    parser.add_argument('--data_dir', type=str, default='../../data/')
+    parser.add_argument('--result_dir', type=str, default='result/')
+
+    parser.add_argument('--n_estimators', type=int, default=100)
+    parser.add_argument('--max_depth', type=int, default=1)
+    parser.add_argument('--n_jobs', type=int, default=-1, help='Number of CPU cores to use (-1 for all cores)')
+    parser.add_argument('--use_gpu', type=bool, default=True, help='Whether to use GPU acceleration')
+    args = parser.parse_args()
+    return args
+
+def load_data(args):
+    xData = np.load(os.path.join(args.data_dir, args.species, 'genotype.npz'))["arr_0"]
+    yData = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_0"]
+    names = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_1"]
+
+    nsample = xData.shape[0]
+    nsnp = xData.shape[1]
+    print("Number of samples: ", nsample)
+    print("Number of SNPs: ", nsnp)
+    return xData, yData, nsample, nsnp, names
+
+def get_gpu_mem_by_pid(pid):
+    procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
+    for p in procs:
+        if p.pid == pid:
+            return p.usedGpuMemory / 1024**2
+    return 0.0
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+try:
+    import cuml
+    import cupy as cp
+    from cuml.ensemble import RandomForestRegressor as cuRandomForestRegressor
+    GPU_AVAILABLE = True
+except ImportError:
+    GPU_AVAILABLE = False
+
+def run_nested_cv(args, data, label):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+    os.makedirs(result_dir, exist_ok=True)
+    print("Starting 10-fold cross-validation with Random Forest...")
+       
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_mse, all_mae, all_r2, all_pcc = [], [], [], []
+    time_star = time.time()
+
+    for fold, (train_index, test_index) in enumerate(kf.split(data)):
+        print(f"Running fold {fold}...")
+        process = psutil.Process(os.getpid())
+        fold_start_time = time.time()
+        
+        x_train, x_test = data[train_index], data[test_index]
+        y_train, y_test = label[train_index], label[test_index]
+
+        x_train = x_train.astype(np.float32)
+        x_test = x_test.astype(np.float32)
+        y_train_scaled = y_train.astype(np.float32)
+        y_test_scaled = y_test.astype(np.float32)
+
+        x_train_gpu = cp.asarray(x_train)
+        x_test_gpu = cp.asarray(x_test)
+        y_train_gpu = cp.asarray(y_train_scaled)
+        
+        model = cuRandomForestRegressor(
+            n_estimators=args.n_estimators,
+            max_depth=args.max_depth,
+            random_state=42,
+            n_streams=1
+        )
+
+        model.fit(x_train_gpu, y_train_gpu)
+        
+        y_test_preds = model.predict(x_test_gpu)
+        y_test_preds = cp.asnumpy(y_test_preds)
+        y_test_scaled_cpu = cp.asnumpy(cp.asarray(y_test_scaled))
+
+        y_test_original = y_test_scaled_cpu.reshape(-1)
+        y_pred = y_test_preds.reshape(-1)
+
+        mse = mean_squared_error(y_test_original, y_pred)
+        r2 = r2_score(y_test_original, y_pred)
+        mae = mean_absolute_error(y_test_original, y_pred)
+        pcc, _ = pearsonr(y_test_original, y_pred)
+
+        all_mse.append(mse)
+        all_r2.append(r2)
+        all_mae.append(mae)
+        all_pcc.append(pcc)
+
+        fold_time = time.time() - fold_start_time
+        fold_gpu_mem = get_gpu_mem_by_pid(os.getpid())
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        
+        acceleration_status = "GPU" if GPU_AVAILABLE else f"CPU({args.n_jobs} cores)"
+        print(f'Fold {fold}[{acceleration_status}]: Corr={pcc:.4f}, MAE={mae:.4f}, MSE={mse:.4f}, R2={r2:.4f}, Time={fold_time:.2f}s, '
+              f'GPU={fold_gpu_mem:.2f}MB, CPU={fold_cpu_mem:.2f}MB')
+        
+        results_df = pd.DataFrame({'Y_test': y_test, 'Y_pred': y_test_preds})
+        results_df.to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+    print("\n===== Cross-validation summary =====")
+    acceleration_status = "GPU" if GPU_AVAILABLE else f"CPU({args.n_jobs} cores)"
+    print(f"Average PCC: {np.mean(all_pcc):.4f} ± {np.std(all_pcc):.4f}")
+    print(f"Average MAE: {np.mean(all_mae):.4f} ± {np.std(all_mae):.4f}")
+    print(f"Average MSE: {np.mean(all_mse):.4f} ± {np.std(all_mse):.4f}")
+    print(f"Average R2 : {np.mean(all_r2):.4f} ± {np.std(all_r2):.4f}")
+    print(f"Time: {time.time() - time_star:.2f}s")
+
+
+
+def RF_reg():
+    set_seed(42)
+    pynvml.nvmlInit()
+    handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+    all_species =['Cotton/']
+    
+    args = parse_args()
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        X, Y, nsamples, nsnp, names = load_data(args)
+        
+        for j in range(len(names)):
+            args.phe = names[j]
+            print(f"Starting run: {args.methods}{args.species}{args.phe}")
+
+            label = Y[:, j]
+            label = np.nan_to_num(label, nan=np.nanmean(label))
+            best_params = RF_Hyperparameters.Hyperparameter(X, label)
+            args.n_estimators = best_params['n_estimators']
+            args.max_depth = best_params['max_depth']
+            start_time = time.time()
+            if torch.cuda.is_available():
+                torch.cuda.reset_peak_memory_stats()
+            process = psutil.Process(os.getpid())
+            run_nested_cv(args, data=X, label=label)
+            
+            elapsed_time = time.time() - start_time
+            print(f"running time: {elapsed_time:.2f} s")
+            print("successfully")
+
+
+if __name__ == "__main__":
+    RF_reg()