flexynesis 0.2.3__tar.gz → 0.2.5__tar.gz

{flexynesis-0.2.3 → flexynesis-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flexynesis
-Version: 0.2.3
+Version: 0.2.5
 Summary: A deep-learning based multi-omics bulk sequencing data integration suite with a focus on (pre-)clinical endpoint prediction.
 Author-email: Bora Uyar <bora.uyar@mdc-berlin.de>, Taras Savchyn <Taras.Savchyn@mdc-berlin.de>, Ricardo Wurmus <Ricardo.Wurmus@mdc-berlin.de>, Ahmet Sarigun <Ahmet.Sariguen@mdc-berlin.de>
 Project-URL: homepage, https://github.com/BIMSBbioinfo/flexynesis
@@ -113,7 +113,7 @@ flexynesis --data_path dataset1 \
   --prefix erlotinib_direct \
   --early_stop_patience 3 \
   --use_loss_weighting False \
-  --evaluate_baseline_performance False
+  --evaluate_baseline_performance
 ```
 
 ## Accelerating with GPUs

{flexynesis-0.2.3 → flexynesis-0.2.5}/README.md

@@ -77,7 +77,7 @@ flexynesis --data_path dataset1 \
   --prefix erlotinib_direct \
   --early_stop_patience 3 \
   --use_loss_weighting False \
-  --evaluate_baseline_performance False
+  --evaluate_baseline_performance
 ```
 
 ## Accelerating with GPUs

{flexynesis-0.2.3 → flexynesis-0.2.5}/flexynesis/__main__.py

@@ -1,7 +1,7 @@
 from lightning import seed_everything
 import lightning as pl
 from typing import NamedTuple
-import os, yaml, torch, time, random, warnings, argparse 
+import os, yaml, torch, time, random, warnings, argparse, sys
 os.environ["OMP_NUM_THREADS"] = "1"
 import pandas as pd
 import flexynesis
@@ -18,7 +18,7 @@ def main():
 
     Args:
         --data_path (str): Path to the folder with train/test data files. (Required)
-        --model_class (str): The kind of model class to instantiate. Choices are ["DirectPred", "GNN", "supervised_vae", "MultiTripletNetwork", "CrossModalPred"]. (Required)
+        --model_class (str): The kind of model class to instantiate. Choices are ["DirectPred", "GNN", "supervised_vae", "MultiTripletNetwork", "CrossModalPred", "RandomForest", "SVM", "RandomSurvivalForest"]. (Required)
         --gnn_conv_type (str): If model_class is set to GNN, choose which graph convolution type to use. Choices are ["GC", "GCN", "SAGE"].
         --target_variables (str): Which variables in 'clin.csv' to use for predictions, comma-separated if multiple. Optional if survival variables are not set to None.
         --batch_variables (str): Which variables in 'clin.csv' to use for data integration/batch correction, comma-separated if multiple. Optional.
@@ -44,7 +44,7 @@ def main():
         --hpo_patience (int): How many hyperparameter optimisation iterations to wait for when no improvements are observed. Default is 10; set to 0 to disable early stopping.
         --use_cv (bool): If set, a 5-fold cross-validation training will be done. Otherwise, a single training on 80 percent of the dataset is done.
         --use_loss_weighting (str): Whether to apply loss-balancing using uncertainty weights method. Choices are ['True', 'False']. Default is 'True'.
-        --evaluate_baseline_performance (str): Whether to run Random Forest + SVMs to see the performance of off-the-shelf tools on the same dataset. Choices are ['True', 'False']. Default is 'True'.
+        --evaluate_baseline_performance (bool): Enables modeling also with Random Forest + SVMs to see the performance of off-the-shelf tools on the same dataset. 
         --threads (int): How many threads to use when using CPU. Default is 4.
         --num_workers (int): How many workers to use for model training. Default is 2
         --use_gpu (bool): If set, the system will attempt to use CUDA/GPU if available.
@@ -57,7 +57,7 @@ def main():
     
     parser.add_argument("--data_path", help="(Required) Path to the folder with train/test data files", type=str, required = True)
     parser.add_argument("--model_class", help="(Required) The kind of model class to instantiate", type=str, 
-                        choices=["DirectPred", "supervised_vae", "MultiTripletNetwork", "CrossModalPred", "GNN"], required = True)
+                        choices=["DirectPred", "supervised_vae", "MultiTripletNetwork", "CrossModalPred", "GNN", "RandomForest", "SVM", "RandomSurvivalForest"], required = True)
     parser.add_argument("--gnn_conv_type", help="If model_class is set to GNN, choose which graph convolution type to use", type=str, 
                         choices=["GC", "GCN", "SAGE"])
     parser.add_argument("--target_variables", 
@@ -98,7 +98,8 @@ def main():
     parser.add_argument("--use_cv", action="store_true", 
                         help="(Optional) If set, the a 5-fold cross-validation training will be done. Otherwise, a single trainig on 80 percent of the dataset is done.")
     parser.add_argument("--use_loss_weighting", help="whether to apply loss-balancing using uncertainty weights method", type=str, choices=['True', 'False'], default = 'True')
-    parser.add_argument("--evaluate_baseline_performance", help="whether to run Random Forest + SVMs to see the performance of off-the-shelf tools on the same dataset", type=str, choices=['True', 'False'], default = 'True')
+    parser.add_argument("--evaluate_baseline_performance", action="store_true", 
+                        help="whether to run Random Forest + SVMs to see the performance of off-the-shelf tools on the same dataset")
     parser.add_argument("--threads", help="(Optional) How many threads to use when using CPU (default is 4)", type=int, default = 4)
     parser.add_argument("--num_workers", help="(Optional) How many workers to use for model training (default is 2)", type=int, default = 2)
     parser.add_argument("--use_gpu", action="store_true", 
@@ -140,12 +141,10 @@ def main():
                                    "`srun --gpus=1 --pty flexynesis <rest of your_command>` !!!\n\n"]))
             time.sleep(3)  #wait a bit to capture user's attention to the warning
             device_type = 'cpu'
-            torch.set_num_threads(args.threads)
         else:
             device_type = 'gpu'
     else:
         device_type = 'cpu'
-        torch.set_num_threads(args.threads)
 
     # 5. check GNN arguments
     if args.model_class == 'GNN':
@@ -186,20 +185,24 @@ def main():
     if not os.path.exists(args.outdir):
         raise FileNotFoundError(f"Path to --outdir doesn't exist at:",  {args.outdir})
 
-    class AvailableModels(NamedTuple):
-        # type AvailableModel = ModelClass: Type, ModelConfig: str
-        DirectPred: tuple[DirectPred, str] = DirectPred, "DirectPred"
-        supervised_vae: tuple[supervised_vae, str] = supervised_vae, "supervised_vae"
-        MultiTripletNetwork: tuple[MultiTripletNetwork, str] = MultiTripletNetwork, "MultiTripletNetwork"
-        CrossModalPred: tuple[CrossModalPred, str] = CrossModalPred, "CrossModalPred"
-        GNN: tuple[GNN, str] = GNN, "GNN"
-        
-    available_models = AvailableModels()
-    model_class = getattr(available_models, args.model_class, None)
-    if model_class is None:
-        raise ValueError(f"Invalid model_class: {args.model_class}")
-    else:
-        model_class, config_name = model_class
+    available_models = {
+        "DirectPred": (DirectPred, "DirectPred"),
+        "supervised_vae": (supervised_vae, "supervised_vae"),
+        "MultiTripletNetwork": (MultiTripletNetwork,  "MultiTripletNetwork"),
+        "CrossModalPred": (CrossModalPred, "CrossModalPred"),
+        "GNN": (GNN, "GNN"),
+        "RandomForest": ("RandomForest", None),
+        "SVM": ("SVM", None),
+        "RandomSurvivalForest": ("RandomSurvivalForest", None)
+    }
+    
+    model_info = available_models.get(args.model_class)
+
+    if model_info is None:
+        raise ValueError(f"Unsupported model class {args.model_class}")
+
+    # Unpack the tuple into model class and config name
+    model_class, config_name = model_info
 
     # import assays and labels
     inputDir = args.data_path
@@ -221,6 +224,34 @@ def main():
                                             downsample = args.subsample)
     train_dataset, test_dataset = data_importer.import_data()
     
+    if args.model_class in ["RandomForest", "SVM"]:
+        if args.target_variables:
+            var =  args.target_variables.strip().split(',')[0]
+            print(f"Training {args.model_class} on variable: {var}")
+            metrics = flexynesis.evaluate_baseline_performance(train_dataset, test_dataset, variable_name=var,  
+                                                    methods=[args.model_class], n_folds=5, n_jobs=args.threads)
+            metrics.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'stats.csv'])), header=True, index=False)
+            print(f"{args.model_class} evaluation complete. Results saved.")
+            # we skip everything related to deep learning models here
+            sys.exit(0) 
+        else:
+            raise ValueError(f"At least one target variable is required to run RandomForest/SVM models. Set --target_variables argument")
+
+    if args.model_class == "RandomSurvivalForest":
+        if args.surv_event_var and args.surv_time_var:
+            print(f"Training {args.model_class} on survival variables: {args.surv_event_var} and {args.surv_time_var}")
+            metrics = flexynesis.evaluate_baseline_survival_performance(train_dataset, test_dataset,
+                                                              args.surv_time_var, 
+                                                                 args.surv_event_var, 
+                                                                 n_folds = 5,
+                                                                 n_jobs = int(args.threads))
+            metrics.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'stats.csv'])), header=True, index=False)
+            print(f"{args.model_class} evaluation complete. Results saved.")
+            # we skip everything related to deep learning models here
+            sys.exit(0) 
+        else:
+            raise ValueError(f"Missing survival variables. Set --surv_event_var --surv_time_var arguments")
+    
     if args.model_class == 'GNN': 
         # overlay datasets with network info 
         # this is a temporary solution 
@@ -282,20 +313,16 @@ def main():
         # update the test dataset to exclude finetuning samples
         test_dataset = holdout_dataset 
     
+    # get sample embeddings and save 
+    print("[INFO] Extracting sample embeddings")
+    embeddings_train = model.transform(train_dataset)
+    embeddings_test = model.transform(test_dataset)
+    
+    embeddings_train.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'embeddings_train.csv'])), header=True)
+    embeddings_test.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'embeddings_test.csv'])), header=True)
+
     # evaluate predictions;  (if any supervised learning happened)
     if any([args.target_variables, args.surv_event_var, args.batch_variables]):
-        print("[INFO] Computing model evaluation metrics")
-        metrics_df = flexynesis.evaluate_wrapper(model.predict(test_dataset), test_dataset, 
-                                                 surv_event_var=model.surv_event_var, 
-                                                 surv_time_var=model.surv_time_var)
-        metrics_df.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'stats.csv'])), header=True, index=False)
-
-        # print known/predicted labels 
-        predicted_labels = pd.concat([flexynesis.get_predicted_labels(model.predict(train_dataset), train_dataset, 'train'),
-                                      flexynesis.get_predicted_labels(model.predict(test_dataset), test_dataset, 'test')], 
-                                    ignore_index=True)
-        predicted_labels.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'predicted_labels.csv'])), header=True, index=False)
-        
         if not args.disable_marker_finding: # unless marker discovery is disabled
             # compute feature importance values
             print("[INFO] Computing variable importance scores")
@@ -305,14 +332,19 @@ def main():
                                ignore_index = True)
             df_imp.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'feature_importance.csv'])), header=True, index=False)
 
-    # get sample embeddings and save 
-    print("[INFO] Extracting sample embeddings")
-    embeddings_train = model.transform(train_dataset)
-    embeddings_test = model.transform(test_dataset)
-    
-    embeddings_train.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'embeddings_train.csv'])), header=True)
-    embeddings_test.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'embeddings_test.csv'])), header=True)
-    
+        # print known/predicted labels 
+        predicted_labels = pd.concat([flexynesis.get_predicted_labels(model.predict(train_dataset), train_dataset, 'train'),
+                                      flexynesis.get_predicted_labels(model.predict(test_dataset), test_dataset, 'test')], 
+                                    ignore_index=True)
+        predicted_labels.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'predicted_labels.csv'])), header=True, index=False)
+        
+        print("[INFO] Computing model evaluation metrics")
+        metrics_df = flexynesis.evaluate_wrapper(args.model_class, model.predict(test_dataset), test_dataset, 
+                                                 surv_event_var=model.surv_event_var, 
+                                                 surv_time_var=model.surv_time_var)
+        metrics_df.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'stats.csv'])), header=True, index=False)
+
+        
     # also filter embeddings to remove batch-associated dims and only keep target-variable associated dims 
     if args.batch_variables is not None:
         print("[INFO] Printing filtered embeddings")
@@ -339,7 +371,7 @@ def main():
 
     
     # evaluate off-the-shelf methods on the main target variable 
-    if args.evaluate_baseline_performance == 'True':
+    if args.evaluate_baseline_performance:
         print("[INFO] Computing off-the-shelf method performance on first target variable:",model.target_variables[0])
         var = model.target_variables[0]
         metrics = pd.DataFrame()
@@ -351,9 +383,10 @@ def main():
         
         if var != model.surv_event_var: 
             metrics = flexynesis.evaluate_baseline_performance(train, test, 
-                                                            variable_name = var, 
-                                                            n_folds=5,
-                                                            n_jobs = int(args.threads))
+                                                               variable_name = var, 
+                                                               methods = ['RandomForest', 'SVM'],
+                                                               n_folds = 5,
+                                                               n_jobs = int(args.threads))
         if model.surv_event_var and model.surv_time_var:
             print("[INFO] Computing off-the-shelf method performance on survival variable:",model.surv_time_var)
             metrics_baseline_survival = flexynesis.evaluate_baseline_survival_performance(train, test, 
@@ -369,5 +402,7 @@ def main():
     # save the trained model in file
     torch.save(model, os.path.join(args.outdir, '.'.join([args.prefix, 'final_model.pth'])))
     
+    
 if __name__ == "__main__":
     main()
+    print("[INFO] Finished the analysis!") 

{flexynesis-0.2.3 → flexynesis-0.2.5}/flexynesis/data.py

@@ -627,13 +627,14 @@ class TripletMultiOmicDataset(Dataset):
                              for label in labels_set}
         return labels_set, label_to_indices
 
+    
 class MultiOmicDatasetNW(Dataset):
     def __init__(self, multiomic_dataset, interaction_df):
         self.multiomic_dataset = multiomic_dataset
         self.interaction_df = interaction_df
         
-        # Precompute common features and edge index
-        self.common_features = self.find_common_features()
+        # Compute union of features in the data matrices that also appear in the network
+        self.common_features = self.find_union_features()
         self.gene_to_index = {gene: idx for idx, gene in enumerate(self.common_features)}
         self.edge_index = self.create_edge_index()
         self.samples = self.multiomic_dataset.samples
@@ -647,38 +648,48 @@ class MultiOmicDatasetNW(Dataset):
         # Store labels for all samples
         self.labels = {target_name: labels for target_name, labels in self.multiomic_dataset.ann.items()}
         
-    def find_common_features(self):
-        common_features = set.intersection(*(set(features) for features in self.multiomic_dataset.features.values()))
+    def find_union_features(self):
+        # Find the union of all features in the multiomic dataset
+        all_omic_features = set().union(*(set(features) for features in self.multiomic_dataset.features.values()))
+        # Find the union of proteins involved in interactions
         interaction_genes = set(self.interaction_df['protein1']).union(set(self.interaction_df['protein2']))
-        return list(common_features.intersection(interaction_genes))
+        # Return the intersection of omic features and interaction genes
+        return list(all_omic_features.intersection(interaction_genes))
 
     def create_edge_index(self):
+        # Create edges only if both proteins are within the available features
         filtered_df = self.interaction_df[
             (self.interaction_df['protein1'].isin(self.common_features)) & 
             (self.interaction_df['protein2'].isin(self.common_features))
         ]
         edge_list = [(self.gene_to_index[row['protein1']], self.gene_to_index[row['protein2']]) for index, row in filtered_df.iterrows()]
         return torch.tensor(edge_list, dtype=torch.long).t()
-
+    
     def precompute_node_features(self):
-        # Find indices of common features in each data matrix
-        feature_indices = {data_type: [self.multiomic_dataset.features[data_type].get_loc(gene) 
-                                        for gene in self.common_features]
-                           for data_type in self.multiomic_dataset.dat}
-        # Create a tensor to store all features [num_samples, num_nodes, num_data_types]
         num_samples = len(self.samples)
         num_nodes = len(self.common_features)
         num_data_types = len(self.multiomic_dataset.dat)
-        all_features = torch.empty((num_samples, num_nodes, num_data_types), dtype=torch.float)
+        all_features = torch.full((num_samples, num_nodes, num_data_types), float('nan'), dtype=torch.float)
 
-        # Extract features for each data type and place them in the tensor
         for i, data_type in enumerate(self.multiomic_dataset.dat):
-            # Get the data matrix
             data_matrix = self.multiomic_dataset.dat[data_type]
-            # Use advanced indexing to extract features for all samples at once
-            indices = feature_indices[data_type]
-            if indices:  # Ensure there are common features in this data type
-                all_features[:, :, i] = data_matrix[:, indices]
+            feature_indices = {
+                gene: self.multiomic_dataset.features[data_type].get_loc(gene)
+                for gene in self.common_features if gene in self.multiomic_dataset.features[data_type]
+            }
+            valid_indices = torch.tensor(list(feature_indices.values()))
+            feature_positions = torch.tensor([self.gene_to_index[gene] for gene in feature_indices.keys()])
+
+            # Fill in the available data
+            all_features[:, feature_positions, i] = data_matrix[:, valid_indices]
+
+        # Precompute medians for all data types, ignoring NaN values
+        medians = torch.nanmedian(all_features, dim=1, keepdim=True).values  # Use .values to get the actual median tensor
+
+        # Replace all NaN values in all_features with their corresponding median values
+        isnan = torch.isnan(all_features)
+        all_features[isnan] = medians.expand_as(all_features)[isnan]
+
         return all_features
     
     def subset(self, indices):

{flexynesis-0.2.3 → flexynesis-0.2.5}/flexynesis/utils.py

@@ -199,6 +199,23 @@ def evaluate_survival(outputs, durations, events):
     return {'cindex': c_index}
 
 def evaluate_classifier(y_true, y_pred, print_report = False):
+    """
+    Evaluate the performance of a classifier using multiple metrics and optionally print a detailed classification report.
+
+    This function computes balanced accuracy, F1 score (macro), and Cohen's Kappa score for the given true and predicted labels.
+    If `print_report` is set to True, it prints a detailed classification report.
+
+    Args:
+        y_true (array-like): True labels of the data, must be 1D list or array of labels.
+        y_pred (array-like): Predicted labels as returned by a classifier, must match the dimensions of y_true.
+        print_report (bool, optional): If True, prints a detailed classification report. Defaults to False.
+
+    Returns:
+        dict: A dictionary containing:
+              - 'balanced_acc': The balanced accuracy of the predictions.
+              - 'f1_score': The macro-average F1 score of the predictions.
+              - 'kappa': Cohen's Kappa score indicating the level of agreement between the true and predicted labels.
+    """
     # Balanced accuracy
     balanced_acc = balanced_accuracy_score(y_true, y_pred)
     # F1 score (macro)
@@ -213,12 +230,48 @@ def evaluate_classifier(y_true, y_pred, print_report = False):
     return {"balanced_acc": balanced_acc, "f1_score": f1, "kappa": kappa}
 
 def evaluate_regressor(y_true, y_pred):
+    """
+    Evaluate the performance of a regression model using mean squared error, R-squared, and Pearson correlation coefficient.
+
+    This function computes the mean squared error (MSE) between true and predicted values as a measure of prediction accuracy.
+    It also performs a linear regression analysis between the true and predicted values to obtain the R-squared value, which
+    explains the variance ratio, and the Pearson correlation coefficient, providing insight into the linear relationship strength.
+
+    Args:
+        y_true (array-like): True values of the dependent variable, must be a 1D list or array.
+        y_pred (array-like): Predicted values as returned by a regressor, must match the dimensions of y_true.
+
+    Returns:
+        dict: A dictionary containing:
+              - 'mse': The mean squared error between the true and predicted values.
+              - 'r2': The R-squared value indicating the proportion of variance in the dependent variable predictable from the independent variable.
+              - 'pearson_corr': The Pearson correlation coefficient indicating the linear relationship strength between the true and predicted values.
+    """
     mse = mean_squared_error(y_true, y_pred)
     slope, intercept, r_value, p_value, std_err = linregress(y_true,y_pred)
     r2 = r_value**2 
     return {"mse": mse, "r2": r2, "pearson_corr": r_value}
 
-def evaluate_wrapper(y_pred_dict, dataset, surv_event_var = None, surv_time_var = None):
+def evaluate_wrapper(method, y_pred_dict, dataset, surv_event_var = None, surv_time_var = None):
+    """
+    Evaluates predictions for different variables within a dataset using appropriate metrics based on the variable type. 
+    Supports evaluation for numerical, categorical, and survival data.
+
+    This function loops through each variable in the predictions dictionary, determines the type of the variable,
+    and evaluates the predictions using the appropriate method: regression, classification, or survival analysis.
+    It compiles the metrics into a list of dictionaries, which is then converted into a pandas DataFrame.
+
+    Args:
+        method (str): Identifier for the prediction method or model used.
+        y_pred_dict (dict): A dictionary where keys are variable names and values are arrays of predicted values.
+        dataset (Dataset): A dataset object containing actual values and metadata such as variable types.
+        surv_event_var (str, optional): The name of the survival event variable. Required if survival analysis is performed.
+        surv_time_var (str, optional): The name of the survival time variable. Required if survival analysis is performed.
+
+    Returns:
+        pd.DataFrame: A DataFrame where each row contains the method, variable name, variable type, metric name, and metric value.
+
+    """
     metrics_list = []
     for var in y_pred_dict.keys():
         if dataset.variable_types[var] == 'numerical':
@@ -235,6 +288,7 @@ def evaluate_wrapper(y_pred_dict, dataset, surv_event_var = None, surv_time_var
 
         for metric, value in metrics.items():
             metrics_list.append({
+                'method': method,
                 'var': var,
                 'variable_type': dataset.variable_types[var],
                 'metric': metric,
@@ -263,8 +317,26 @@ def get_predicted_labels(y_pred_dict, dataset, split):
         dfs.append(df)
     return pd.concat(dfs, ignore_index=True)
 
-# evaluate performance of off-the-shelf methods such as Random Forests and SVMs on regression/classification tasks
-def evaluate_baseline_performance(train_dataset, test_dataset, variable_name, n_folds=5, n_jobs = 4):
+def evaluate_baseline_performance(train_dataset, test_dataset, variable_name, methods, n_folds=5, n_jobs=4):
+    """
+    Evaluates the performance of RandomForest and/or Support Vector Machine models on a given variable from the provided datasets using cross-validation.
+
+    This function preprocesses the training and testing data, performs grid search with cross-validation to find the best
+    hyperparameters for the specified methods, and then evaluates the performance of these models on the testing set.
+    It supports evaluation for both categorical and numerical variables using appropriate machine learning models.
+
+    Args:
+        train_dataset (Dataset): A MultiOmicDataset object containing training data and metadata such as variable types.
+        test_dataset (Dataset): A MultiOmicDataset object containing testing data.
+        variable_name (str): The name of the target variable for prediction.
+        methods (list of str): List of machine learning methods to evaluate, e.g., ['RandomForest', 'SVM'].
+        n_folds (int, optional): Number of folds to use in K-fold cross-validation. Defaults to 5.
+        n_jobs (int, optional): Number of jobs to run in parallel during grid search. Defaults to 4.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the method, variable name, variable type, metric name, and metric value for each tested method.
+
+    """
     def prepare_data(data_object):
         # Concatenate Data Matrices
         X = np.concatenate([tensor for tensor in data_object.dat.values()], axis=1)
@@ -281,52 +353,32 @@ def evaluate_baseline_performance(train_dataset, test_dataset, variable_name, n_
     # Determine variable type
     variable_type = train_dataset.variable_types[variable_name]
 
-    # Initialize models and parameter grids
-    if variable_type == 'categorical':
-        model_params = {
-            'RandomForestClassifier': {
-                'model': RandomForestClassifier(random_state=42),
-                'params': {
-                    'n_estimators': [100, 200, 300],
-                    'max_depth': [10, 20, None]
-                }
-            },
-            'SVC': {
-                'model': SVC(),
-                'params': {
-                    'C': [0.1, 1, 10],
-                    'kernel': ['rbf', 'poly']
-                }
-            }
-        }
-    elif variable_type == 'numerical':
-        model_params = {
-            'RandomForestRegressor': {
-                'model': RandomForestRegressor(random_state=42),
-                'params': {
-                    'n_estimators': [100, 200, 300],
-                    'max_depth': [10, 20, None]
-                }
-            },
-            'SVR': {
-                'model': SVR(),
-                'params': {
-                    'C': [0.1, 1, 10],
-                    'kernel': ['rbf', 'poly']
-                }
-            }
-        }
-
     # Cross-Validation and Training
     kf = KFold(n_splits=n_folds, shuffle=True, random_state=42)
     X_train, y_train = prepare_data(train_dataset)
-    print("Train:",X_train.shape)
+    print("Train:", X_train.shape)
     X_test, y_test = prepare_data(test_dataset)
-    print("Test:",X_test.shape)
+    print("Test:", X_test.shape)
 
     metrics_list = []
-    for model_name, mp in model_params.items():
-        grid_search = GridSearchCV(mp['model'], mp['params'], cv=kf, n_jobs=n_jobs)
+
+    for method in methods:
+        if variable_type == 'categorical':
+            if method == 'RandomForest':
+                model = RandomForestClassifier(random_state=42)
+                params = {'n_estimators': [100, 200, 300], 'max_depth': [10, 20, None]}
+            elif method == 'SVM':
+                model = SVC(random_state=42)
+                params = {'C': [0.1, 1, 10], 'kernel': ['rbf', 'poly']}
+        elif variable_type == 'numerical':
+            if method == 'RandomForest':
+                model = RandomForestRegressor(random_state=42)
+                params = {'n_estimators': [100, 200, 300], 'max_depth': [10, 20, None]}
+            elif method == 'SVM':
+                model = SVR()
+                params = {'C': [0.1, 1, 10], 'kernel': ['rbf', 'poly']}
+
+        grid_search = GridSearchCV(model, params, cv=kf, n_jobs=n_jobs)
         grid_search.fit(X_train, y_train)
         best_model = grid_search.best_estimator_
 
@@ -341,7 +393,7 @@ def evaluate_baseline_performance(train_dataset, test_dataset, variable_name, n_
 
         for metric, value in metrics.items():
             metrics_list.append({
-                'method': model_name,
+                'method': method + ('Classifier' if variable_type == 'categorical' else 'Regressor'),
                 'var': variable_name,
                 'variable_type': variable_type,
                 'metric': metric,
@@ -352,6 +404,26 @@ def evaluate_baseline_performance(train_dataset, test_dataset, variable_name, n_
     return pd.DataFrame(metrics_list)
 
 def evaluate_baseline_survival_performance(train_dataset, test_dataset, duration_col, event_col, n_folds=5, n_jobs=4):
+    """
+    Evaluates the baseline performance of a Random Survival Forest model on survival data using the Concordance Index.
+
+    The function preprocesses both training and testing datasets to prepare appropriate survival data (comprising durations 
+    and event occurrences), performs cross-validation to assess model robustness, and then calculates the Concordance Index on 
+    the test data. It uses a Random Survival Forest (RSF) as the predictive model.
+
+    Args:
+        train_dataset (Dataset): The training dataset (a MultiOmicDataset object) containing features and survival data.
+        test_dataset (Dataset): The testing dataset  (a MultiOmicDataset object) containing features and survival data.
+        duration_col (str): Column name in the dataset for survival time.
+        event_col (str): Column name in the dataset for the event occurrence (1 if event occurred, 0 otherwise).
+        n_folds (int, optional): Number of folds for K-fold cross-validation. Defaults to 5.
+        n_jobs (int, optional): Number of parallel jobs to run for Random Survival Forest training. Defaults to 4.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the performance metrics of the RSF model, specifically the Concordance Index,
+                      listed along with the method name and variable details.
+
+    """
     print(f"[INFO] Evaluating baseline survival prediction performance")
     def prepare_data(data_object, duration_col, event_col):
         # Concatenate Data Matrices

{flexynesis-0.2.3 → flexynesis-0.2.5}/flexynesis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flexynesis
-Version: 0.2.3
+Version: 0.2.5
 Summary: A deep-learning based multi-omics bulk sequencing data integration suite with a focus on (pre-)clinical endpoint prediction.
 Author-email: Bora Uyar <bora.uyar@mdc-berlin.de>, Taras Savchyn <Taras.Savchyn@mdc-berlin.de>, Ricardo Wurmus <Ricardo.Wurmus@mdc-berlin.de>, Ahmet Sarigun <Ahmet.Sariguen@mdc-berlin.de>
 Project-URL: homepage, https://github.com/BIMSBbioinfo/flexynesis
@@ -113,7 +113,7 @@ flexynesis --data_path dataset1 \
   --prefix erlotinib_direct \
   --early_stop_patience 3 \
   --use_loss_weighting False \
-  --evaluate_baseline_performance False
+  --evaluate_baseline_performance
 ```
 
 ## Accelerating with GPUs

{flexynesis-0.2.3 → flexynesis-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flexynesis"
-version = "0.2.3"
+version = "0.2.5"
 authors = [
     {name = "Bora Uyar", email = "bora.uyar@mdc-berlin.de"},
     {name = "Taras Savchyn", email = "Taras.Savchyn@mdc-berlin.de"},