flexynesis 0.2.4__tar.gz → 0.2.6__tar.gz

flexynesis-0.2.6/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: flexynesis
+Version: 0.2.6
+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
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: <3.12,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE.md
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: lightning
+Requires-Dist: pyyaml
+Requires-Dist: scikit-optimize
+Requires-Dist: scipy
+Requires-Dist: seaborn
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: tqdm
+Requires-Dist: umap-learn
+Requires-Dist: rich
+Requires-Dist: captum
+Requires-Dist: ipywidgets
+Requires-Dist: torch_geometric
+Requires-Dist: ipykernel
+Requires-Dist: lifelines
+Requires-Dist: papermill
+Requires-Dist: scikit-survival
+Requires-Dist: python-louvain
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+
+<p align="center">
+  <img alt="logo" src="https://github.com/BIMSBbioinfo/flexynesis/raw/main/img/logo.png" width="50%" height="50%">
+</p>
+
+[![Downloads](https://static.pepy.tech/badge/flexynesis)](https://pepy.tech/project/flexynesis)
+![License: CC BY-NC-ND 4.0](https://img.shields.io/badge/License-CC_BY--NC--ND_4.0-lightgrey.svg)
+![benchmarks](https://github.com/BIMSBbioinfo/flexynesis/actions/workflows/benchmarks.yml/badge.svg)
+![tutorials](https://github.com/BIMSBbioinfo/flexynesis/actions/workflows/tutorials.yml/badge.svg)
+
+# flexynesis
+
+A deep-learning based multi-omics bulk sequencing data integration suite with a focus on (pre-)clinical 
+endpoint prediction. The package includes multiple types of deep learning architectures such as simple 
+fully connected networks, supervised variational autoencoders, graph convolutional networks, multi-triplet networks
+different options of data layer fusion, and automates feature selection and hyperparameter optimisation. The tools are continuosly benchmarked on publicly available datasets mostly related to the study of cancer. Some of the applications of the methods 
+we develop are drug response modeling in cancer patients or preclinical models (such as cell lines and 
+patient-derived xenografts), cancer subtype prediction, or any other clinically relevant outcome prediction
+that can be formulated as a regression, classification, survival, or cross-modality prediction problem. 
+
+<p align="center">
+  <img alt="workflow" src="https://github.com/BIMSBbioinfo/flexynesis/raw/main/img/graphical_abstract.jpg">
+</p>
+
+# Citing our work
+
+In order to refer to our work, please cite our manuscript currently available at [BioRxiv](https://biorxiv.org/cgi/content/short/2024.07.16.603606v1). 
+
+# Getting started with Flexynesis
+
+## Command-line tutorial
+
+- [Getting Started with Flexynesis](https://bimsbstatic.mdc-berlin.de/akalin/buyar/flexynesis/site/getting_started/)
+
+## Jupyter notebooks for interactive usage
+
+- [Modeling Breast Cancer Subtypes](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/brca_subtypes.ipynb)
+- [Survival Markers of Lower Grade Gliomas](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/survival_subtypes_LGG_GBM.ipynb)
+- [Unsupervised Analysis of Bone Marrow Cells](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/unsupervised_analysis_single_cell.ipynb)
+
+
+# Benchmarks
+
+For the latest benchmark results see: 
+https://bimsbstatic.mdc-berlin.de/akalin/buyar/flexynesis-benchmark-datasets/dashboard.html
+
+The code for the benchmarking pipeline is at: https://github.com/BIMSBbioinfo/flexynesis-benchmarks
+
+
+# Defining Kernel for the Jupyter Notebook
+
+For interactively using flexynesis on Jupyter notebooks, one can define the kernel to make
+flexynesis and its dependencies available on the jupyter session. 
+
+Assuming you have already defined an environment and installed the package: 
+```
+conda activate flexynesisenv 
+python -m ipykernel install --user --name "flexynesisenv" --display-name "flexynesisenv"
+```
+
+# Compiling Notebooks
+
+`papermill` can be used to compile the tutorials under `examples/tutorials`. 
+
+If the purpose is to quickly check if the notebook can be run; set HPO_ITER to 1. 
+This sets hyperparameter optimisation steps to 1. 
+For longer training runs to see more meaningful results from the notebook, increase this number to e.g. 50. 
+
+Example: 
+
+```
+papermill examples/tutorials/brca_subtypes.ipynb brca_subtypes.ipynb -p HPO_ITER 1 
+```
+
+The output from papermill can be converted to an html file as follows:
+
+```
+jupyter nbconvert --to html brca_subtypes.ipynb 
+```
+
+# Documentation
+
+Documentation generated using [mkdocs](https://mkdocstrings.github.io/) 
+
+```
+pip install mkdocstrings[python]
+mkdocs build --clean
+```
+
+
+

flexynesis-0.2.6/README.md

@@ -0,0 +1,91 @@
+
+<p align="center">
+  <img alt="logo" src="https://github.com/BIMSBbioinfo/flexynesis/raw/main/img/logo.png" width="50%" height="50%">
+</p>
+
+[![Downloads](https://static.pepy.tech/badge/flexynesis)](https://pepy.tech/project/flexynesis)
+![License: CC BY-NC-ND 4.0](https://img.shields.io/badge/License-CC_BY--NC--ND_4.0-lightgrey.svg)
+![benchmarks](https://github.com/BIMSBbioinfo/flexynesis/actions/workflows/benchmarks.yml/badge.svg)
+![tutorials](https://github.com/BIMSBbioinfo/flexynesis/actions/workflows/tutorials.yml/badge.svg)
+
+# flexynesis
+
+A deep-learning based multi-omics bulk sequencing data integration suite with a focus on (pre-)clinical 
+endpoint prediction. The package includes multiple types of deep learning architectures such as simple 
+fully connected networks, supervised variational autoencoders, graph convolutional networks, multi-triplet networks
+different options of data layer fusion, and automates feature selection and hyperparameter optimisation. The tools are continuosly benchmarked on publicly available datasets mostly related to the study of cancer. Some of the applications of the methods 
+we develop are drug response modeling in cancer patients or preclinical models (such as cell lines and 
+patient-derived xenografts), cancer subtype prediction, or any other clinically relevant outcome prediction
+that can be formulated as a regression, classification, survival, or cross-modality prediction problem. 
+
+<p align="center">
+  <img alt="workflow" src="https://github.com/BIMSBbioinfo/flexynesis/raw/main/img/graphical_abstract.jpg">
+</p>
+
+# Citing our work
+
+In order to refer to our work, please cite our manuscript currently available at [BioRxiv](https://biorxiv.org/cgi/content/short/2024.07.16.603606v1). 
+
+# Getting started with Flexynesis
+
+## Command-line tutorial
+
+- [Getting Started with Flexynesis](https://bimsbstatic.mdc-berlin.de/akalin/buyar/flexynesis/site/getting_started/)
+
+## Jupyter notebooks for interactive usage
+
+- [Modeling Breast Cancer Subtypes](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/brca_subtypes.ipynb)
+- [Survival Markers of Lower Grade Gliomas](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/survival_subtypes_LGG_GBM.ipynb)
+- [Unsupervised Analysis of Bone Marrow Cells](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/unsupervised_analysis_single_cell.ipynb)
+
+
+# Benchmarks
+
+For the latest benchmark results see: 
+https://bimsbstatic.mdc-berlin.de/akalin/buyar/flexynesis-benchmark-datasets/dashboard.html
+
+The code for the benchmarking pipeline is at: https://github.com/BIMSBbioinfo/flexynesis-benchmarks
+
+
+# Defining Kernel for the Jupyter Notebook
+
+For interactively using flexynesis on Jupyter notebooks, one can define the kernel to make
+flexynesis and its dependencies available on the jupyter session. 
+
+Assuming you have already defined an environment and installed the package: 
+```
+conda activate flexynesisenv 
+python -m ipykernel install --user --name "flexynesisenv" --display-name "flexynesisenv"
+```
+
+# Compiling Notebooks
+
+`papermill` can be used to compile the tutorials under `examples/tutorials`. 
+
+If the purpose is to quickly check if the notebook can be run; set HPO_ITER to 1. 
+This sets hyperparameter optimisation steps to 1. 
+For longer training runs to see more meaningful results from the notebook, increase this number to e.g. 50. 
+
+Example: 
+
+```
+papermill examples/tutorials/brca_subtypes.ipynb brca_subtypes.ipynb -p HPO_ITER 1 
+```
+
+The output from papermill can be converted to an html file as follows:
+
+```
+jupyter nbconvert --to html brca_subtypes.ipynb 
+```
+
+# Documentation
+
+Documentation generated using [mkdocs](https://mkdocstrings.github.io/) 
+
+```
+pip install mkdocstrings[python]
+mkdocs build --clean
+```
+
+
+

{flexynesis-0.2.4 → flexynesis-0.2.6}/flexynesis/__main__.py

@@ -18,16 +18,14 @@ 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", "RandomForest", "SVM", "RandomSurvivalForest"]. (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.
         --surv_event_var (str): Which column in 'clin.csv' to use as event/status indicator for survival modeling.
         --surv_time_var (str): Which column in 'clin.csv' to use as time/duration indicator for survival modeling.
         --config_path (str): Optional path to an external hyperparameter configuration file in YAML format.
         --fusion_type (str): How to fuse the omics layers. Choices are ["early", "intermediate"]. Default is 'intermediate'.
-        --hpo_iter (int): Number of iterations for hyperparameter optimisation. Default is 5.
+        --hpo_iter (int): Number of iterations for hyperparameter optimisation. Default is 100.
         --finetuning_samples (int): Number of samples from the test dataset to use for fine-tuning the model. Set to 0 to disable fine-tuning. Default is 0.
         --variance_threshold (float): Variance threshold (as percentile) to drop low variance features. Default is 1; set to 0 for no variance filtering.
         --correlation_threshold (float): Correlation threshold to drop highly redundant features. Default is 0.8; set to 1 for no redundancy filtering.
@@ -65,14 +63,11 @@ def main():
                         help="(Optional if survival variables are not set to None)." 
                         "Which variables in 'clin.csv' to use for predictions, comma-separated if multiple", 
                         type = str, default = None)
-    parser.add_argument("--batch_variables", 
-                        help="(Optional) Which variables in 'clin.csv' to use for data integration / batch correction, comma-separated if multiple", 
-                        type = str, default = None)
     parser.add_argument("--surv_event_var", help="Which column in 'clin.csv' to use as event/status indicator for survival modeling", type = str, default = None)
     parser.add_argument("--surv_time_var", help="Which column in 'clin.csv' to use as time/duration indicator for survival modeling", type = str, default = None)
     parser.add_argument('--config_path', type=str, default=None, help='Optional path to an external hyperparameter configuration file in YAML format.')
     parser.add_argument("--fusion_type", help="How to fuse the omics layers", type=str, choices=["early", "intermediate"], default = 'intermediate')
-    parser.add_argument("--hpo_iter", help="Number of iterations for hyperparameter optimisation", type=int, default = 5)
+    parser.add_argument("--hpo_iter", help="Number of iterations for hyperparameter optimisation", type=int, default = 100)
     parser.add_argument("--finetuning_samples", help="Number of samples from the test dataset to use for fine-tuning the model. Set to 0 to disable fine-tuning", type=int, default = 0)
     parser.add_argument("--variance_threshold", help="Variance threshold (as percentile) to drop low variance features (default is 1; set to 0 for no variance filtering)", type=float, default = 1)
     parser.add_argument("--correlation_threshold", help="Correlation threshold to drop highly redundant features (default is 0.8; set to 1 for no redundancy filtering)", type=float, default = 0.8)
@@ -95,7 +90,7 @@ def main():
     parser.add_argument("--prefix", help="Job prefix to use for output files", type=str, default = 'job')
     parser.add_argument("--log_transform", help="whether to apply log-transformation to input data matrices", type=str, choices=['True', 'False'], default = 'False')
     parser.add_argument("--early_stop_patience", help="How many epochs to wait when no improvements in validation loss is observed (default 10; set to -1 to disable early stopping)", type=int, default = 10)
-    parser.add_argument("--hpo_patience", help="How many hyperparamater optimisation iterations to wait for when no improvements are observed (default is 10; set to 0 to disable early stopping)", type=int, default = 10)
+    parser.add_argument("--hpo_patience", help="How many hyperparamater optimisation iterations to wait for when no improvements are observed (default is 10; set to 0 to disable early stopping)", type=int, default = 20)
     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')
@@ -120,11 +115,10 @@ def main():
 
     # 2. Check for required variables for model classes
     if args.model_class != "supervised_vae" and args.model_class != 'CrossModalPred':
-        if not any([args.target_variables, args.surv_event_var, args.batch_variables]):
+        if not any([args.target_variables, args.surv_event_var]):
             parser.error(''.join(["When selecting a model other than 'supervised_vae' or 'CrossModalPred',",
                                   "you must provide at least one of --target_variables, ",
-                                  "survival variables (--surv_event_var and --surv_time_var)",
-                                  "or --batch_variables."]))
+                                  "or survival variables (--surv_event_var and --surv_time_var)"]))
 
     # 3. Check for compatibility of fusion_type with GNN
     if args.fusion_type == "early":
@@ -142,12 +136,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':
@@ -277,7 +269,7 @@ def main():
     tuner = flexynesis.HyperparameterTuning(dataset = train_dataset, 
                                             model_class = model_class, 
                                             target_variables = args.target_variables.strip().split(',') if args.target_variables is not None else [],
-                                            batch_variables = args.batch_variables.strip().split(',') if args.batch_variables is not None else None,
+                                            batch_variables = None,
                                             surv_event_var = args.surv_event_var,
                                             surv_time_var = args.surv_time_var,
                                             config_name = config_name, 
@@ -325,7 +317,7 @@ def main():
     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]):
+    if any([args.target_variables, args.surv_event_var]):
         if not args.disable_marker_finding: # unless marker discovery is disabled
             # compute feature importance values
             print("[INFO] Computing variable importance scores")
@@ -348,20 +340,6 @@ def main():
         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")
-        embeddings_train_filtered = flexynesis.remove_batch_associated_variables(data = embeddings_train, 
-                                                                                 batch_dict={x: train_dataset.ann[x] for x in model.batch_variables} if model.batch_variables is not None else None, 
-                                                                                 target_dict={x: train_dataset.ann[x] for x in model.target_variables}, 
-                                                                                 variable_types=train_dataset.variable_types)
-        # filter test embeddings to keep the same dims as the filtered training embeddings
-        embeddings_test_filtered = embeddings_test[embeddings_train_filtered.columns]
-
-        # save 
-        embeddings_train_filtered.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'embeddings_train.filtered.csv'])), header=True)    
-        embeddings_test_filtered.to_csv(os.path.join(args.outdir, '.'.join([args.prefix, 'embeddings_test.filtered.csv'])), header=True)    
-
     # for architectures with decoders; print decoded output layers 
     if args.model_class == 'CrossModalPred':
         print("[INFO] Printing decoded output layers")
@@ -408,4 +386,4 @@ def main():
     
 if __name__ == "__main__":
     main()
-    print("[INFO] Finished the analysis!") 
+    print("[INFO] Finished the analysis!") 

{flexynesis-0.2.4 → flexynesis-0.2.6}/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(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':
@@ -265,6 +318,25 @@ def get_predicted_labels(y_pred_dict, dataset, split):
     return pd.concat(dfs, ignore_index=True)
 
 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)
@@ -332,6 +404,26 @@ def evaluate_baseline_performance(train_dataset, test_dataset, variable_name, me
     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.6/flexynesis.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: flexynesis
+Version: 0.2.6
+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
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: <3.12,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE.md
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: lightning
+Requires-Dist: pyyaml
+Requires-Dist: scikit-optimize
+Requires-Dist: scipy
+Requires-Dist: seaborn
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: tqdm
+Requires-Dist: umap-learn
+Requires-Dist: rich
+Requires-Dist: captum
+Requires-Dist: ipywidgets
+Requires-Dist: torch_geometric
+Requires-Dist: ipykernel
+Requires-Dist: lifelines
+Requires-Dist: papermill
+Requires-Dist: scikit-survival
+Requires-Dist: python-louvain
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+
+<p align="center">
+  <img alt="logo" src="https://github.com/BIMSBbioinfo/flexynesis/raw/main/img/logo.png" width="50%" height="50%">
+</p>
+
+[![Downloads](https://static.pepy.tech/badge/flexynesis)](https://pepy.tech/project/flexynesis)
+![License: CC BY-NC-ND 4.0](https://img.shields.io/badge/License-CC_BY--NC--ND_4.0-lightgrey.svg)
+![benchmarks](https://github.com/BIMSBbioinfo/flexynesis/actions/workflows/benchmarks.yml/badge.svg)
+![tutorials](https://github.com/BIMSBbioinfo/flexynesis/actions/workflows/tutorials.yml/badge.svg)
+
+# flexynesis
+
+A deep-learning based multi-omics bulk sequencing data integration suite with a focus on (pre-)clinical 
+endpoint prediction. The package includes multiple types of deep learning architectures such as simple 
+fully connected networks, supervised variational autoencoders, graph convolutional networks, multi-triplet networks
+different options of data layer fusion, and automates feature selection and hyperparameter optimisation. The tools are continuosly benchmarked on publicly available datasets mostly related to the study of cancer. Some of the applications of the methods 
+we develop are drug response modeling in cancer patients or preclinical models (such as cell lines and 
+patient-derived xenografts), cancer subtype prediction, or any other clinically relevant outcome prediction
+that can be formulated as a regression, classification, survival, or cross-modality prediction problem. 
+
+<p align="center">
+  <img alt="workflow" src="https://github.com/BIMSBbioinfo/flexynesis/raw/main/img/graphical_abstract.jpg">
+</p>
+
+# Citing our work
+
+In order to refer to our work, please cite our manuscript currently available at [BioRxiv](https://biorxiv.org/cgi/content/short/2024.07.16.603606v1). 
+
+# Getting started with Flexynesis
+
+## Command-line tutorial
+
+- [Getting Started with Flexynesis](https://bimsbstatic.mdc-berlin.de/akalin/buyar/flexynesis/site/getting_started/)
+
+## Jupyter notebooks for interactive usage
+
+- [Modeling Breast Cancer Subtypes](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/brca_subtypes.ipynb)
+- [Survival Markers of Lower Grade Gliomas](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/survival_subtypes_LGG_GBM.ipynb)
+- [Unsupervised Analysis of Bone Marrow Cells](https://github.com/BIMSBbioinfo/flexynesis/blob/main/examples/tutorials/unsupervised_analysis_single_cell.ipynb)
+
+
+# Benchmarks
+
+For the latest benchmark results see: 
+https://bimsbstatic.mdc-berlin.de/akalin/buyar/flexynesis-benchmark-datasets/dashboard.html
+
+The code for the benchmarking pipeline is at: https://github.com/BIMSBbioinfo/flexynesis-benchmarks
+
+
+# Defining Kernel for the Jupyter Notebook
+
+For interactively using flexynesis on Jupyter notebooks, one can define the kernel to make
+flexynesis and its dependencies available on the jupyter session. 
+
+Assuming you have already defined an environment and installed the package: 
+```
+conda activate flexynesisenv 
+python -m ipykernel install --user --name "flexynesisenv" --display-name "flexynesisenv"
+```
+
+# Compiling Notebooks
+
+`papermill` can be used to compile the tutorials under `examples/tutorials`. 
+
+If the purpose is to quickly check if the notebook can be run; set HPO_ITER to 1. 
+This sets hyperparameter optimisation steps to 1. 
+For longer training runs to see more meaningful results from the notebook, increase this number to e.g. 50. 
+
+Example: 
+
+```
+papermill examples/tutorials/brca_subtypes.ipynb brca_subtypes.ipynb -p HPO_ITER 1 
+```
+
+The output from papermill can be converted to an html file as follows:
+
+```
+jupyter nbconvert --to html brca_subtypes.ipynb 
+```
+
+# Documentation
+
+Documentation generated using [mkdocs](https://mkdocstrings.github.io/) 
+
+```
+pip install mkdocstrings[python]
+mkdocs build --clean
+```
+
+
+

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

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