flexynesis 0.2.2__tar.gz → 0.2.4__tar.gz

{flexynesis-0.2.2 → flexynesis-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flexynesis
-Version: 0.2.2
+Version: 0.2.4
 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

{flexynesis-0.2.2 → flexynesis-0.2.4}/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,8 @@ 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,8 +45,9 @@ 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.
         --disable_marker_finding (bool): If set, marker discovery after model training is disabled.
         --string_organism (int): STRING DB organism id. Default is 9606.
@@ -56,7 +58,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", 
@@ -97,8 +99,10 @@ 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", 
                         help="(Optional) If set, the system will attempt to use CUDA/GPU if available.")
     parser.add_argument("--disable_marker_finding", action="store_true", 
@@ -184,20 +188,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
@@ -219,6 +227,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 
@@ -253,7 +289,8 @@ def main():
                                             device_type = device_type,
                                             gnn_conv_type = gnn_conv_type,
                                             input_layers = input_layers,
-                                            output_layers = output_layers)    
+                                            output_layers = output_layers, 
+                                            num_workers = args.num_workers)    
     
     # do a hyperparameter search training multiple models and get the best_configuration 
     model, best_params = tuner.perform_tuning(hpo_patience = args.hpo_patience)
@@ -279,20 +316,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")
@@ -302,14 +335,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")
@@ -336,7 +374,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()
@@ -348,9 +386,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, 
@@ -366,5 +405,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.2 → flexynesis-0.2.4}/flexynesis/config.py

@@ -6,28 +6,28 @@ epochs = [500]
 search_spaces = {
     'DirectPred': [
         Integer(16, 128, name='latent_dim'),
-        Real(0.2, 1, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
+        Real(0.2, 0.5, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
         Real(0.0001, 0.01, prior='log-uniform', name='lr'),
         Integer(8, 32, name='supervisor_hidden_dim'),
         Categorical(epochs, name='epochs')
     ], 
     'supervised_vae': [
         Integer(16, 128, name='latent_dim'),
-        Real(0.2, 1, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
+        Real(0.2, 0.5, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
         Integer(8, 32, name='supervisor_hidden_dim'),
         Real(0.0001, 0.01, prior='log-uniform', name='lr'),
         Categorical(epochs, name='epochs')
     ],
     'CrossModalPred': [
         Integer(16, 128, name='latent_dim'),
-        Real(0.2, 1, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
+        Real(0.2, 0.5, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
         Integer(8, 32, name='supervisor_hidden_dim'),
         Real(0.0001, 0.01, prior='log-uniform', name='lr'),
         Categorical(epochs, name='epochs')
     ],
     'MultiTripletNetwork': [
         Integer(16, 128, name='latent_dim'),
-        Real(0.2, 1, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
+        Real(0.2, 0.5, name='hidden_dim_factor'), # relative size of the hidden_dim w.r.t input_dim 
         Integer(8, 32, name='supervisor_hidden_dim'),
         Real(0.0001, 0.01, prior='log-uniform', name='lr'),
         Categorical(epochs, name='epochs')

{flexynesis-0.2.2 → flexynesis-0.2.4}/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.2 → flexynesis-0.2.4}/flexynesis/main.py

@@ -56,7 +56,7 @@ class HyperparameterTuning:
                  cv_splits=5, use_loss_weighting=True, early_stop_patience=-1, device_type=None, gnn_conv_type=None,
                  input_layers=None, output_layers=None): Initializes the hyperparameter tuner with specific settings.
 
-        get_batch_space(min_size=16, max_size=256): Determines the batch size search space based on the dataset size.
+        get_batch_space(min_size=16, max_size=128): Determines the batch size search space based on the dataset size.
 
         setup_trainer(params, current_step, total_steps, full_train=False): Sets up the trainer with appropriate callbacks
             and configurations for either full training or validation based training.
@@ -80,7 +80,7 @@ class HyperparameterTuning:
                  val_size = 0.2,  use_cv = False, cv_splits = 5, 
                  use_loss_weighting = True, early_stop_patience = -1,
                  device_type = None, gnn_conv_type = None, 
-                 input_layers = None, output_layers = None):
+                 input_layers = None, output_layers = None, num_workers = 2):
         self.dataset = dataset # dataset for model initiation
         self.loader_dataset = dataset # dataset for defining data loaders (this can be model specific)
         self.model_class = model_class
@@ -107,6 +107,7 @@ class HyperparameterTuning:
         self.gnn_conv_type = gnn_conv_type
         self.input_layers = input_layers
         self.output_layers = output_layers 
+        self.num_workers = num_workers
         
         self.DataLoader = torch.utils.data.DataLoader # use torch data loader by default
         
@@ -128,7 +129,7 @@ class HyperparameterTuning:
             else:
                 raise ValueError(f"'{self.config_name}' not found in the default config.")
 
-    def get_batch_space(self, min_size = 32, max_size = 256):
+    def get_batch_space(self, min_size = 32, max_size = 128):
         m = int(np.log2(len(self.dataset) * 0.8))
         st = int(np.log2(min_size))
         end = int(np.log2(max_size))
@@ -214,9 +215,11 @@ class HyperparameterTuning:
                 train_subset = torch.utils.data.Subset(self.loader_dataset, train_index)
                 val_subset = torch.utils.data.Subset(self.loader_dataset, val_index)
                 train_loader = self.DataLoader(train_subset, batch_size=int(params['batch_size']), 
-                                               pin_memory=True, shuffle=True, drop_last=True, num_workers = 4, prefetch_factor = None, persistent_workers = True)
+                                               pin_memory=True, shuffle=True, drop_last=True, num_workers = self.num_workers, prefetch_factor = None, 
+                                               persistent_workers = self.num_workers > 0)
                 val_loader = self.DataLoader(val_subset, batch_size=int(params['batch_size']), 
-                                             pin_memory=True, shuffle=False, num_workers = 4, prefetch_factor = None, persistent_workers = True)
+                                             pin_memory=True, shuffle=False, num_workers = self.num_workers, prefetch_factor = None, 
+                                             persistent_workers = self.num_workers > 0)
 
                 model = self.model_class(**model_args)
                 trainer, early_stop_callback = self.setup_trainer(params, current_step, total_steps)

{flexynesis-0.2.2 → flexynesis-0.2.4}/flexynesis/utils.py

@@ -218,7 +218,7 @@ def evaluate_regressor(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):
     metrics_list = []
     for var in y_pred_dict.keys():
         if dataset.variable_types[var] == 'numerical':
@@ -235,6 +235,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 +264,7 @@ 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):
     def prepare_data(data_object):
         # Concatenate Data Matrices
         X = np.concatenate([tensor for tensor in data_object.dat.values()], axis=1)
@@ -281,52 +281,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 +321,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,

{flexynesis-0.2.2 → flexynesis-0.2.4}/flexynesis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flexynesis
-Version: 0.2.2
+Version: 0.2.4
 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

{flexynesis-0.2.2 → flexynesis-0.2.4}/pyproject.toml

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