diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..233795b379d21a7345b91b7bdc8997b5b95e4748 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,27 +1,41 @@ *.7z filter=lfs diff=lfs merge=lfs -text *.arrow filter=lfs diff=lfs merge=lfs -text *.bin filter=lfs diff=lfs merge=lfs -text +<<<<<<< HEAD *.bz2 filter=lfs diff=lfs merge=lfs -text *.ckpt filter=lfs diff=lfs merge=lfs -text +======= +*.bin.* filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +>>>>>>> 09de19734bf3da83050abc74408517ba15b5b185 *.ftz filter=lfs diff=lfs merge=lfs -text *.gz filter=lfs diff=lfs merge=lfs -text *.h5 filter=lfs diff=lfs merge=lfs -text *.joblib filter=lfs diff=lfs merge=lfs -text *.lfs.* filter=lfs diff=lfs merge=lfs -text +<<<<<<< HEAD *.mlmodel filter=lfs diff=lfs merge=lfs -text *.model filter=lfs diff=lfs merge=lfs -text *.msgpack filter=lfs diff=lfs merge=lfs -text *.npy filter=lfs diff=lfs merge=lfs -text *.npz filter=lfs diff=lfs merge=lfs -text +======= +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +>>>>>>> 09de19734bf3da83050abc74408517ba15b5b185 *.onnx filter=lfs diff=lfs merge=lfs -text *.ot filter=lfs diff=lfs merge=lfs -text *.parquet filter=lfs diff=lfs merge=lfs -text *.pb filter=lfs diff=lfs merge=lfs -text +<<<<<<< HEAD *.pickle filter=lfs diff=lfs merge=lfs -text +======= +>>>>>>> 09de19734bf3da83050abc74408517ba15b5b185 *.pkl filter=lfs diff=lfs merge=lfs -text *.pt filter=lfs diff=lfs merge=lfs -text *.pth filter=lfs diff=lfs merge=lfs -text *.rar filter=lfs diff=lfs merge=lfs -text +<<<<<<< HEAD *.safetensors filter=lfs diff=lfs merge=lfs -text saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.tar.* filter=lfs diff=lfs merge=lfs -text @@ -33,3 +47,14 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +======= +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zstandard filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text +model.safetensors filter=lfs diff=lfs merge=lfs -text +>>>>>>> 09de19734bf3da83050abc74408517ba15b5b185 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..68bc17f9ff2104a9d7b6777058bb4c343ca72609 --- /dev/null +++ b/.gitignore @@ -0,0 +1,160 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..329c392ef93028194018644abc5e66b0afdfdf11 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,26 @@ +# See https://pre-commit.com for more information +# See https://pre-commit.com/hooks.html for more hooks +repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v3.2.0 + hooks: + - id: trailing-whitespace + - id: end-of-file-fixer + - id: check-yaml + - id: check-added-large-files + - id: check-merge-conflict + - id: mixed-line-ending + - id: check-docstring-first +- repo: https://github.com/pycqa/isort + rev: 5.12.0 + hooks: + - id: isort + args: ["--profile", "black"] +- repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.1.4 + hooks: + # Run the Ruff linter. + - id: ruff + # Run the Ruff formatter. + - id: ruff-format diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8c50993305dc7ea3d1c8b2e6271afa1665762f78 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,19 @@ +# Read the Docs configuration file + +# Required +version: 2 + +# Set the OS, Python version and other tools you might need +build: + os: ubuntu-22.04 + tools: + python: "3.10" + +# Build documentation in the "docs/" directory with Sphinx +sphinx: + configuration: docs/source/conf.py + +# Python requirements required build your documentation +python: + install: + - requirements: docs/requirements.txt diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..c3875d90a1e1ee1715279ba71ae3efc1a46643e8 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,4 @@ +include geneformer/gene_median_dictionary_gc95M.pkl +include geneformer/gene_name_id_dict_gc95M.pkl +include geneformer/ensembl_mapping_dict_gc95M.pkl +include geneformer/token_dictionary_gc95M.pkl diff --git a/README.md b/README.md index ee6f996dd04c09293a1b84efe0c424eb14523d20..bd0cccc939117d1a4cbb7d35f7c3887741b131a7 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ --- +<<<<<<< HEAD license: apache-2.0 datasets: - ctheodoris/Genecorpus-30M @@ -20,3 +21,98 @@ model = AutoModelForMaskedLM.from_pretrained("ctheodoris/Geneformer") ``` For further details see: https://huggingface.co/ctheodoris/Geneformer +======= +datasets: ctheodoris/Genecorpus-30M +license: apache-2.0 +tags: +- single-cell +- genomics +--- +# Geneformer +Geneformer is a foundational transformer model pretrained on a large-scale corpus of single cell transcriptomes to enable context-aware predictions in settings with limited data in network biology. + +- See [our manuscript](https://rdcu.be/ddrx0) for details of the original model trained on ~30 million transcriptomes in June 2021 and the initial report of our in silico perturbation and cell and gene classification strategies. +- See [our manuscript](https://www.biorxiv.org/content/10.1101/2024.08.16.608180v1.full.pdf) for details of the expanded model trained on ~95 million transcriptomes in April 2024 and our continual learning, multitask learning, and quantization strategies. +- See [geneformer.readthedocs.io](https://geneformer.readthedocs.io) for documentation. + +# Model Description +Geneformer is a foundational transformer model pretrained on a large-scale corpus of single cell transcriptomes representing a broad range of human tissues. Geneformer was originally pretrained in June 2021 on [Genecorpus-30M](https://huggingface.co/datasets/ctheodoris/Genecorpus-30M), a corpus comprised of ~30 million single cell transcriptomes. We excluded cells with high mutational burdens (e.g. malignant cells and immortalized cell lines) that could lead to substantial network rewiring without companion genome sequencing to facilitate interpretation. Then, in April 2024, Geneformer was pretrained on ~95 million non-cancer transcriptomes, followed by continual learning on ~14 million cancer transcriptomes to yield a cancer domain-tuned model. + +Each single cell’s transcriptome is presented to the model as a rank value encoding where genes are ranked by their expression in that cell scaled by their expression across the entire Genecorpus-30M. The rank value encoding provides a nonparametric representation of that cell’s transcriptome and takes advantage of the many observations of each gene’s expression across the pretraining corpus to prioritize genes that distinguish cell state. Specifically, this method will deprioritize ubiquitously highly-expressed housekeeping genes by scaling them to a lower rank. Conversely, genes such as transcription factors that may be lowly expressed when they are expressed but highly distinguish cell state will move to a higher rank within the encoding. Furthermore, this rank-based approach may be more robust against technical artifacts that may systematically bias the absolute transcript counts value while the overall relative ranking of genes within each cell remains more stable. + +The rank value encoding of each single cell’s transcriptome then proceeds through N layers of transformer encoder units, where N varies dependent on the model size. Pretraining was accomplished using a masked learning objective where 15% of the genes within each transcriptome were masked and the model was trained to predict which gene should be within each masked position in that specific cell state using the context of the remaining unmasked genes. A major strength of this approach is that it is entirely self-supervised and can be accomplished on completely unlabeled data, which allows the inclusion of large amounts of training data without being restricted to samples with accompanying labels. + +We detail applications and results in [our manuscript](https://rdcu.be/ddrx0). + +During pretraining, Geneformer gained a fundamental understanding of network dynamics, encoding network hierarchy in the model’s attention weights in a completely self-supervised manner. With both zero-shot learning and fine-tuning with limited task-specific data, Geneformer consistently boosted predictive accuracy in a diverse panel of downstream tasks relevant to chromatin and network dynamics. In silico perturbation with zero-shot learning identified a novel transcription factor in cardiomyocytes that we experimentally validated to be critical to their ability to generate contractile force. In silico treatment with limited patient data revealed candidate therapeutic targets for cardiomyopathy that we experimentally validated to significantly improve the ability of cardiomyocytes to generate contractile force in an induced pluripotent stem cell (iPSC) model of the disease. Overall, Geneformer represents a foundational deep learning model pretrained on a large-scale corpus human single cell transcriptomes to gain a fundamental understanding of gene network dynamics that can now be democratized to a vast array of downstream tasks to accelerate discovery of key network regulators and candidate therapeutic targets. + +The repository includes the following pretrained models: + +L=layers\ +M=millions of cells used for pretraining\ +i=input size\ +(pretraining date) + +- GF-6L-30M-i2048 (June 2021) +- GF-12L-30M-i2048 (June 2021) +- GF-12L-95M-i4096 (April 2024) +- GF-20L-95M-i4096 (April 2024) + +The current default model in the main directory of the repository is GF-12L-95M-i4096. + +The repository also contains fined tuned models in the fine_tuned_models directory and the cancer-tuned model following continual learning on ~14 million cancer cells, GF-12L-95M-i4096_CLcancer. + +# Application +The pretrained Geneformer model can be used directly for zero-shot learning, for example for in silico perturbation analysis, or by fine-tuning towards the relevant downstream task, such as gene or cell state classification. + +Example applications demonstrated in [our manuscript](https://rdcu.be/ddrx0) include: + +*Fine-tuning*: +- transcription factor dosage sensitivity +- chromatin dynamics (bivalently marked promoters) +- transcription factor regulatory range +- gene network centrality +- transcription factor targets +- cell type annotation +- batch integration +- cell state classification across differentiation +- disease classification +- in silico perturbation to determine disease-driving genes +- in silico treatment to determine candidate therapeutic targets + +*Zero-shot learning*: +- batch integration +- gene context specificity +- in silico reprogramming +- in silico differentiation +- in silico perturbation to determine impact on cell state +- in silico perturbation to determine transcription factor targets +- in silico perturbation to determine transcription factor cooperativity + +# Installation +In addition to the pretrained model, contained herein are functions for tokenizing and collating data specific to single cell transcriptomics, pretraining the model, fine-tuning the model, extracting and plotting cell embeddings, and performing in silico pertrubation with either the pretrained or fine-tuned models. To install (~20s): + +```bash +# Make sure you have git-lfs installed (https://git-lfs.com) +git lfs install +git clone https://huggingface.co/ctheodoris/Geneformer +cd Geneformer +pip install . +``` + +For usage, see [examples](https://huggingface.co/ctheodoris/Geneformer/tree/main/examples) for: +- tokenizing transcriptomes +- pretraining +- hyperparameter tuning +- fine-tuning +- extracting and plotting cell embeddings +- in silico perturbation + +Please note that the fine-tuning examples are meant to be generally applicable and the input datasets and labels will vary dependent on the downstream task. Example input files for a few of the downstream tasks demonstrated in the manuscript are located within the [example_input_files directory](https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/tree/main/example_input_files) in the dataset repository, but these only represent a few example fine-tuning applications. + +Please note that GPU resources are required for efficient usage of Geneformer. Additionally, we strongly recommend tuning hyperparameters for each downstream fine-tuning application as this can significantly boost predictive potential in the downstream task (e.g. max learning rate, learning schedule, number of layers to freeze, etc.). + +# Citations +- C V Theodoris#, L Xiao, A Chopra, M D Chaffin, Z R Al Sayed, M C Hill, H Mantineo, E Brydon, Z Zeng, X S Liu, P T Ellinor#. Transfer learning enables predictions in network biology. _**Nature**_, 31 May 2023. (#co-corresponding authors) +- H Chen*, M S Venkatesh*, J Gomez Ortega, S V Mahesh, T Nandi, R Madduri, K Pelka†, C V Theodoris†#. Quantized multi-task learning for context-specific representations of gene network dynamics. _**bioRxiv**_, 19 Aug 2024. (*co-first authors, †co-senior authors, #corresponding author) +>>>>>>> 09de19734bf3da83050abc74408517ba15b5b185 diff --git a/config.json b/config.json new file mode 100644 index 0000000000000000000000000000000000000000..86e20c35e6f257f0daeb00ebb92a0751d12d8fff --- /dev/null +++ b/config.json @@ -0,0 +1,24 @@ +{ + "architectures": [ + "BertForMaskedLM" + ], + "attention_probs_dropout_prob": 0.02, + "classifier_dropout": null, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 512, + "initializer_range": 0.02, + "intermediate_size": 1024, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 4096, + "model_type": "bert", + "num_attention_heads": 8, + "num_hidden_layers": 12, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "torch_dtype": "float32", + "transformers_version": "4.37.1", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 20275 +} diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..d0c3cbf1020d5c292abdedf27627c6abe25e2293 --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000000000000000000000000000000000000..747ffb7b3033659bdd2d1e6eae41ecb00358a45e --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..d4b51ede80c4f16d12cac47ffe5d17e496a3addd --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,3 @@ +. +sphinx_rtd_theme==2.0.0 +nbsphinx==0.9.3 diff --git a/docs/source/_static/css/custom.css b/docs/source/_static/css/custom.css new file mode 100644 index 0000000000000000000000000000000000000000..1c6748950c328c423cad4a9a039f6477ea19cc4c --- /dev/null +++ b/docs/source/_static/css/custom.css @@ -0,0 +1,40 @@ +/* top left logo */ +.wy-side-nav-search, .wy-nav-top { + background: linear-gradient(15deg, #13547a 0%, #80d0c7 100%); +} + + +/* unvisited link */ +.wy-nav-content a:link { + color: #067abd; +} + +/* visited link */ +.wy-nav-content a:visited { + color: #4b827c; +} + +/* mouse over link */ +.wy-nav-content a:hover { + color: #80d0c7; +} + +/* selected link */ +.wy-nav-content a:active { + color: #4b827c; +} + +/* class object */ +.sig.sig-object { + padding: 5px 5px 5px 5px; + background-color: #ececec; + border-style: solid; + border-color: black; + border-width: 1px 0; +} + +/* parameter object */ +dt { + padding: 5px 5px 5px 5px; + background-color: #ececec; +} diff --git a/docs/source/_static/gf_logo.png b/docs/source/_static/gf_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..68fd0aac123094bdfd9bae1356e6c0012bded8a0 Binary files /dev/null and b/docs/source/_static/gf_logo.png differ diff --git a/docs/source/about.rst b/docs/source/about.rst new file mode 100644 index 0000000000000000000000000000000000000000..7e5a53453d0a3a4ed59f12b4191e17d3d82d4411 --- /dev/null +++ b/docs/source/about.rst @@ -0,0 +1,49 @@ +About +===== + +Model Description +----------------- + +**Geneformer** is a context-aware, attention-based deep learning model pretrained on a large-scale corpus of single-cell transcriptomes to enable context-specific predictions in settings with limited data in network biology. During pretraining, Geneformer gained a fundamental understanding of network dynamics, encoding network hierarchy in the attention weights of the model in a completely self-supervised manner. With both zero-shot learning and fine-tuning with limited task-specific data, Geneformer consistently boosted predictive accuracy in a diverse panel of downstream tasks relevant to chromatin and network dynamics. In silico perturbation with zero-shot learning identified a novel transcription factor in cardiomyocytes that we experimentally validated to be critical to their ability to generate contractile force. In silico treatment with limited patient data revealed candidate therapeutic targets for cardiomyopathy that we experimentally validated to significantly improve the ability of cardiomyocytes to generate contractile force in an iPSC model of the disease. Overall, Geneformer represents a foundational deep learning model pretrained on a large-scale corpus of human single cell transcriptomes to gain a fundamental understanding of gene network dynamics that can now be democratized to a vast array of downstream tasks to accelerate discovery of key network regulators and candidate therapeutic targets. + +In `our manuscript `_, we report results for the original 6 layer Geneformer model pretrained on Genecorpus-30M. We additionally provide within the repository a 12 layer Geneformer model, scaled up with retained width:depth aspect ratio, also pretrained on Genecorpus-30M. + +Both the `6 `_ and `12 `_ layer Geneformer models were pretrained in June 2021. + +Also see `our 2024 manuscript `_, for details of the `expanded model `_ trained on ~95 million transcriptomes in April 2024 and our continual learning, multitask learning, and quantization strategies. + +Application +----------- + +The pretrained Geneformer model can be used directly for zero-shot learning, for example for in silico perturbation analysis, or by fine-tuning towards the relevant downstream task, such as gene or cell state classification. + +Example applications demonstrated in `our manuscript `_ include: + +| *Fine-tuning*: +| - transcription factor dosage sensitivity +| - chromatin dynamics (bivalently marked promoters) +| - transcription factor regulatory range +| - gene network centrality +| - transcription factor targets +| - cell type annotation +| - batch integration +| - cell state classification across differentiation +| - disease classification +| - in silico perturbation to determine disease-driving genes +| - in silico treatment to determine candidate therapeutic targets + +| *Zero-shot learning*: +| - batch integration +| - gene context specificity +| - in silico reprogramming +| - in silico differentiation +| - in silico perturbation to determine impact on cell state +| - in silico perturbation to determine transcription factor targets +| - in silico perturbation to determine transcription factor cooperativity + +Citations +--------- + +| C V Theodoris #, L Xiao, A Chopra, M D Chaffin, Z R Al Sayed, M C Hill, H Mantineo, E Brydon, Z Zeng, X S Liu, P T Ellinor #. `Transfer learning enables predictions in network biology. `_ *Nature*, 31 May 2023. (# co-corresponding authors) + +| H Chen \*, M S Venkatesh \*, J Gomez Ortega, S V Mahesh, T Nandi, R Madduri, K Pelka †, C V Theodoris † #. `Quantized multi-task learning for context-specific representations of gene network dynamics. `_ *bioRxiv*, 19 Aug 2024. (\* co-first authors, † co-senior authors, # corresponding author) diff --git a/docs/source/api.rst b/docs/source/api.rst new file mode 100644 index 0000000000000000000000000000000000000000..36817a1c1ce42a95485eefaa6c2ad1dad0cb78db --- /dev/null +++ b/docs/source/api.rst @@ -0,0 +1,51 @@ +API +=== + +Tokenizer +--------- + +.. toctree:: + :maxdepth: 1 + + geneformer.tokenizer + +Classifier +---------- + +.. toctree:: + :maxdepth: 1 + + geneformer.classifier + +Multitask Classifier +-------------------- + +.. toctree:: + :maxdepth: 1 + + geneformer.mtl_classifier + +Embedding Extractor +------------------- + +.. toctree:: + :maxdepth: 1 + + geneformer.emb_extractor + +In Silico Perturber +------------------- + +.. toctree:: + :maxdepth: 1 + + geneformer.in_silico_perturber + + +In Silico Perturber Stats +------------------------- + +.. toctree:: + :maxdepth: 1 + + geneformer.in_silico_perturber_stats diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000000000000000000000000000000000000..37b658f688ddc54230e18687d43ae4618fdd9ddd --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,80 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +import pathlib +import re +import sys + +from sphinx.ext import autodoc + +sys.path.insert(0, pathlib.Path(__file__).parents[2].resolve().as_posix()) + + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = "geneformer" +copyright = "2024, Christina Theodoris" +author = "Christina Theodoris" +release = "0.1.0" +repository_url = "https://huggingface.co/ctheodoris/Geneformer" + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "nbsphinx", + "sphinx.ext.viewcode", + "sphinx.ext.doctest", +] + +templates_path = ["_templates"] +exclude_patterns = [ + "**.ipynb_checkpoints", +] +autoclass_content = "both" + + +class MockedClassDocumenter(autodoc.ClassDocumenter): + def add_line(self, line: str, source: str, *lineno: int) -> None: + if line == " Bases: :py:class:`object`": + return + super().add_line(line, source, *lineno) + + +autodoc.ClassDocumenter = MockedClassDocumenter +add_module_names = False + + +def process_signature(app, what, name, obj, options, signature, return_annotation): + # loop through each line in the docstring and replace path with + # the generic path text + signature = re.sub(r"PosixPath\(.*?\)", "FILEPATH", signature) + return (signature, None) + + +def setup(app): + app.connect("autodoc-process-signature", process_signature) + + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = "sphinx_rtd_theme" +html_show_sphinx = False +html_static_path = ["_static"] +html_logo = "_static/gf_logo.png" +html_theme_options = { + "collapse_navigation": False, + "sticky_navigation": True, + "navigation_depth": 3, + "logo_only": True, +} +html_css_files = [ + "css/custom.css", +] +html_show_sourcelink = False diff --git a/docs/source/geneformer.classifier.rst b/docs/source/geneformer.classifier.rst new file mode 100644 index 0000000000000000000000000000000000000000..cf3548519d6e5b8df963ede9918e944053b92493 --- /dev/null +++ b/docs/source/geneformer.classifier.rst @@ -0,0 +1,10 @@ +geneformer.classifier +===================== + +.. automodule:: geneformer.classifier + :members: + :undoc-members: + :show-inheritance: + :exclude-members: + valid_option_dict, + validate_options diff --git a/docs/source/geneformer.emb_extractor.rst b/docs/source/geneformer.emb_extractor.rst new file mode 100644 index 0000000000000000000000000000000000000000..0f602294b47f598dde04e16ab2fa0c51ecc43dac --- /dev/null +++ b/docs/source/geneformer.emb_extractor.rst @@ -0,0 +1,26 @@ +geneformer.emb\_extractor +========================= + +.. automodule:: geneformer.emb_extractor + :members: + :undoc-members: + :show-inheritance: + :exclude-members: + accumulate_tdigests, + gen_heatmap_class_colors, + gen_heatmap_class_dict, + get_embs, + label_cell_embs, + label_gene_embs, + make_colorbar, + plot_heatmap, + plot_umap, + summarize_gene_embs, + tdigest_mean, + tdigest_median, + test_emb, + update_tdigest_dict, + update_tdigest_dict_mean, + update_tdigest_dict_median, + valid_option_dict, + validate_options diff --git a/docs/source/geneformer.in_silico_perturber.rst b/docs/source/geneformer.in_silico_perturber.rst new file mode 100644 index 0000000000000000000000000000000000000000..fab76dea3c46244ab15d3d77552bc538535675e5 --- /dev/null +++ b/docs/source/geneformer.in_silico_perturber.rst @@ -0,0 +1,8 @@ +geneformer.in\_silico\_perturber +======================================= + +.. automodule:: geneformer.in_silico_perturber + :members: + :undoc-members: + :show-inheritance: + :exclude-members: valid_option_dict, validate_options, apply_additional_filters, isp_perturb_all, isp_perturb_set, update_perturbation_dictionary diff --git a/docs/source/geneformer.in_silico_perturber_stats.rst b/docs/source/geneformer.in_silico_perturber_stats.rst new file mode 100644 index 0000000000000000000000000000000000000000..97d8f170017ead706fd9160fb622c6debc3b3a1a --- /dev/null +++ b/docs/source/geneformer.in_silico_perturber_stats.rst @@ -0,0 +1,25 @@ +geneformer.in\_silico\_perturber\_stats +============================================== + +.. automodule:: geneformer.in_silico_perturber_stats + :members: + :undoc-members: + :show-inheritance: + :exclude-members: + find, + get_fdr, + get_gene_list, + get_impact_component, + invert_dict, + isp_aggregate_gene_shifts, + isp_aggregate_grouped_perturb, + isp_stats_mixture_model, + isp_stats_to_goal_state, + isp_stats_vs_null, + n_detections, + read_dict, + read_dictionaries, + token_to_gene_name, + token_tuple_to_ensembl_ids, + valid_option_dict, + validate_options diff --git a/docs/source/geneformer.mtl_classifier.rst b/docs/source/geneformer.mtl_classifier.rst new file mode 100644 index 0000000000000000000000000000000000000000..b67c1d30bc13926095c8d5d021e68f5146aff2e1 --- /dev/null +++ b/docs/source/geneformer.mtl_classifier.rst @@ -0,0 +1,11 @@ +geneformer.mtl\_classifier +========================== + +.. automodule:: geneformer.mtl_classifier + :members: + :undoc-members: + :show-inheritance: + :exclude-members: + valid_option_dict, + validate_options, + validate_additional_options diff --git a/docs/source/geneformer.tokenizer.rst b/docs/source/geneformer.tokenizer.rst new file mode 100644 index 0000000000000000000000000000000000000000..b8150d3312ff7eddd56183604e952aa3b06798bc --- /dev/null +++ b/docs/source/geneformer.tokenizer.rst @@ -0,0 +1,15 @@ +geneformer.tokenizer +==================== + +.. automodule:: geneformer.tokenizer + :members: + :undoc-members: + :show-inheritance: + :exclude-members: + create_dataset, + tokenize_anndata, + tokenize_files, + tokenize_loom, + rank_genes, + tokenize_cell, + sum_ensembl_ids diff --git a/docs/source/getstarted.rst b/docs/source/getstarted.rst new file mode 100644 index 0000000000000000000000000000000000000000..fb0d853bc29cb961a844add7b0dede9891ce8689 --- /dev/null +++ b/docs/source/getstarted.rst @@ -0,0 +1,36 @@ +Getting Started +=============== + +Installation +------------ + +Geneformer installation instructions. + +Make sure you have git-lfs installed (https://git-lfs.com). + +.. code-block:: bash + + git lfs install + git clone https://huggingface.co/ctheodoris/Geneformer + cd Geneformer + pip install . + + +Tutorials +--------- + +| See `examples `_ for: +| - tokenizing transcriptomes +| - pretraining +| - hyperparameter tuning +| - fine-tuning +| - extracting and plotting cell embeddings +| - in silico perturbation + +Please note that the fine-tuning examples are meant to be generally applicable and the input datasets and labels will vary dependent on the downstream task. Example input files for a few of the downstream tasks demonstrated in the manuscript are located within the `example_input_files directory `_ in the dataset repository, but these only represent a few example fine-tuning applications. + + +Tips +---- + +Please note that GPU resources are required for efficient usage of Geneformer. Additionally, we strongly recommend tuning hyperparameters for each downstream fine-tuning application as this can significantly boost predictive potential in the downstream task (e.g. max learning rate, learning schedule, number of layers to freeze, etc.). diff --git a/docs/source/index.rst b/docs/source/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..102a5861bc63fccb4ba295afd437fc461dda0d42 --- /dev/null +++ b/docs/source/index.rst @@ -0,0 +1,16 @@ +Geneformer +========== + +Geneformer is a foundation transformer model pretrained on a large-scale corpus of single cell transcriptomes to enable context-aware predictions in network biology. + +See `our manuscript `_ for details. + +Table of Contents +----------------- + +.. toctree:: + :maxdepth: 2 + + about + getstarted + api diff --git a/examples/cell_classification.ipynb b/examples/cell_classification.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..321187b9959abe460c6efc34996d6db0cf3488ed --- /dev/null +++ b/examples/cell_classification.ipynb @@ -0,0 +1,458 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "65a2b29a-c678-4874-a1bf-5af3a7d00ed9", + "metadata": {}, + "source": [ + "## Geneformer Fine-Tuning for Classification of Cardiomyopathy Disease States" + ] + }, + { + "cell_type": "markdown", + "id": "1792e51c-86c3-406f-be5a-273c4e4aec20", + "metadata": {}, + "source": [ + "### Please note that, as usual with deep learning models, we **highly** recommend tuning learning hyperparameters for all fine-tuning applications as this can significantly improve model performance. Example below uses previously optimized hyperparameters, but one can optimize hyperparameters with the argument n_hyperopt_trials=n in cc.validate() where n>0 and represents the number of trials for hyperparameter optimization." + ] + }, + { + "cell_type": "markdown", + "id": "3dad7564-b464-4d37-9188-17c0ae4ae59f", + "metadata": {}, + "source": [ + "### Train cell classifier with 70% of data (with hyperparameters previously optimized based on 15% of data as validation set) and evaluate on held-out test set of 15% of data" + ] + }, + { + "cell_type": "markdown", + "id": "9027e51e-7830-4ab8-aebf-b9779b3ea2c1", + "metadata": {}, + "source": [ + "### Fine-tune the model for cell state classification" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "efe3b79b-aa8f-416c-9755-7f9299d6a81e", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "from geneformer import Classifier\n", + "\n", + "current_date = datetime.datetime.now()\n", + "datestamp = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}{current_date.hour:02d}{current_date.minute:02d}{current_date.second:02d}\"\n", + "datestamp_min = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}\"\n", + "\n", + "output_prefix = \"cm_classifier_test\"\n", + "output_dir = f\"/path/to/output_dir/{datestamp}\"\n", + "!mkdir $output_dir" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f070ab20-1b18-4941-a5c7-89e23b519261", + "metadata": {}, + "outputs": [], + "source": [ + "filter_data_dict={\"cell_type\":[\"Cardiomyocyte1\",\"Cardiomyocyte2\",\"Cardiomyocyte3\"]}\n", + "training_args = {\n", + " \"num_train_epochs\": 0.9,\n", + " \"learning_rate\": 0.000804,\n", + " \"lr_scheduler_type\": \"polynomial\",\n", + " \"warmup_steps\": 1812,\n", + " \"weight_decay\":0.258828,\n", + " \"per_device_train_batch_size\": 12,\n", + " \"seed\": 73,\n", + "}\n", + "\n", + "# OF NOTE: token_dictionary_file must be set to the gc-30M token dictionary if using a 30M series model\n", + "# (otherwise the Classifier will use the current default model dictionary)\n", + "# 30M token dictionary: https://huggingface.co/ctheodoris/Geneformer/blob/main/geneformer/gene_dictionaries_30m/token_dictionary_gc30M.pkl\n", + "cc = Classifier(classifier=\"cell\",\n", + " cell_state_dict = {\"state_key\": \"disease\", \"states\": \"all\"},\n", + " filter_data=filter_data_dict,\n", + " training_args=training_args,\n", + " max_ncells=None,\n", + " freeze_layers = 2,\n", + " num_crossval_splits = 1,\n", + " forward_batch_size=200,\n", + " nproc=16)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0bced2e8-0a49-418e-a7f9-3981be256bd6", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c409ca656ed4cb0b280d95e326c1bc7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Saving the dataset (0/3 shards): 0%| | 0/115367 [00:00\n", + " \n", + " \n", + " [7020/7020 26:02, Epoch 0/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation LossAccuracyMacro F1
00.1424000.3891660.8897970.693074

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/gladstone/theodoris/home/ctheodoris/Geneformer/geneformer/collator_for_classification.py:581: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " batch = {k: torch.tensor(v, dtype=torch.int64) for k, v in batch.items()}\n" + ] + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_valid_id_split_dict = {\"attr_key\": \"individual\",\n", + " \"train\": train_ids,\n", + " \"eval\": eval_ids}\n", + "\n", + "# Example 6 layer 30M Geneformer model: https://huggingface.co/ctheodoris/Geneformer/blob/main/gf-6L-30M-i2048/model.safetensors\n", + "all_metrics = cc.validate(model_directory=\"/path/to/Geneformer\",\n", + " prepared_input_data_file=f\"{output_dir}/{output_prefix}_labeled_train.dataset\",\n", + " id_class_dict_file=f\"{output_dir}/{output_prefix}_id_class_dict.pkl\",\n", + " output_directory=output_dir,\n", + " output_prefix=output_prefix,\n", + " split_id_dict=train_valid_id_split_dict)\n", + " # to optimize hyperparameters, set n_hyperopt_trials=100 (or alternative desired # of trials)" + ] + }, + { + "cell_type": "markdown", + "id": "6eca8ab4-6f4d-4dd6-9b90-edfb5cc7417c", + "metadata": {}, + "source": [ + "### Evaluate the model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f580021e-2b70-4ebc-943c-2bfe6177e1b5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Hyperparameter tuning is highly recommended for optimal results. No training_args provided; using default hyperparameters.\n" + ] + } + ], + "source": [ + "cc = Classifier(classifier=\"cell\",\n", + " cell_state_dict = {\"state_key\": \"disease\", \"states\": \"all\"},\n", + " forward_batch_size=200,\n", + " nproc=16)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b05398b4-bca1-44b0-8160-637489f16646", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8e93a706295b49a1996b275eba3e9f31", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/87 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cc.plot_conf_mat(\n", + " conf_mat_dict={\"Geneformer\": all_metrics_test[\"conf_matrix\"]},\n", + " output_directory=output_dir,\n", + " output_prefix=output_prefix,\n", + " custom_class_order=[\"nf\",\"hcm\",\"dcm\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0038d701-ab94-46d2-b390-803be0850019", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cc.plot_predictions(\n", + " predictions_file=f\"{output_dir}/{output_prefix}_pred_dict.pkl\",\n", + " id_class_dict_file=f\"{output_dir}/{output_prefix}_id_class_dict.pkl\",\n", + " title=\"disease\",\n", + " output_directory=output_dir,\n", + " output_prefix=output_prefix,\n", + " custom_class_order=[\"nf\",\"hcm\",\"dcm\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "167f8023-82fa-4c05-8f0c-ea45b9c9c199", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'conf_matrix': nf hcm dcm\n", + " nf 3794 385 328\n", + " hcm 562 8680 566\n", + " dcm 13 485 2415,\n", + " 'macro_f1': 0.8426513907521005,\n", + " 'acc': 0.864232644532157,\n", + " 'all_roc_metrics': None}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_metrics_test" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/extract_and_plot_cell_embeddings.ipynb b/examples/extract_and_plot_cell_embeddings.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f00388708664a1cd0c774bfa13f0c01d0ee6578d --- /dev/null +++ b/examples/extract_and_plot_cell_embeddings.ipynb @@ -0,0 +1,140 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2aa9de11-ed78-40d5-83ed-384b11b56b70", + "metadata": {}, + "outputs": [], + "source": [ + "from geneformer import EmbExtractor" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f86fe1e4-eb3d-448e-8b0e-64aefb8ba7fe", + "metadata": {}, + "outputs": [], + "source": [ + "# initiate EmbExtractor\n", + "# OF NOTE: token_dictionary_file must be set to the gc-30M token dictionary if using a 30M series model\n", + "# (otherwise the EmbExtractor will use the current default model dictionary)\n", + "embex = EmbExtractor(model_type=\"CellClassifier\",\n", + " num_classes=3,\n", + " filter_data={\"cell_type\":[\"Cardiomyocyte1\",\"Cardiomyocyte2\",\"Cardiomyocyte3\"]},\n", + " max_ncells=1000,\n", + " emb_layer=0,\n", + " emb_label=[\"disease\",\"cell_type\"],\n", + " labels_to_plot=[\"disease\"],\n", + " forward_batch_size=200,\n", + " nproc=16,\n", + " token_dictionary_file=\"./gene_dictionaries_30m/token_dictionary_gc30M.pkl\") # change from current default dictionary for 30M model series\n", + "\n", + "# extracts embedding from input data\n", + "# input data is tokenized rank value encodings generated by Geneformer tokenizer (see tokenizing_scRNAseq_data.ipynb)\n", + "# example dataset for 30M model series: https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/tree/main/example_input_files/cell_classification/disease_classification/human_dcm_hcm_nf.dataset\n", + "embs = embex.extract_embs(\"../fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224\", # example 30M fine-tuned model\n", + " \"path/to/input_data/\",\n", + " \"path/to/output_directory/\",\n", + " \"output_prefix\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "82d62fa3-6fe0-4a00-baaf-de11610eb051", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: saving figure to file figures/umap_emb_plot_umap_disease.pdf\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot UMAP of cell embeddings\n", + "# note: scanpy umap necessarily saves figs to figures directory\n", + "embex.plot_embs(embs=embs, \n", + " plot_style=\"umap\",\n", + " output_directory=\"path/to/output_directory/\", \n", + " output_prefix=\"emb_plot\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7a48edab-20cf-43bb-814f-5052283c95c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot heatmap of cell embeddings\n", + "embex.plot_embs(embs=embs, \n", + " plot_style=\"heatmap\",\n", + " output_directory=\"path/to/output_directory/\",\n", + " output_prefix=\"emb_plot\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40ec7599-00d2-4878-ba97-8b144ef056d3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/gene_classification.ipynb b/examples/gene_classification.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..284da7a1cc5846566d8b599ac2b549f6dc20f4a4 --- /dev/null +++ b/examples/gene_classification.ipynb @@ -0,0 +1,1251 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "08f41458-5304-48c5-9e92-f9b56ab052c4", + "metadata": {}, + "source": [ + "## Geneformer Fine-Tuning for Classification of Dosage-Sensitive vs. -Insensitive Transcription Factors (TFs)" + ] + }, + { + "cell_type": "markdown", + "id": "79539e95-2c9c-4162-835c-f0d158abb15d", + "metadata": {}, + "source": [ + "### Please note that, as usual with deep learning models, we **highly** recommend tuning learning hyperparameters for all fine-tuning applications as this can significantly improve model performance. Example below uses default hyperparameters, but please see the \"hyperparam_optimiz_for_disease_classifier\" script for an example of how to tune hyperparameters for downstream applications." + ] + }, + { + "cell_type": "markdown", + "id": "51b4852a-9f03-4bc3-ba33-79eaa4582d50", + "metadata": {}, + "source": [ + "### Train gene classifier with 5-fold cross-validation:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "58d59e09-5e6c-4fba-ba2b-3aee103869fd", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import pickle\n", + "from geneformer import Classifier\n", + "\n", + "current_date = datetime.datetime.now()\n", + "datestamp = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}{current_date.hour:02d}{current_date.minute:02d}{current_date.second:02d}\"\n", + "datestamp_min = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}\"\n", + "\n", + "output_prefix = \"tf_dosage_sens_test\"\n", + "output_dir = f\"/path/to/output_dir/{datestamp}\"\n", + "!mkdir $output_dir" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9e33942f-39e4-4db4-a3de-5949bed9fa5d", + "metadata": {}, + "outputs": [], + "source": [ + "# Example input_data_file: https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/blob/main/example_input_files/gene_classification/dosage_sensitive_tfs/dosage_sensitivity_TFs.pickle\n", + "with open(\"/path/to/dosage_sensitivity_TFs.pickle\", \"rb\") as fp:\n", + " gene_class_dict = pickle.load(fp)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f4053ee9-3506-4c97-b544-8d667f0adfab", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Hyperparameter tuning is highly recommended for optimal results. No training_args provided; using default hyperparameters.\n" + ] + } + ], + "source": [ + "# OF NOTE: token_dictionary_file must be set to the gc-30M token dictionary if using a 30M series model\n", + "# (otherwise the Classifier will use the current default model dictionary)\n", + "# 30M token dictionary: https://huggingface.co/ctheodoris/Geneformer/blob/main/geneformer/gene_dictionaries_30m/token_dictionary_gc30M.pkl\n", + "cc = Classifier(classifier=\"gene\",\n", + " gene_class_dict = gene_class_dict,\n", + " max_ncells = 10_000,\n", + " freeze_layers = 4,\n", + " num_crossval_splits = 5,\n", + " forward_batch_size=200,\n", + " nproc=16)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e4855e53-1cd7-4af0-b786-02b6c0e55f8c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6a3f7bcf2a314368b00f49c74a775571", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Saving the dataset (0/1 shards): 0%| | 0/33558 [00:00\n", + " \n", + " \n", + " [834/834 02:37, Epoch 1/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
830.729100
1660.667600
2490.553100
3320.409100
4150.294300
4980.197000
5810.138300
6640.099900
7470.083700
8300.072300

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "****** Validation split: 2/5 ******\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d186836393d84c19b9c0dffafb31a09c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Filter (num_proc=16): 0%| | 0/33558 [00:00\n", + " \n", + " \n", + " [834/834 02:34, Epoch 1/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
830.695400
1660.634600
2490.540200
3320.414800
4150.298500
4980.199100
5810.133200
6640.096300
7470.078100
8300.068100

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "****** Validation split: 3/5 ******\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "93e9c12bc6e243b39224994add37ce21", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Filter (num_proc=16): 0%| | 0/33558 [00:00\n", + " \n", + " \n", + " [834/834 02:35, Epoch 1/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
830.708600
1660.656300
2490.553600
3320.430600
4150.300000
4980.202900
5810.144700
6640.109900
7470.096000
8300.086700

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "****** Validation split: 4/5 ******\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1a9cebe980534274907ae3858a706c37", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Filter (num_proc=16): 0%| | 0/33558 [00:00\n", + " \n", + " \n", + " [834/834 02:35, Epoch 1/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
830.697500
1660.632000
2490.524600
3320.394300
4150.264700
4980.180100
5810.128300
6640.094200
7470.082200
8300.078500

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "****** Validation split: 5/5 ******\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "455067153dc145cba4e3cfdc63f129cc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Filter (num_proc=16): 0%| | 0/33558 [00:00\n", + " \n", + " \n", + " [834/834 02:35, Epoch 1/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
830.711400
1660.644000
2490.535900
3320.395400
4150.275400
4980.193600
5810.129300
6640.093300
7470.070000
8300.067100

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 6 layer 30M Geneformer model: https://huggingface.co/ctheodoris/Geneformer/blob/main/gf-6L-30M-i2048/model.safetensors\n", + "all_metrics = cc.validate(model_directory=\"/path/to/Geneformer\",\n", + " prepared_input_data_file=f\"{output_dir}/{output_prefix}_labeled.dataset\",\n", + " id_class_dict_file=f\"{output_dir}/{output_prefix}_id_class_dict.pkl\",\n", + " output_directory=output_dir,\n", + " output_prefix=output_prefix)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "11a1329b-4968-45f3-ac7a-2438b574404e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cc.plot_conf_mat(\n", + " conf_mat_dict={\"Geneformer\": all_metrics[\"conf_matrix\"]},\n", + " output_directory=output_dir,\n", + " output_prefix=output_prefix,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "edf6ffd9-8b84-4d31-8b39-11959140382f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cc.plot_roc(\n", + " roc_metric_dict={\"Geneformer\": all_metrics[\"all_roc_metrics\"]},\n", + " model_style_dict={\"Geneformer\": {\"color\": \"red\", \"linestyle\": \"-\"}},\n", + " title=\"Dosage-sensitive vs -insensitive factors\",\n", + " output_directory=output_dir,\n", + " output_prefix=output_prefix,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d10ac27f-8d70-400e-8a00-d0b84c1d02b4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'conf_matrix': Dosage-sensitive TFs Dosage-insensitive TFs\n", + " Dosage-sensitive TFs 61229.0 14801.0\n", + " Dosage-insensitive TFs 9094.0 73907.0,\n", + " 'macro_f1': [0.8489695337205987,\n", + " 0.8637730998133415,\n", + " 0.9122635701525341,\n", + " 0.8180200155972593,\n", + " 0.7913574275548942],\n", + " 'acc': [0.8544562281799618,\n", + " 0.8647275498539312,\n", + " 0.9122812348079727,\n", + " 0.8182044035899506,\n", + " 0.798060129740519],\n", + " 'all_roc_metrics': {'mean_tpr': array([0. , 0.29330305, 0.39824459, 0.48477052, 0.53910681,\n", + " 0.58654819, 0.62233428, 0.65499297, 0.68383714, 0.7105218 ,\n", + " 0.7331015 , 0.75404762, 0.77191402, 0.79007262, 0.80530801,\n", + " 0.81812243, 0.83182971, 0.84348565, 0.85308334, 0.86179954,\n", + " 0.87018186, 0.87841599, 0.88666193, 0.89398957, 0.90104605,\n", + " 0.90768847, 0.91468381, 0.92081589, 0.92687436, 0.93170239,\n", + " 0.93600138, 0.93963402, 0.9430781 , 0.94641134, 0.94881205,\n", + " 0.95143243, 0.95361201, 0.95556462, 0.95766077, 0.95966244,\n", + " 0.96118109, 0.96277551, 0.96448544, 0.96590662, 0.96726595,\n", + " 0.96852001, 0.96991619, 0.97113487, 0.9723888 , 0.97361378,\n", + " 0.97487929, 0.97591807, 0.97725326, 0.97856005, 0.97952476,\n", + " 0.98071045, 0.98164245, 0.98264028, 0.98393822, 0.9850845 ,\n", + " 0.98620898, 0.9872157 , 0.98857151, 0.98954745, 0.99058733,\n", + " 0.99138259, 0.99226871, 0.99306583, 0.99380789, 0.99461065,\n", + " 0.99527049, 0.99592002, 0.99655526, 0.99691174, 0.99757778,\n", + " 0.9978895 , 0.99816814, 0.99852539, 0.99874352, 0.99896924,\n", + " 0.99925024, 0.9993954 , 0.99949426, 0.99964604, 0.99974177,\n", + " 0.99977018, 0.9998233 , 0.99984802, 0.99990114, 0.99994688,\n", + " 0.99996108, 0.99997159, 1. , 1. , 1. ,\n", + " 1. , 1. , 1. , 1. , 1. ]),\n", + " 'mean_fpr': array([0. , 0.01010101, 0.02020202, 0.03030303, 0.04040404,\n", + " 0.05050505, 0.06060606, 0.07070707, 0.08080808, 0.09090909,\n", + " 0.1010101 , 0.11111111, 0.12121212, 0.13131313, 0.14141414,\n", + " 0.15151515, 0.16161616, 0.17171717, 0.18181818, 0.19191919,\n", + " 0.2020202 , 0.21212121, 0.22222222, 0.23232323, 0.24242424,\n", + " 0.25252525, 0.26262626, 0.27272727, 0.28282828, 0.29292929,\n", + " 0.3030303 , 0.31313131, 0.32323232, 0.33333333, 0.34343434,\n", + " 0.35353535, 0.36363636, 0.37373737, 0.38383838, 0.39393939,\n", + " 0.4040404 , 0.41414141, 0.42424242, 0.43434343, 0.44444444,\n", + " 0.45454545, 0.46464646, 0.47474747, 0.48484848, 0.49494949,\n", + " 0.50505051, 0.51515152, 0.52525253, 0.53535354, 0.54545455,\n", + " 0.55555556, 0.56565657, 0.57575758, 0.58585859, 0.5959596 ,\n", + " 0.60606061, 0.61616162, 0.62626263, 0.63636364, 0.64646465,\n", + " 0.65656566, 0.66666667, 0.67676768, 0.68686869, 0.6969697 ,\n", + " 0.70707071, 0.71717172, 0.72727273, 0.73737374, 0.74747475,\n", + " 0.75757576, 0.76767677, 0.77777778, 0.78787879, 0.7979798 ,\n", + " 0.80808081, 0.81818182, 0.82828283, 0.83838384, 0.84848485,\n", + " 0.85858586, 0.86868687, 0.87878788, 0.88888889, 0.8989899 ,\n", + " 0.90909091, 0.91919192, 0.92929293, 0.93939394, 0.94949495,\n", + " 0.95959596, 0.96969697, 0.97979798, 0.98989899, 1. ]),\n", + " 'all_roc_auc': [0.9373324264902606,\n", + " 0.9410936383111078,\n", + " 0.9635257667493496,\n", + " 0.8903987740960708,\n", + " 0.8781592994811886],\n", + " 'roc_auc': 0.9141830130444975,\n", + " 'roc_auc_sd': 0.03204329033266111}}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_metrics" + ] + }, + { + "cell_type": "markdown", + "id": "7007e45e-16c2-47a3-962c-92b9fe867bde", + "metadata": {}, + "source": [ + "### Train gene classifier with all data:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6df82c21-937c-4563-ba6b-a52ce287f542", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import pickle\n", + "from geneformer import Classifier\n", + "\n", + "current_date = datetime.datetime.now()\n", + "datestamp = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}{current_date.hour:02d}{current_date.minute:02d}{current_date.second:02d}\"\n", + "datestamp_min = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}\"\n", + "\n", + "\n", + "output_prefix = \"tf_dosage_sens_alldata\"\n", + "output_dir = f\"/path/to/output_dir/{datestamp}\"\n", + "!mkdir $output_dir" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f031131c-54fd-4ad1-a925-bf0846cc3235", + "metadata": {}, + "outputs": [], + "source": [ + "# Example input_data_file: https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/blob/main/example_input_files/gene_classification/dosage_sensitive_tfs/dosage_sensitivity_TFs.pickle\n", + "with open(\"/path/to/dosage_sensitivity_TFs.pickle\", \"rb\") as fp:\n", + " gene_class_dict = pickle.load(fp)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cd27b15c-52d4-46a6-af8c-812c8731f82c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Hyperparameter tuning is highly recommended for optimal results. No training_args provided; using default hyperparameters.\n" + ] + } + ], + "source": [ + "cc = Classifier(classifier=\"gene\",\n", + " gene_class_dict = gene_class_dict,\n", + " max_ncells = 10_000,\n", + " freeze_layers = 4,\n", + " num_crossval_splits = 0,\n", + " forward_batch_size=200,\n", + " nproc=16)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3d542bda-fbab-4d63-ab58-00d4caa996b9", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7f77eaec105642b199a9e797fccdbf4b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Saving the dataset (0/1 shards): 0%| | 0/33558 [00:00\n", + " \n", + " \n", + " [834/834 02:35, Epoch 1/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
830.700600
1660.643100
2490.544700
3320.412900
4150.298600
4980.205700
5810.138900
6640.103200
7470.090000
8300.083100

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 6 layer Geneformer: https://huggingface.co/ctheodoris/Geneformer/blob/main/model.safetensors\n", + "trainer_test = cc.train_all_data(model_directory=\"/path/to/Geneformer\",\n", + " prepared_input_data_file=f\"{output_dir}/{output_prefix}_labeled.dataset\",\n", + " id_class_dict_file=f\"{output_dir}/{output_prefix}_id_class_dict.pkl\",\n", + " output_directory=output_dir,\n", + " output_prefix=output_prefix)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/in_silico_perturbation.ipynb b/examples/in_silico_perturbation.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f7102617ebd36956d07ba61f8e4bccdf0719515e --- /dev/null +++ b/examples/in_silico_perturbation.ipynb @@ -0,0 +1,159 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "e10ac0c9-40ce-41fb-b6fa-3d62b76f2e57", + "metadata": {}, + "outputs": [], + "source": [ + "from geneformer import InSilicoPerturber\n", + "from geneformer import InSilicoPerturberStats\n", + "from geneformer import EmbExtractor" + ] + }, + { + "cell_type": "markdown", + "id": "cbd6851c-060e-4967-b816-e605ffe58b23", + "metadata": { + "tags": [] + }, + "source": [ + "### in silico perturbation in deletion mode to determine genes whose deletion in the dilated cardiomyopathy (dcm) state significantly shifts the embedding towards non-failing (nf) state" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c53e98cd-c603-4878-82ba-db471181bb55", + "metadata": {}, + "outputs": [], + "source": [ + "# first obtain start, goal, and alt embedding positions\n", + "# this function was changed to be separate from perturb_data\n", + "# to avoid repeating calcuations when parallelizing perturb_data\n", + "cell_states_to_model={\"state_key\": \"disease\", \n", + " \"start_state\": \"dcm\", \n", + " \"goal_state\": \"nf\", \n", + " \"alt_states\": [\"hcm\"]}\n", + "\n", + "filter_data_dict={\"cell_type\":[\"Cardiomyocyte1\",\"Cardiomyocyte2\",\"Cardiomyocyte3\"]}\n", + "\n", + "# OF NOTE: token_dictionary_file must be set to the gc-30M token dictionary if using a 30M series model\n", + "# (otherwise the EmbExtractor will use the current default model dictionary)\n", + "# 30M token dictionary: https://huggingface.co/ctheodoris/Geneformer/blob/main/geneformer/gene_dictionaries_30m/token_dictionary_gc30M.pkl\n", + "embex = EmbExtractor(model_type=\"CellClassifier\", # if using previously fine-tuned cell classifier model\n", + " num_classes=3,\n", + " filter_data=filter_data_dict,\n", + " max_ncells=1000,\n", + " emb_layer=0,\n", + " summary_stat=\"exact_mean\",\n", + " forward_batch_size=256,\n", + " nproc=16)\n", + "\n", + "state_embs_dict = embex.get_state_embs(cell_states_to_model,\n", + " \"../fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224\", # example 30M fine-tuned model\n", + " \"path/to/input_data\",\n", + " \"path/to/output_directory\",\n", + " \"output_prefix\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "981e1190-62da-4543-b7d3-6e2a2d6a6d56", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# OF NOTE: token_dictionary_file must be set to the gc-30M token dictionary if using a 30M series model\n", + "# (otherwise the InSilicoPerturber will use the current default model dictionary)\n", + "# 30M token dictionary: https://huggingface.co/ctheodoris/Geneformer/blob/main/geneformer/gene_dictionaries_30m/token_dictionary_gc30M.pkl\n", + "isp = InSilicoPerturber(perturb_type=\"delete\",\n", + " perturb_rank_shift=None,\n", + " genes_to_perturb=\"all\",\n", + " combos=0,\n", + " anchor_gene=None,\n", + " model_type=\"CellClassifier\", # if using previously fine-tuned cell classifier model\n", + " num_classes=3,\n", + " emb_mode=\"cell\",\n", + " cell_emb_style=\"mean_pool\",\n", + " filter_data=filter_data_dict,\n", + " cell_states_to_model=cell_states_to_model,\n", + " state_embs_dict=state_embs_dict,\n", + " max_ncells=2000,\n", + " emb_layer=0,\n", + " forward_batch_size=400,\n", + " nproc=16)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0525a663-871a-4ce0-a135-cc203817ffa9", + "metadata": {}, + "outputs": [], + "source": [ + "# outputs intermediate files from in silico perturbation\n", + "\n", + "isp.perturb_data(\"../fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224\", # example 30M fine-tuned model\n", + " \"path/to/input_data\",\n", + " \"path/to/isp_output_directory\",\n", + " \"output_prefix\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f8aadabb-516a-4dc0-b307-6de880e64e26", + "metadata": {}, + "outputs": [], + "source": [ + "# OF NOTE: token_dictionary_file must be set to the gc-30M token dictionary if using a 30M series model\n", + "# (otherwise the InSilicoPerturberStats will use the current default model dictionary)\n", + "# 30M token dictionary: https://huggingface.co/ctheodoris/Geneformer/blob/main/geneformer/gene_dictionaries_30m/token_dictionary_gc30M.pkl\n", + "ispstats = InSilicoPerturberStats(mode=\"goal_state_shift\",\n", + " genes_perturbed=\"all\",\n", + " combos=0,\n", + " anchor_gene=None,\n", + " cell_states_to_model=cell_states_to_model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ffecfae6-e737-43e3-99e9-fa37ff46610b", + "metadata": {}, + "outputs": [], + "source": [ + "# extracts data from intermediate files and processes stats to output in final .csv\n", + "ispstats.get_stats(\"path/to/isp_output_directory\", # this should be the directory \n", + " None,\n", + " \"path/to/isp_stats_output_directory\",\n", + " \"output_prefix\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/multitask_cell_classification.ipynb b/examples/multitask_cell_classification.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b3f13b7477c7fb8797bf871b90f943877fb61029 --- /dev/null +++ b/examples/multitask_cell_classification.ipynb @@ -0,0 +1,420 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "866f100c-e11a-4e7b-a37c-831775d845a7", + "metadata": {}, + "source": [ + "# Geneformer Multi-Task Cell Classifier Tutorial\n", + "\n", + "This tutorial demonstrates how to use the Geneformer Multi-Task Cell Classifier and optimizatize hyperparameter for fine-tuning" + ] + }, + { + "cell_type": "markdown", + "id": "311ba456-b44d-40c7-941d-3fc03bcda85a", + "metadata": {}, + "source": [ + "## 1. Installation and Imports\n", + "\n", + "First import the necessary modules." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cd9defdc-0524-4c3b-a741-27117ed3a5be", + "metadata": {}, + "outputs": [], + "source": [ + "from geneformer import MTLClassifier" + ] + }, + { + "cell_type": "markdown", + "id": "790e9c3c-f6d9-44b3-b9a5-05725760f4fd", + "metadata": {}, + "source": [ + "## 2. Set up Paths and Parameters\n", + "\n", + "Now, let's set up the necessary paths and parameters for our classifier. We'll also define our task columns, which are specific columns from our dataset that represent the classification tasks we want to train the model on." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04a04197-8e45-47f8-a86f-202209ea10ae", + "metadata": {}, + "outputs": [], + "source": [ + "# Define paths\n", + "pretrained_path = \"/path/to/pretrained/Geneformer/model\" \n", + "# input data is tokenized rank value encodings generated by Geneformer tokenizer (see tokenizing_scRNAseq_data.ipynb)\n", + "train_path = \"/path/to/train/data.dataset\"\n", + "val_path = \"/path/to/val/data.dataset\"\n", + "test_path = \"/path/to/test/data.dataset\"\n", + "results_dir = \"/path/to/results/directory\"\n", + "model_save_path = \"/path/to/model/save/path\"\n", + "tensorboard_log_dir = \"/path/to/tensorboard/log/dir\"\n", + "\n", + "# Define tasks and hyperparameters\n", + "# task_columns should be a list of column names from your dataset\n", + "# Each column represents a specific classification task (e.g. cell type, disease state)\n", + "task_columns = [\"cell_type\", \"disease_state\"] # Example task columns\n", + "\n", + "hyperparameters = {\n", + " \"learning_rate\": {\"type\": \"float\", \"low\": 1e-5, \"high\": 1e-3, \"log\": True},\n", + " \"warmup_ratio\": {\"type\": \"float\", \"low\": 0.005, \"high\": 0.01},\n", + " \"weight_decay\": {\"type\": \"float\", \"low\": 0.01, \"high\": 0.1},\n", + " \"dropout_rate\": {\"type\": \"float\", \"low\": 0.0, \"high\": 0.7},\n", + " \"lr_scheduler_type\": {\"type\": \"categorical\", \"choices\": [\"cosine\"]},\n", + " \"task_weights\": {\"type\": \"float\", \"low\": 0.1, \"high\": 2.0}\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "31857690-a739-435a-aefd-f171fafc1b78", + "metadata": {}, + "source": [ + "In the code above, we've defined `task_columns` as `[\"cell_type\", \"disease_state\"]`. This means our model will be trained to classify cells based on two tasks:\n", + "1. Identifying the cell type\n", + "2. Determining the disease state\n", + "3. Note: \"unique_cell_id\" is a required column in the dataset for logging and inference purposes\n", + "\n", + "These column names should correspond to actual columns in your dataset. Each column should contain the labels for that specific classification task.\n", + "\n", + "For example, your dataset might look something like this:\n", + "\n", + " | unique_cell_id | input_ids | ... | cell_type | disease_state |\n", + " |----------------|-----------|-----|-----------|---------------|\n", + " | cell1 | ... | ... | neuron | healthy |\n", + " | cell2 | ... | ... | astrocyte | diseased |\n", + " | ... | ... | ... | ... | ... |\n", + "The model will learn to predict classes within 'cell_type' and 'disease_state' " + ] + }, + { + "cell_type": "markdown", + "id": "b9e3050a-6162-4c01-b6fd-8784bf4ab1e4", + "metadata": {}, + "source": [ + "## 3. Initialize the MTLClassifier\n", + "\n", + "Now, let's create an instance of the MTLClassifier with our defined parameters and task columns." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e27caac9-670c-409d-9313-50201c665cb9", + "metadata": {}, + "outputs": [], + "source": [ + "mc = MTLClassifier(\n", + " task_columns=task_columns, # Our defined classification tasks\n", + " study_name=\"MTLClassifier_example\",\n", + " pretrained_path=pretrained_path,\n", + " train_path=train_path,\n", + " val_path=val_path,\n", + " test_path=test_path,\n", + " model_save_path=model_save_path,\n", + " results_dir=results_dir,\n", + " tensorboard_log_dir=tensorboard_log_dir,\n", + " hyperparameters=hyperparameters,\n", + " n_trials=15, # Number of trials for hyperparameter optimization (at least 50 suggested)\n", + " epochs=1, # Number of training epochs (1 suggested to prevent overfitting)\n", + " batch_size=8, # Adjust based on available GPU memory\n", + " seed=42\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0d729444-e3ad-4584-9659-0c464ac97462", + "metadata": {}, + "source": [ + "## 4. Run Hyperparameter Optimization\n", + "\n", + "Now, let's run the Optuna study to optimize our hyperparameters for both classification tasks." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9298aa3e-6a52-4aa8-b9ff-b63d97beac93", + "metadata": {}, + "outputs": [], + "source": [ + "mc.run_optuna_study()" + ] + }, + { + "cell_type": "markdown", + "id": "af23075d-d07b-43d3-bc5d-4df4d5d7199b", + "metadata": {}, + "source": [ + "## 5. Evaluate the Model on Test Data\n", + "\n", + "After optimization, we can evaluate our model on the test dataset. This will provide performance metrics for both classification tasks. CSV containing following keys will be generated in specified results directiory \"Cell ID, task(1...n) True,task(1.,.n) Pred,task(1...n) Probabilities\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "461bf8d3-b964-4ff4-994f-9f3d313d4614", + "metadata": {}, + "outputs": [], + "source": [ + "mc.load_and_evaluate_test_model()" + ] + }, + { + "cell_type": "markdown", + "id": "31cfeb2d-6673-4b02-a79c-2533cc5e4d28", + "metadata": {}, + "source": [ + "## 6. (Optional) Manual Hyperparameter Tuning\n", + "\n", + "If you prefer to set hyperparameters manually, you can use the following approach:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ee6b99f-42e9-4abf-a292-aa9047735e0e", + "metadata": {}, + "outputs": [], + "source": [ + "manual_hyperparameters = {\n", + " \"learning_rate\": 0.001,\n", + " \"warmup_ratio\": 0.01,\n", + " \"weight_decay\": 0.1,\n", + " \"dropout_rate\": 0.1,\n", + " \"lr_scheduler_type\": \"cosine\",\n", + " \"task_weights\": [1, 1], # Weights for each task (cell_type, disease_state)\n", + " \"max_layers_to_freeze\": 2\n", + "}\n", + "\n", + "mc_manual = MTLClassifier(\n", + " task_columns=task_columns,\n", + " study_name=\"mtl_manual\",\n", + " pretrained_path=pretrained_path,\n", + " train_path=train_path,\n", + " val_path=val_path,\n", + " test_path=test_path,\n", + " model_save_path=model_save_path,\n", + " results_dir=results_dir,\n", + " tensorboard_log_dir=tensorboard_log_dir,\n", + " manual_hyperparameters=manual_hyperparameters,\n", + " use_manual_hyperparameters=True,\n", + " epochs=10,\n", + " batch_size=32,\n", + " seed=42\n", + ")\n", + "\n", + "mc_manual.run_manual_tuning()" + ] + }, + { + "cell_type": "markdown", + "id": "dbaac008-fc00-4b71-8e78-89b2d922d9d8", + "metadata": {}, + "source": [ + "# Geneformer In Silico Perturber Tutorial (MTL Quantized)\n", + "This demonstrates how to use the Geneformer In Silico Perturber with a Multi-Task Learning (MTL) model in a quantized configuration to optimize runtime and memory." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e15ad57-736c-48f0-be87-39cf5015bc5c", + "metadata": {}, + "outputs": [], + "source": [ + "from geneformer import InSilicoPerturber, EmbExtractor, InSilicoPerturberStats" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43c18140-151e-4d44-95b4-a9b3a47172cf", + "metadata": {}, + "outputs": [], + "source": [ + "# Define paths\n", + "model_directory = \"/path/to/model/save/path\"\n", + "input_data_file = \"/path/to/input/data.dataset\"\n", + "output_directory = \"/path/to/output/directory\"\n", + "output_prefix = \"mtl_quantized_perturbation\"\n", + "\n", + "# Define parameters\n", + "perturb_type = \"delete\" # or \"overexpress\"\n", + "\n", + "# Define cell states to model\n", + "cell_states_to_model = {\n", + " \"state_key\": \"disease_state\", \n", + " \"start_state\": \"disease\", \n", + " \"goal_state\": \"control\"\n", + "}\n", + "\n", + "# Define filter data\n", + "filter_data_dict = {\n", + " \"cell_type\": [\"Fibroblast\"]\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "3010d0bf-b23c-45c1-ac12-8c472dc8b7a1", + "metadata": {}, + "source": [ + "## 3. Extract State Embeddings\n", + "\n", + "Before we initialize the InSilicoPerturber, we need to extract the state embeddings using the EmbExtractor." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "215f0a90-8041-417d-a5d3-b2483626c3b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize EmbExtractor\n", + "embex = EmbExtractor(\n", + " filter_data_dict=filter_data_dict,\n", + " max_ncells=1000, # Number of cells to extract embeddings for\n", + " emb_layer=0, # Use the second to last layer\n", + " emb_mode = \"cls\",\n", + " summary_stat=\"exact_mean\",\n", + " forward_batch_size=8, # Adjust based on available GPU memory\n", + " nproc=4\n", + ")\n", + "\n", + "# Extract state embeddings\n", + "state_embs_dict = embex.get_state_embs(\n", + " cell_states_to_model,\n", + " model_directory=model_directory,\n", + " input_data_file=input_data_file,\n", + " output_directory=output_directory,\n", + " output_prefix=output_prefix\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "23f14e36-4529-4fb2-8af9-7f4875cf81e3", + "metadata": {}, + "source": [ + "## 4. Initialize the InSilicoPerturber\n", + "\n", + "Now that we have our state embeddings, let's create an instance of the InSilicoPerturber with MTL and quantized configurations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09f985a1-91bc-4e8d-8001-a3663531b570", + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize InSilicoPerturber\n", + "isp = InSilicoPerturber(\n", + " perturb_type=perturb_type,\n", + " genes_to_perturb=\"all\", # Perturb all genes\n", + " model_type=\"MTLCellClassifier-Quantized\", # Use quantized MTL model\n", + " emb_mode=\"cls\", # Use CLS token embedding\n", + " cell_states_to_model=cell_states_to_model,\n", + " state_embs_dict=state_embs_dict,\n", + " max_ncells=1000, # Number of cells to perturb (larger number increases power)\n", + " emb_layer=0, \n", + " forward_batch_size=8, # Adjust based on available GPU memory\n", + " nproc=1\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cfcc2c1e-fd7f-4a36-99fc-ac7f43e5be6b", + "metadata": {}, + "source": [ + "## 5. Run In Silico Perturbation\n", + "\n", + "Run the in silico perturbation on the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf030c09-8ae4-45a7-aaf7-3fc2af4fe296", + "metadata": {}, + "outputs": [], + "source": [ + "# Run perturbation and output intermediate files\n", + "isp.perturb_data(\n", + " model_directory=model_directory,\n", + " input_data_file=input_data_file,\n", + " output_directory=output_directory,\n", + " output_prefix=output_prefix\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "bb8ec074-6f2f-422b-a973-37ed32a15c38", + "metadata": {}, + "source": [ + "## 6. Process Results with InSilicoPerturberStats\n", + "\n", + "After running the perturbation, we'll use InSilicoPerturberStats to process the intermediate files and generate the final statistics." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a748043-43fc-47ad-ace5-f0ae3dd34674", + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize InSilicoPerturberStats\n", + "ispstats = InSilicoPerturberStats(\n", + " mode=\"goal_state_shift\",\n", + " genes_perturbed=\"all\",\n", + " combos=0,\n", + " anchor_gene=None,\n", + " cell_states_to_model=cell_states_to_model\n", + ")\n", + "\n", + "# Process stats and output final .csv\n", + "ispstats.get_stats(\n", + " input_data_file,\n", + " None,\n", + " output_directory,\n", + " output_prefix\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/pretraining_new_model/obtain_nonzero_median_digests.ipynb b/examples/pretraining_new_model/obtain_nonzero_median_digests.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8dddf0b8c5c7dceb5557468c003d445636c6ee7c --- /dev/null +++ b/examples/pretraining_new_model/obtain_nonzero_median_digests.ipynb @@ -0,0 +1,365 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "charged-worcester", + "metadata": {}, + "source": [ + "# Obtain non-zero median expression value of each gene across Genecorpus-30M" + ] + }, + { + "cell_type": "markdown", + "id": "28e87f2a-a33e-4fe3-81af-ad4cd62fcc1b", + "metadata": {}, + "source": [ + "#### Upon request, we are providing the code that we used for obtaining the non-zero median expression value of each gene across the broad range of cell types represented in Genecorpus-30M that we use as a normalization factor to prioritize genes that uniquely distinguish cell state.\n", + "\n", + "#### Please read the important information below before using this code.\n", + "\n", + "#### If using Geneformer, to ensure consistency of the normalization factor used for each gene for all future datasets, **users should use the Geneformer transcriptome tokenizer to tokenize their datasets and should not re-calculate this normalization factor for their individual dataset** . This code for re-calculating the normalization factor should only be used by users who are pretraining a new model from scratch with a new pretraining corpus other than Genecorpus-30M.\n", + "\n", + "#### It is critical that this calculation is performed on a large-scale pretraining corpus that has tens of millions of cells from a broad range of human tissues. **The richness of variable cell states in the pretraining corpus is what allows this normalization factor to accomplish the goal of prioritizing genes that uniquely distinguish cell states.** This normalization factor for each gene is calculated once from the large-scale pretraining corpus and is used for all future datasets presented to the model. \n", + "\n", + "#### Of note, as discussed in the Methods, we only included droplet-based sequencing platforms in the pretraining corpus to assure expression value unit comparability for the calculation of this normalization factor. Users wishing to pretrain a new model from scratch with a new pretraining corpus should choose either droplet-based or plate-based platforms for calculating this normalization factor, or they should exercise caution that including both platforms may cause unintended effects on the results. Once the normalization factor is calculated however, data from any platform can be used with the model because the expression value units will be consistent within each individual cell.\n", + "\n", + "#### Please see the Methods in the manuscript for a description of the procedure enacted by this code, an excerpt of which is below for convenience:\n", + "\n", + "#### \"To accomplish this, we first calculated the non-zero median value of expression of each detected gene across all cells passing quality filtering from the entire Genecorpus-30M. We aggregated the transcript count distribution for each gene in a memory-efficient manner by scanning through chunks of .loom data using loompy, normalizing the gene transcript counts in each cell by the total transcript count of that cell to account for varying sequencing depth and updating the normalized count distribution of the gene within the t-digest data structure developed for accurate online accumulation of rank-based statistics. We then normalized the genes in each single-cell transcriptome by the non-zero median value of expression of that gene across Genecorpus-30M and ordered the genes by the rank of their normalized expression in that specific cell. Of note, we opted to use the non-zero median value of expression rather than include zeros in the distribution so as not to weight the value by tissue representation within Genecorpus-30M, assuming that a representative range of transcript values would be observed within the cells in which each gene was detected. This normalization factor for each gene is calculated once from the pretraining corpus and is used for all future datasets presented to the model. The provided tokenizer code includes this normalization procedure and should be used for tokenizing new datasets presented to Geneformer to ensure consistency of the normalization factor used for each gene.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "textile-destruction", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "import loompy as lp\n", + "import pandas as pd\n", + "import crick\n", + "import pickle\n", + "import math\n", + "from tqdm.notebook import tqdm" + ] + }, + { + "cell_type": "markdown", + "id": "4af8cfef-05f2-47e0-b8d2-71ca025059c7", + "metadata": { + "tags": [] + }, + "source": [ + "### The following code is an example of how the nonzero median expression values are obtained for a single input file. This calculation should be run as a script to be parallelized for all dataset files." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "physical-intro", + "metadata": {}, + "outputs": [], + "source": [ + "input_file = \"study1.loom\"\n", + "current_database = \"database1\"\n", + "\n", + "rootdir = f\"/path/to/{current_database}/data/\"\n", + "output_file = input_file.replace(\".loom\", \".gene_median_digest_dict.pickle\")\n", + "outdir = rootdir.replace(\"/data/\", \"/tdigest/\")\n", + "\n", + "with lp.connect(f\"{rootdir}{input_file}\") as data:\n", + " # define coordinates of protein-coding or miRNA genes\n", + " coding_miRNA_loc = np.where((data.ra.gene_type == \"protein_coding\") | (data.ra.gene_type == \"miRNA\"))[0]\n", + " coding_miRNA_genes = data.ra[\"ensembl_id\"][coding_miRNA_loc]\n", + " \n", + " # initiate tdigests\n", + " median_digests = [crick.tdigest.TDigest() for _ in range(len(coding_miRNA_loc))]\n", + " \n", + " # initiate progress meters\n", + " progress = tqdm(total=len(coding_miRNA_loc))\n", + " last_view_row = 0\n", + " progress.update(0)\n", + " \n", + " for (ix, selection, view) in data.scan(items=coding_miRNA_loc, axis=0):\n", + " # define coordinates of cells passing filter\n", + " filter_passed_loc = np.where(view.ca.filter_pass == 1)[0]\n", + " subview = view.view[:, filter_passed_loc]\n", + " # normalize by total counts per cell and multiply by 10,000 to allocate bits to precision\n", + " subview_norm_array = subview[:,:]/subview.ca.n_counts*10_000\n", + " # if integer, convert to float to prevent error with filling with nan\n", + " if np.issubdtype(subview_norm_array.dtype, np.integer):\n", + " subview_norm_array = subview_norm_array.astype(np.float32)\n", + " # mask zeroes from distribution tdigest by filling with nan\n", + " nonzero_data = np.ma.masked_equal(subview_norm_array, 0.0).filled(np.nan)\n", + " # update tdigests\n", + " [median_digests[i+last_view_row].update(nonzero_data[i,:]) for i in range(nonzero_data.shape[0])]\n", + " # update progress meters\n", + " progress.update(view.shape[0])\n", + " last_view_row = last_view_row + view.shape[0]\n", + " \n", + "median_digest_dict = dict(zip(coding_miRNA_genes, median_digests))\n", + "with open(f\"{outdir}{output_file}\", \"wb\") as fp:\n", + " pickle.dump(median_digest_dict, fp)" + ] + }, + { + "cell_type": "markdown", + "id": "190a3754-aafa-4ccf-ba97-951c94ea3030", + "metadata": { + "tags": [] + }, + "source": [ + "### After the above code is run as a script in parallel for all datasets to obtain the nonzero median tdigests for their contained genes, the following code can be run to merge the tdigests across all datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "distributed-riding", + "metadata": {}, + "outputs": [], + "source": [ + "# merge new tdigests into total tdigest dict\n", + "def merge_digest(dict_key_ensembl_id, dict_value_tdigest, new_tdigest_dict):\n", + " new_gene_tdigest = new_tdigest_dict.get(dict_key_ensembl_id)\n", + " if new_gene_tdigest is not None:\n", + " dict_value_tdigest.merge(new_gene_tdigest)\n", + " return dict_value_tdigest\n", + " elif new_gene_tdigest is None:\n", + " return dict_value_tdigest" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "distinct-library", + "metadata": {}, + "outputs": [], + "source": [ + "# use tdigest1.merge(tdigest2) to merge tdigest1, tdigest2, ...tdigestn\n", + "# then, extract median by tdigest1.quantile(0.5)\n", + "\n", + "databases = [\"database1\", \"database2\", \"...databaseN\"]\n", + "\n", + "# obtain gene list\n", + "gene_info = pd.read_csv(\"/path/to/gene_info_table.csv\", index_col=0)\n", + "func_gene_list = [i for i in gene_info[(gene_info[\"gene_type\"] == \"protein_coding\") | (gene_info[\"gene_type\"] == \"miRNA\")][\"ensembl_id\"]]\n", + "\n", + "# initiate tdigests\n", + "median_digests = [crick.tdigest.TDigest() for _ in range(len(func_gene_list))]\n", + "total_tdigest_dict = dict(zip(func_gene_list, median_digests))\n", + "\n", + "# merge tdigests\n", + "for current_database in databases:\n", + " rootdir = f\"/path/to/{current_database}/tdigest/\"\n", + " \n", + " for subdir, dirs, files in os.walk(rootdir):\t\n", + " for file in files:\n", + " if file.endswith(\".gene_median_digest_dict.pickle\"):\n", + " with open(f\"{rootdir}{file}\", \"rb\") as fp:\n", + " tdigest_dict = pickle.load(fp)\n", + " total_tdigest_dict = {k: merge_digest(k,v,tdigest_dict) for k, v in total_tdigest_dict.items()}\n", + "\n", + "# save dict of merged tdigests\n", + "with open(f\"/path/to/total_gene_tdigest_dict.pickle\", \"wb\") as fp:\n", + " pickle.dump(total_tdigest_dict, fp)\n", + "\n", + "# extract medians and save dict\n", + "total_median_dict = {k: v.quantile(0.5) for k, v in total_tdigest_dict.items()}\n", + "with open(f\"/path/to/total_gene_median_dict.pickle\", \"wb\") as fp:\n", + " pickle.dump(total_median_dict, fp)\n", + "\n", + "# save dict of only detected genes' medians \n", + "detected_median_dict = {k: v for k, v in total_median_dict.items() if not math.isnan(v)}\n", + "with open(f\"/path/to/detected_gene_median_dict.pickle\", \"wb\") as fp:\n", + " pickle.dump(detected_median_dict, fp)" + ] + }, + { + "cell_type": "markdown", + "id": "e8e17ad6-79ac-4f34-aa0c-1eaa1bace2e5", + "metadata": { + "tags": [] + }, + "source": [ + "### The below code displays some characteristics of the genes detected in the pretraining corpus." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "decent-switzerland", + "metadata": {}, + "outputs": [], + "source": [ + "gene_detection_counts_dict = {k: v.size() for k, v in total_tdigest_dict.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "polished-innocent", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home1/ct68/miniconda3/lib/python3.8/site-packages/seaborn/distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gene_detection_counts = [i for i in gene_detection_counts_dict.values()]\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "plt.figure(figsize=(10,5), dpi=150)\n", + "plt.rcParams.update({'font.size': 18})\n", + "count_plot = sns.distplot(gene_detection_counts).set_title(f\"# Cells Expressing Each\\nProtein-Coding or miRNA Gene\")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "missing-bradley", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "27454" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(gene_detection_counts)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "perfect-signal", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "25424" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len([i for i in gene_detection_counts if i > 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "faced-theory", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "22735" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len([i for i in gene_detection_counts if i > 100])" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "tough-workplace", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "21167" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len([i for i in gene_detection_counts if i > 1000])" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "cooperative-camcorder", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "173152.0299000284" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gene_detection_event_digest = crick.tdigest.TDigest()\n", + "gene_detection_event_digest.update(gene_detection_counts)\n", + "gene_detection_event_digest.quantile(0.5)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/pretraining_new_model/pretrain_geneformer_w_deepspeed.py b/examples/pretraining_new_model/pretrain_geneformer_w_deepspeed.py new file mode 100644 index 0000000000000000000000000000000000000000..205fb9624ee76d6c0e8c727a8014c8544fd30584 --- /dev/null +++ b/examples/pretraining_new_model/pretrain_geneformer_w_deepspeed.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python +# coding: utf-8 + +# run with: +# deepspeed --num_gpus=12 --num_nodes=3 pretrain_geneformer_w_deepspeed.py --deepspeed ds_config.json + +import datetime + +# imports +import os + +os.environ["NCCL_DEBUG"] = "INFO" +os.environ["OMPI_MCA_opal_cuda_support"] = "true" +os.environ["CONDA_OVERRIDE_GLIBC"] = "2.56" + +import pickle +import random +import subprocess + +import numpy as np +import pytz +import torch +from datasets import load_from_disk +from transformers import BertConfig, BertForMaskedLM, TrainingArguments + +from geneformer import GeneformerPretrainer + +seed_num = 0 +random.seed(seed_num) +np.random.seed(seed_num) +seed_val = 42 +torch.manual_seed(seed_val) +torch.cuda.manual_seed_all(seed_val) + +# set local time/directories +timezone = pytz.timezone("US/Eastern") +rootdir = "/parent_ouput_directory" + +# set model parameters +# model type +model_type = "bert" +# max input size +max_input_size = 2**11 # 2048 +# number of layers +num_layers = 6 +# number of attention heads +num_attn_heads = 4 +# number of embedding dimensions +num_embed_dim = 256 +# intermediate size +intermed_size = num_embed_dim * 2 +# activation function +activ_fn = "relu" +# initializer range, layer norm, dropout +initializer_range = 0.02 +layer_norm_eps = 1e-12 +attention_probs_dropout_prob = 0.02 +hidden_dropout_prob = 0.02 + + +# set training parameters +# total number of examples in Genecorpus-30M after QC filtering: +num_examples = 27_406_208 +# number gpus +num_gpus = 12 +# batch size for training and eval +geneformer_batch_size = 12 +# max learning rate +max_lr = 1e-3 +# learning schedule +lr_schedule_fn = "linear" +# warmup steps +warmup_steps = 10_000 +# number of epochs +epochs = 3 +# optimizer +optimizer = "adamw" +# weight_decay +weight_decay = 0.001 + + +# output directories +current_date = datetime.datetime.now(tz=timezone) +datestamp = f"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}_{current_date.strftime('%X').replace(':','')}" +run_name = f"{datestamp}_geneformer_30M_L{num_layers}_emb{num_embed_dim}_SL{max_input_size}_E{epochs}_B{geneformer_batch_size}_LR{max_lr}_LS{lr_schedule_fn}_WU{warmup_steps}_O{optimizer}_DS{num_gpus}" +training_output_dir = f"{rootdir}/models/{run_name}/" +logging_dir = f"{rootdir}/runs/{run_name}/" +model_output_dir = os.path.join(training_output_dir, "models/") + + +# ensure not overwriting previously saved model +model_output_file = os.path.join(model_output_dir, "pytorch_model.bin") +if os.path.isfile(model_output_file) is True: + raise Exception("Model already saved to this directory.") + + +# make training and model output directories +subprocess.call(f"mkdir {training_output_dir}", shell=True) +subprocess.call(f"mkdir {model_output_dir}", shell=True) + + +# load gene_ensembl_id:token dictionary (e.g. https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/blob/main/token_dictionary.pkl) +with open("token_dictionary.pkl", "rb") as fp: + token_dictionary = pickle.load(fp) + +# model configuration +config = { + "hidden_size": num_embed_dim, + "num_hidden_layers": num_layers, + "initializer_range": initializer_range, + "layer_norm_eps": layer_norm_eps, + "attention_probs_dropout_prob": attention_probs_dropout_prob, + "hidden_dropout_prob": hidden_dropout_prob, + "intermediate_size": intermed_size, + "hidden_act": activ_fn, + "max_position_embeddings": max_input_size, + "model_type": model_type, + "num_attention_heads": num_attn_heads, + "pad_token_id": token_dictionary.get(""), + "vocab_size": len(token_dictionary), # genes+2 for and tokens +} + +config = BertConfig(**config) +model = BertForMaskedLM(config) +model = model.train() + +# define the training arguments +training_args = { + "learning_rate": max_lr, + "do_train": True, + "do_eval": False, + "group_by_length": True, + "length_column_name": "length", + "disable_tqdm": False, + "lr_scheduler_type": lr_schedule_fn, + "warmup_steps": warmup_steps, + "weight_decay": weight_decay, + "per_device_train_batch_size": geneformer_batch_size, + "num_train_epochs": epochs, + "save_strategy": "steps", + "save_steps": np.floor( + num_examples / geneformer_batch_size / 8 + ), # 8 saves per epoch + "logging_steps": 1000, + "output_dir": training_output_dir, + "logging_dir": logging_dir, +} +training_args = TrainingArguments(**training_args) + +print("Starting training.") + +# define the trainer +trainer = GeneformerPretrainer( + model=model, + args=training_args, + # pretraining corpus (e.g. https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/tree/main/genecorpus_30M_2048.dataset) + train_dataset=load_from_disk("genecorpus_30M_2048.dataset"), + # file of lengths of each example cell (e.g. https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/blob/main/genecorpus_30M_2048_lengths.pkl) + example_lengths_file="genecorpus_30M_2048_lengths.pkl", + token_dictionary=token_dictionary, +) + +# train +trainer.train() + +# save model +trainer.save_model(model_output_dir) diff --git a/examples/tokenizing_scRNAseq_data.ipynb b/examples/tokenizing_scRNAseq_data.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..58c629a166529b066ba3615c16a26e59dd46295f --- /dev/null +++ b/examples/tokenizing_scRNAseq_data.ipynb @@ -0,0 +1,91 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a91bca46-c056-4784-8c6c-b0f5d3f33496", + "metadata": { + "tags": [] + }, + "source": [ + "## Tokenizing .loom or .h5ad single cell RNA-seq data to rank value encoding .dataset format" + ] + }, + { + "cell_type": "markdown", + "id": "1fe86f48-5578-47df-b373-58c21ec170ab", + "metadata": {}, + "source": [ + "#### Input data is a directory with .loom or .h5ad files containing raw counts from single cell RNAseq data, including all genes detected in the transcriptome without feature selection. The input file type is specified by the argument file_format in the tokenize_data function.\n", + "\n", + "#### The discussion below references the .loom file format, but the analagous labels are required for .h5ad files, just that they will be column instead of row attributes and vice versa due to the transposed format of the two file types.\n", + "\n", + "#### Genes should be labeled with Ensembl IDs (loom row attribute \"ensembl_id\"), which provide a unique identifer for conversion to tokens. Other forms of gene annotations (e.g. gene names) can be converted to Ensembl IDs via Ensembl Biomart. Cells should be labeled with the total read count in the cell (loom column attribute \"n_counts\") to be used for normalization.\n", + "\n", + "#### No cell metadata is required, but custom cell attributes may be passed onto the tokenized dataset by providing a dictionary of custom attributes to be added, which is formatted as loom_col_attr_name : desired_dataset_col_attr_name. For example, if the original .loom dataset has column attributes \"cell_type\" and \"organ_major\" and one would like to retain these attributes as labels in the tokenized dataset with the new names \"cell_type\" and \"organ\", respectively, the following custom attribute dictionary should be provided: {\"cell_type\": \"cell_type\", \"organ_major\": \"organ\"}. \n", + "\n", + "#### Additionally, if the original .loom file contains a cell column attribute called \"filter_pass\", this column will be used as a binary indicator of whether to include these cells in the tokenized data. All cells with \"1\" in this attribute will be tokenized, whereas the others will be excluded. One may use this column to indicate QC filtering or other criteria for selection for inclusion in the final tokenized dataset.\n", + "\n", + "#### If one's data is in other formats besides .loom or .h5ad, one can use the relevant tools (such as Anndata tools) to convert the file to a .loom or .h5ad format prior to running the transcriptome tokenizer." + ] + }, + { + "cell_type": "markdown", + "id": "32c69493-4e5a-4b07-8dc1-958ff2ee7d0b", + "metadata": {}, + "source": [ + "**********************************************************************************************************\n", + "#### OF NOTE: PLEASE ENSURE THE CORRECT TOKEN DICTIONARY AND GENE MEDIAN FILE IS USED FOR THE CORRECT MODEL.\n", + "#### 95M: current defaults; 30M: https://huggingface.co/ctheodoris/Geneformer/tree/main/geneformer/gene_dictionaries_30m\n", + "\n", + "#### ADDITIONALLY:\n", + "#### The 95M model series require the special_token argument to be set to True and model_input_size to be 4096. (current defaults)\n", + "#### The 30M model series require the special_token argument to be set to False and the model_input_size to be 2048." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "080fdd9c-0c48-4d5d-a254-52b6c53cdf78", + "metadata": {}, + "outputs": [], + "source": [ + "from geneformer import TranscriptomeTokenizer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37205758-aa52-4443-a383-0638519ee8a9", + "metadata": {}, + "outputs": [], + "source": [ + "tk = TranscriptomeTokenizer({\"cell_type\": \"cell_type\", \"organ_major\": \"organ\"}, nproc=16)\n", + "tk.tokenize_data(\"loom_data_directory\", \n", + " \"output_directory\", \n", + " \"output_prefix\", \n", + " file_format=\"loom\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/fine_tuned_models/gf-12L-95M-i4096_MTLCellClassifier_CELLxGENE_240522/config.json b/fine_tuned_models/gf-12L-95M-i4096_MTLCellClassifier_CELLxGENE_240522/config.json new file mode 100755 index 0000000000000000000000000000000000000000..bc8099f84af0bd3e35d700a7135dd417e38f6bea --- /dev/null +++ b/fine_tuned_models/gf-12L-95M-i4096_MTLCellClassifier_CELLxGENE_240522/config.json @@ -0,0 +1,24 @@ +{ + "architectures": [ + "BertForMaskedLM" + ], + "attention_probs_dropout_prob": 0.02, + "classifier_dropout": null, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 512, + "initializer_range": 0.02, + "intermediate_size": 1024, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 4096, + "model_type": "bert", + "num_attention_heads": 8, + "num_hidden_layers": 12, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "torch_dtype": "float32", + "transformers_version": "4.37.2", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 20275 +} diff --git a/fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224/config.json b/fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224/config.json new file mode 100644 index 0000000000000000000000000000000000000000..a97e9ed8ae1716c9a513469ac9fb13762af12379 --- /dev/null +++ b/fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224/config.json @@ -0,0 +1,35 @@ +{ + "_name_or_path": "/n/home01/ctheodoris/models/210602_111318_geneformer_27M_L6_emb256_SL2048_E3_B12_LR0.001_LSlinear_WU10000_Oadamw_DS12/models/", + "architectures": [ + "BertForSequenceClassification" + ], + "attention_probs_dropout_prob": 0.02, + "gradient_checkpointing": false, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 256, + "id2label": { + "0": "LABEL_0", + "1": "LABEL_1", + "2": "LABEL_2" + }, + "initializer_range": 0.02, + "intermediate_size": 512, + "label2id": { + "LABEL_0": 0, + "LABEL_1": 1, + "LABEL_2": 2 + }, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 2048, + "model_type": "bert", + "num_attention_heads": 4, + "num_hidden_layers": 6, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "problem_type": "single_label_classification", + "transformers_version": "4.6.0", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 25426 +} diff --git a/fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224/trainer_state.json b/fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224/trainer_state.json new file mode 100644 index 0000000000000000000000000000000000000000..1a8a9258268b72e5f9c3388e83fade166c2c1050 --- /dev/null +++ b/fine_tuned_models/gf-6L-30M-i2048_CellClassifier_cardiomyopathies_220224/trainer_state.json @@ -0,0 +1,150 @@ +{ + "best_metric": 0.39658036828041077, + "best_model_checkpoint": "/n/holyscratch01/xiaoleliu_lab/Users/ctheodoris/models/220224_geneformer_27M_SequenceClassifier_tuning_hCMdCM_L2048_B12_LR1e-05_LScosine_WU500_E1_Oadamw_F2/run-8429a330/checkpoint-7020", + "epoch": 0.9, + "global_step": 7020, + "is_hyper_param_search": true, + "is_local_process_zero": true, + "is_world_process_zero": true, + "log_history": [ + { + "epoch": 0.1, + "learning_rate": 0.00034606438343856935, + "loss": 0.911, + "step": 780 + }, + { + "epoch": 0.1, + "eval_accuracy": 0.4531576503366612, + "eval_loss": 1.4550466537475586, + "eval_runtime": 66.5164, + "eval_samples_per_second": 259.004, + "step": 780 + }, + { + "epoch": 0.2, + "learning_rate": 0.0006921287668771387, + "loss": 0.6273, + "step": 1560 + }, + { + "epoch": 0.2, + "eval_accuracy": 0.5953680055723242, + "eval_loss": 0.846651554107666, + "eval_runtime": 66.1267, + "eval_samples_per_second": 260.53, + "step": 1560 + }, + { + "epoch": 0.3, + "learning_rate": 0.0007330550166223805, + "loss": 0.5592, + "step": 2340 + }, + { + "epoch": 0.3, + "eval_accuracy": 0.5935105641978176, + "eval_loss": 1.0599186420440674, + "eval_runtime": 66.2608, + "eval_samples_per_second": 260.003, + "step": 2340 + }, + { + "epoch": 0.4, + "learning_rate": 0.0006283471571048975, + "loss": 0.3714, + "step": 3120 + }, + { + "epoch": 0.4, + "eval_accuracy": 0.686324587880195, + "eval_loss": 1.184874415397644, + "eval_runtime": 66.1411, + "eval_samples_per_second": 260.473, + "step": 3120 + }, + { + "epoch": 0.5, + "learning_rate": 0.0005236392975874146, + "loss": 0.2976, + "step": 3900 + }, + { + "epoch": 0.5, + "eval_accuracy": 0.7681100534014396, + "eval_loss": 0.6318939328193665, + "eval_runtime": 66.3309, + "eval_samples_per_second": 259.728, + "step": 3900 + }, + { + "epoch": 0.6, + "learning_rate": 0.0004189314380699318, + "loss": 0.2564, + "step": 4680 + }, + { + "epoch": 0.6, + "eval_accuracy": 0.7807058277223126, + "eval_loss": 0.7283642888069153, + "eval_runtime": 66.3416, + "eval_samples_per_second": 259.686, + "step": 4680 + }, + { + "epoch": 0.7, + "learning_rate": 0.0003142235785524487, + "loss": 0.2336, + "step": 5460 + }, + { + "epoch": 0.7, + "eval_accuracy": 0.8563965637334572, + "eval_loss": 0.5184123516082764, + "eval_runtime": 66.3416, + "eval_samples_per_second": 259.686, + "step": 5460 + }, + { + "epoch": 0.8, + "learning_rate": 0.0002095157190349659, + "loss": 0.1731, + "step": 6240 + }, + { + "epoch": 0.8, + "eval_accuracy": 0.8288832133735778, + "eval_loss": 0.5823884010314941, + "eval_runtime": 66.1535, + "eval_samples_per_second": 260.425, + "step": 6240 + }, + { + "epoch": 0.9, + "learning_rate": 0.00010480785951748295, + "loss": 0.1451, + "step": 7020 + }, + { + "epoch": 0.9, + "eval_accuracy": 0.886812166241003, + "eval_loss": 0.39658036828041077, + "eval_runtime": 66.3555, + "eval_samples_per_second": 259.632, + "step": 7020 + } + ], + "max_steps": 7800, + "num_train_epochs": 1, + "total_flos": 0, + "trial_name": null, + "trial_params": { + "learning_rate": 0.0008039341830649843, + "lr_scheduler_type": "polynomial", + "num_train_epochs": 1, + "per_device_train_batch_size": 12, + "seed": 73.15243080311434, + "warmup_steps": 1812.6785581609881, + "weight_decay": 0.2588277764570262 + } +} diff --git a/geneformer/__init__.py b/geneformer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..52d43619d06f2a7c019b480d1958a82d287d26ff --- /dev/null +++ b/geneformer/__init__.py @@ -0,0 +1,34 @@ +# ruff: noqa: F401 +import warnings +from pathlib import Path + +warnings.filterwarnings("ignore", message=".*The 'nopython' keyword.*") # noqa # isort:skip + +GENE_MEDIAN_FILE = Path(__file__).parent / "gene_median_dictionary_gc95M.pkl" +TOKEN_DICTIONARY_FILE = Path(__file__).parent / "token_dictionary_gc95M.pkl" +ENSEMBL_DICTIONARY_FILE = Path(__file__).parent / "gene_name_id_dict_gc95M.pkl" +ENSEMBL_MAPPING_FILE = Path(__file__).parent / "ensembl_mapping_dict_gc95M.pkl" + +from . import ( + collator_for_classification, + emb_extractor, + in_silico_perturber, + in_silico_perturber_stats, + pretrainer, + tokenizer, +) +from .collator_for_classification import ( + DataCollatorForCellClassification, + DataCollatorForGeneClassification, +) +from .emb_extractor import EmbExtractor, get_embs +from .in_silico_perturber import InSilicoPerturber +from .in_silico_perturber_stats import InSilicoPerturberStats +from .pretrainer import GeneformerPretrainer +from .tokenizer import TranscriptomeTokenizer + +from . import classifier # noqa # isort:skip +from .classifier import Classifier # noqa # isort:skip + +from . import mtl_classifier # noqa # isort:skip +from .mtl_classifier import MTLClassifier # noqa # isort:skip diff --git a/geneformer/classifier.py b/geneformer/classifier.py new file mode 100644 index 0000000000000000000000000000000000000000..b5ac161e461a014cce6df0d75262a1bc98e88259 --- /dev/null +++ b/geneformer/classifier.py @@ -0,0 +1,1563 @@ +""" +Geneformer classifier. + +**Input data:** + +| Cell state classifier: +| Single-cell transcriptomes as Geneformer rank value encodings with cell state labels in Geneformer .dataset format (generated from single-cell RNAseq data by tokenizer.py) + +| Gene classifier: +| Dictionary in format {Gene_label: list(genes)} for gene labels and single-cell transcriptomes as Geneformer rank value encodings in Geneformer .dataset format (generated from single-cell RNAseq data by tokenizer.py) + +**Usage:** + +.. code-block :: python + + >>> from geneformer import Classifier + >>> cc = Classifier(classifier="cell", # example of cell state classifier + ... cell_state_dict={"state_key": "disease", "states": "all"}, + ... filter_data={"cell_type":["Cardiomyocyte1","Cardiomyocyte2","Cardiomyocyte3"]}, + ... training_args=training_args, + ... freeze_layers = 2, + ... num_crossval_splits = 1, + ... forward_batch_size=200, + ... nproc=16) + >>> cc.prepare_data(input_data_file="path/to/input_data", + ... output_directory="path/to/output_directory", + ... output_prefix="output_prefix") + >>> all_metrics = cc.validate(model_directory="path/to/model", + ... prepared_input_data_file=f"path/to/output_directory/{output_prefix}_labeled.dataset", + ... id_class_dict_file=f"path/to/output_directory/{output_prefix}_id_class_dict.pkl", + ... output_directory="path/to/output_directory", + ... output_prefix="output_prefix", + ... predict_eval=True) + >>> cc.plot_conf_mat(conf_mat_dict={"Geneformer": all_metrics["conf_matrix"]}, + ... output_directory="path/to/output_directory", + ... output_prefix="output_prefix", + ... custom_class_order=["healthy","disease1","disease2"]) + >>> cc.plot_predictions(predictions_file=f"path/to/output_directory/datestamp_geneformer_cellClassifier_{output_prefix}/ksplit1/predictions.pkl", + ... id_class_dict_file=f"path/to/output_directory/{output_prefix}_id_class_dict.pkl", + ... title="disease", + ... output_directory="path/to/output_directory", + ... output_prefix="output_prefix", + ... custom_class_order=["healthy","disease1","disease2"]) +""" + +import datetime +import logging +import os +import pickle +import subprocess +from pathlib import Path + +import numpy as np +import pandas as pd +import seaborn as sns +from tqdm.auto import tqdm, trange +from transformers import Trainer +from transformers.training_args import TrainingArguments + +from . import ( + TOKEN_DICTIONARY_FILE, + DataCollatorForCellClassification, + DataCollatorForGeneClassification, +) +from . import classifier_utils as cu +from . import evaluation_utils as eu +from . import perturber_utils as pu + +sns.set() + + +logger = logging.getLogger(__name__) + + +class Classifier: + valid_option_dict = { + "classifier": {"cell", "gene"}, + "quantize": {bool, dict}, + "cell_state_dict": {None, dict}, + "gene_class_dict": {None, dict}, + "filter_data": {None, dict}, + "rare_threshold": {int, float}, + "max_ncells": {None, int}, + "max_ncells_per_class": {None, int}, + "training_args": {None, dict}, + "freeze_layers": {int}, + "num_crossval_splits": {0, 1, 5}, + "split_sizes": {None, dict}, + "no_eval": {bool}, + "stratify_splits_col": {None, str}, + "forward_batch_size": {int}, + "token_dictionary_file": {None, str}, + "nproc": {int}, + "ngpu": {int}, + } + + def __init__( + self, + classifier=None, + quantize=False, + cell_state_dict=None, + gene_class_dict=None, + filter_data=None, + rare_threshold=0, + max_ncells=None, + max_ncells_per_class=None, + training_args=None, + ray_config=None, + freeze_layers=0, + num_crossval_splits=1, + split_sizes={"train": 0.8, "valid": 0.1, "test": 0.1}, + stratify_splits_col=None, + no_eval=False, + forward_batch_size=100, + token_dictionary_file=None, + nproc=4, + ngpu=1, + ): + """ + Initialize Geneformer classifier. + + **Parameters:** + + classifier : {"cell", "gene"} + | Whether to fine-tune a cell state or gene classifier. + quantize : bool, dict + | Whether to fine-tune a quantized model. + | If True and no config provided, will use default. + | Will use custom config if provided. + | Configs should be provided as dictionary of BitsAndBytesConfig (transformers) and LoraConfig (peft). + | For example: {"bnb_config": BitsAndBytesConfig(...), + | "peft_config": LoraConfig(...)} + cell_state_dict : None, dict + | Cell states to fine-tune model to distinguish. + | Two-item dictionary with keys: state_key and states + | state_key: key specifying name of column in .dataset that defines the states to model + | states: list of values in the state_key column that specifies the states to model + | Alternatively, instead of a list of states, can specify "all" to use all states in that state key from input data. + | Of note, if using "all", states will be defined after data is filtered. + | Must have at least 2 states to model. + | For example: {"state_key": "disease", + | "states": ["nf", "hcm", "dcm"]} + | or + | {"state_key": "disease", + | "states": "all"} + gene_class_dict : None, dict + | Gene classes to fine-tune model to distinguish. + | Dictionary in format: {Gene_label_A: list(geneA1, geneA2, ...), + | Gene_label_B: list(geneB1, geneB2, ...)} + | Gene values should be Ensembl IDs. + filter_data : None, dict + | Default is to fine-tune with all input data. + | Otherwise, dictionary specifying .dataset column name and list of values to filter by. + rare_threshold : float + | Threshold below which rare cell states should be removed. + | For example, setting to 0.05 will remove cell states representing + | < 5% of the total cells from the cell state classifier's possible classes. + max_ncells : None, int + | Maximum number of cells to use for fine-tuning. + | Default is to fine-tune with all input data. + max_ncells_per_class : None, int + | Maximum number of cells per cell class to use for fine-tuning. + | Of note, will be applied after max_ncells above. + | (Only valid for cell classification.) + training_args : None, dict + | Training arguments for fine-tuning. + | If None, defaults will be inferred for 6 layer Geneformer. + | Otherwise, will use the Hugging Face defaults: + | https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments + | Note: Hyperparameter tuning is highly recommended, rather than using defaults. + ray_config : None, dict + | Training argument ranges for tuning hyperparameters with Ray. + freeze_layers : int + | Number of layers to freeze from fine-tuning. + | 0: no layers will be frozen; 2: first two layers will be frozen; etc. + num_crossval_splits : {0, 1, 5} + | 0: train on all data without splitting + | 1: split data into train and eval sets by designated split_sizes["valid"] + | 5: split data into 5 folds of train and eval sets by designated split_sizes["valid"] + split_sizes : None, dict + | Dictionary of proportion of data to hold out for train, validation, and test sets + | {"train": 0.8, "valid": 0.1, "test": 0.1} if intending 80/10/10 train/valid/test split + stratify_splits_col : None, str + | Name of column in .dataset to be used for stratified splitting. + | Proportion of each class in this column will be the same in the splits as in the original dataset. + no_eval : bool + | If True, will skip eval step and use all data for training. + | Otherwise, will perform eval during training. + forward_batch_size : int + | Batch size for forward pass (for evaluation, not training). + token_dictionary_file : None, str + | Default is to use token dictionary file from Geneformer + | Otherwise, will load custom gene token dictionary. + nproc : int + | Number of CPU processes to use. + ngpu : int + | Number of GPUs available. + + """ + + self.classifier = classifier + if self.classifier == "cell": + self.model_type = "CellClassifier" + elif self.classifier == "gene": + self.model_type = "GeneClassifier" + self.quantize = quantize + self.cell_state_dict = cell_state_dict + self.gene_class_dict = gene_class_dict + self.filter_data = filter_data + self.rare_threshold = rare_threshold + self.max_ncells = max_ncells + self.max_ncells_per_class = max_ncells_per_class + self.training_args = training_args + self.ray_config = ray_config + self.freeze_layers = freeze_layers + self.num_crossval_splits = num_crossval_splits + self.split_sizes = split_sizes + self.train_size = self.split_sizes["train"] + self.valid_size = self.split_sizes["valid"] + self.oos_test_size = self.split_sizes["test"] + self.eval_size = self.valid_size / (self.train_size + self.valid_size) + self.stratify_splits_col = stratify_splits_col + self.no_eval = no_eval + self.forward_batch_size = forward_batch_size + self.token_dictionary_file = token_dictionary_file + self.nproc = nproc + self.ngpu = ngpu + + if self.training_args is None: + logger.warning( + "Hyperparameter tuning is highly recommended for optimal results. " + "No training_args provided; using default hyperparameters." + ) + + self.validate_options() + + if self.filter_data is None: + self.filter_data = dict() + + if self.classifier == "cell": + if self.cell_state_dict["states"] != "all": + self.filter_data[ + self.cell_state_dict["state_key"] + ] = self.cell_state_dict["states"] + + # load token dictionary (Ensembl IDs:token) + if self.token_dictionary_file is None: + self.token_dictionary_file = TOKEN_DICTIONARY_FILE + with open(self.token_dictionary_file, "rb") as f: + self.gene_token_dict = pickle.load(f) + + self.token_gene_dict = {v: k for k, v in self.gene_token_dict.items()} + + # filter genes for gene classification for those in token dictionary + if self.classifier == "gene": + all_gene_class_values = set(pu.flatten_list(self.gene_class_dict.values())) + missing_genes = [ + gene + for gene in all_gene_class_values + if gene not in self.gene_token_dict.keys() + ] + if len(missing_genes) == len(all_gene_class_values): + logger.error( + "None of the provided genes to classify are in token dictionary." + ) + raise + elif len(missing_genes) > 0: + logger.warning( + f"Genes to classify {missing_genes} are not in token dictionary." + ) + self.gene_class_dict = { + k: list(set([self.gene_token_dict.get(gene) for gene in v])) + for k, v in self.gene_class_dict.items() + } + empty_classes = [] + for k, v in self.gene_class_dict.items(): + if len(v) == 0: + empty_classes += [k] + if len(empty_classes) > 0: + logger.error( + f"Class(es) {empty_classes} did not contain any genes in the token dictionary." + ) + raise + + def validate_options(self): + # confirm arguments are within valid options and compatible with each other + for attr_name, valid_options in self.valid_option_dict.items(): + attr_value = self.__dict__[attr_name] + if not isinstance(attr_value, (list, dict)): + if attr_value in valid_options: + continue + valid_type = False + for option in valid_options: + if (option in [int, float, list, dict, bool, str]) and isinstance( + attr_value, option + ): + valid_type = True + break + if valid_type: + continue + logger.error( + f"Invalid option for {attr_name}. " + f"Valid options for {attr_name}: {valid_options}" + ) + raise + + if self.filter_data is not None: + for key, value in self.filter_data.items(): + if not isinstance(value, list): + self.filter_data[key] = [value] + logger.warning( + "Values in filter_data dict must be lists. " + f"Changing {key} value to list ([{value}])." + ) + + if self.classifier == "cell": + if set(self.cell_state_dict.keys()) != set(["state_key", "states"]): + logger.error( + "Invalid keys for cell_state_dict. " + "The cell_state_dict should have only 2 keys: state_key and states" + ) + raise + + if self.cell_state_dict["states"] != "all": + if not isinstance(self.cell_state_dict["states"], list): + logger.error( + "States in cell_state_dict should be list of states to model." + ) + raise + if len(self.cell_state_dict["states"]) < 2: + logger.error( + "States in cell_state_dict should contain at least 2 states to classify." + ) + raise + + if self.classifier == "gene": + if len(self.gene_class_dict.keys()) < 2: + logger.error( + "Gene_class_dict should contain at least 2 gene classes to classify." + ) + raise + if sum(self.split_sizes.values()) != 1: + logger.error("Train, validation, and test proportions should sum to 1.") + raise + + def prepare_data( + self, + input_data_file, + output_directory, + output_prefix, + split_id_dict=None, + test_size=None, + attr_to_split=None, + attr_to_balance=None, + max_trials=100, + pval_threshold=0.1, + ): + """ + Prepare data for cell state or gene classification. + + **Parameters** + + input_data_file : Path + | Path to directory containing .dataset input + output_directory : Path + | Path to directory where prepared data will be saved + output_prefix : str + | Prefix for output file + split_id_dict : None, dict + | Dictionary of IDs for train and test splits + | Three-item dictionary with keys: attr_key, train, test + | attr_key: key specifying name of column in .dataset that contains the IDs for the data splits + | train: list of IDs in the attr_key column to include in the train split + | test: list of IDs in the attr_key column to include in the test split + | For example: {"attr_key": "individual", + | "train": ["patient1", "patient2", "patient3", "patient4"], + | "test": ["patient5", "patient6"]} + test_size : None, float + | Proportion of data to be saved separately and held out for test set + | (e.g. 0.2 if intending hold out 20%) + | If None, will inherit from split_sizes["test"] from Classifier + | The training set will be further split to train / validation in self.validate + | Note: only available for CellClassifiers + attr_to_split : None, str + | Key for attribute on which to split data while balancing potential confounders + | e.g. "patient_id" for splitting by patient while balancing other characteristics + | Note: only available for CellClassifiers + attr_to_balance : None, list + | List of attribute keys on which to balance data while splitting on attr_to_split + | e.g. ["age", "sex"] for balancing these characteristics while splitting by patient + | Note: only available for CellClassifiers + max_trials : None, int + | Maximum number of trials of random splitting to try to achieve balanced other attributes + | If no split is found without significant (p<0.05) differences in other attributes, will select best + | Note: only available for CellClassifiers + pval_threshold : None, float + | P-value threshold to use for attribute balancing across splits + | E.g. if set to 0.1, will accept trial if p >= 0.1 for all attributes in attr_to_balance + """ + + if test_size is None: + test_size = self.oos_test_size + + # prepare data and labels for classification + data = pu.load_and_filter(self.filter_data, self.nproc, input_data_file) + + if self.classifier == "cell": + if "label" in data.features: + logger.error( + "Column name 'label' must be reserved for class IDs. Please rename column." + ) + raise + elif self.classifier == "gene": + if "labels" in data.features: + logger.error( + "Column name 'labels' must be reserved for class IDs. Please rename column." + ) + raise + + if (attr_to_split is not None) and (attr_to_balance is None): + logger.error( + "Splitting by attribute while balancing confounders requires both attr_to_split and attr_to_balance to be defined." + ) + raise + + if not isinstance(attr_to_balance, list): + attr_to_balance = [attr_to_balance] + + if self.classifier == "cell": + # remove cell states representing < rare_threshold of cells + data = cu.remove_rare( + data, self.rare_threshold, self.cell_state_dict["state_key"], self.nproc + ) + # downsample max cells and max per class + data = cu.downsample_and_shuffle( + data, self.max_ncells, self.max_ncells_per_class, self.cell_state_dict + ) + # rename cell state column to "label" + data = cu.rename_cols(data, self.cell_state_dict["state_key"]) + + # convert classes to numerical labels and save as id_class_dict + # of note, will label all genes in gene_class_dict + # if (cross-)validating, genes will be relabeled in column "labels" for each split + # at the time of training with Classifier.validate + data, id_class_dict = cu.label_classes( + self.classifier, data, self.gene_class_dict, self.nproc + ) + + # save id_class_dict for future reference + id_class_output_path = ( + Path(output_directory) / f"{output_prefix}_id_class_dict" + ).with_suffix(".pkl") + with open(id_class_output_path, "wb") as f: + pickle.dump(id_class_dict, f) + + if split_id_dict is not None: + data_dict = dict() + data_dict["train"] = pu.filter_by_dict( + data, {split_id_dict["attr_key"]: split_id_dict["train"]}, self.nproc + ) + data_dict["test"] = pu.filter_by_dict( + data, {split_id_dict["attr_key"]: split_id_dict["test"]}, self.nproc + ) + train_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_train" + ).with_suffix(".dataset") + test_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_test" + ).with_suffix(".dataset") + data_dict["train"].save_to_disk(str(train_data_output_path)) + data_dict["test"].save_to_disk(str(test_data_output_path)) + elif (test_size is not None) and (self.classifier == "cell"): + if 1 > test_size > 0: + if attr_to_split is None: + data_dict = data.train_test_split( + test_size=test_size, + stratify_by_column=self.stratify_splits_col, + seed=42, + ) + train_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_train" + ).with_suffix(".dataset") + test_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_test" + ).with_suffix(".dataset") + data_dict["train"].save_to_disk(str(train_data_output_path)) + data_dict["test"].save_to_disk(str(test_data_output_path)) + else: + data_dict, balance_df = cu.balance_attr_splits( + data, + attr_to_split, + attr_to_balance, + test_size, + max_trials, + pval_threshold, + self.cell_state_dict["state_key"], + self.nproc, + ) + balance_df.to_csv( + f"{output_directory}/{output_prefix}_train_test_balance_df.csv" + ) + train_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_train" + ).with_suffix(".dataset") + test_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_test" + ).with_suffix(".dataset") + data_dict["train"].save_to_disk(str(train_data_output_path)) + data_dict["test"].save_to_disk(str(test_data_output_path)) + else: + data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled" + ).with_suffix(".dataset") + data.save_to_disk(str(data_output_path)) + print(data_output_path) + else: + data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled" + ).with_suffix(".dataset") + data.save_to_disk(str(data_output_path)) + + def train_all_data( + self, + model_directory, + prepared_input_data_file, + id_class_dict_file, + output_directory, + output_prefix, + save_eval_output=True, + gene_balance=False, + ): + """ + Train cell state or gene classifier using all data. + + **Parameters** + + model_directory : Path + | Path to directory containing model + prepared_input_data_file : Path + | Path to directory containing _labeled.dataset previously prepared by Classifier.prepare_data + id_class_dict_file : Path + | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + output_directory : Path + | Path to directory where model and eval data will be saved + output_prefix : str + | Prefix for output files + save_eval_output : bool + | Whether to save cross-fold eval output + | Saves as pickle file of dictionary of eval metrics + gene_balance : None, bool + | Whether to automatically balance genes in training set. + | Only available for binary gene classifications. + + **Output** + + Returns trainer after fine-tuning with all data. + + """ + + if (gene_balance is True) and (len(self.gene_class_dict.values()) != 2): + logger.error( + "Automatically balancing gene sets for training is only available for binary gene classifications." + ) + raise + + ##### Load data and prepare output directory ##### + # load numerical id to class dictionary (id:class) + with open(id_class_dict_file, "rb") as f: + id_class_dict = pickle.load(f) + class_id_dict = {v: k for k, v in id_class_dict.items()} + + # load previously filtered and prepared data + data = pu.load_and_filter(None, self.nproc, prepared_input_data_file) + data = data.shuffle(seed=42) # reshuffle in case users provide unshuffled data + + # define output directory path + current_date = datetime.datetime.now() + datestamp = f"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}" + if output_directory[-1:] != "/": # add slash for dir if not present + output_directory = output_directory + "/" + output_dir = f"{output_directory}{datestamp}_geneformer_{self.classifier}Classifier_{output_prefix}/" + subprocess.call(f"mkdir {output_dir}", shell=True) + + # get number of classes for classifier + num_classes = cu.get_num_classes(id_class_dict) + + if self.classifier == "gene": + targets = pu.flatten_list(self.gene_class_dict.values()) + labels = pu.flatten_list( + [ + [class_id_dict[label]] * len(targets) + for label, targets in self.gene_class_dict.items() + ] + ) + assert len(targets) == len(labels) + data = cu.prep_gene_classifier_all_data( + data, targets, labels, self.max_ncells, self.nproc, gene_balance + ) + + trainer = self.train_classifier( + model_directory, num_classes, data, None, output_dir + ) + + return trainer + + def validate( + self, + model_directory, + prepared_input_data_file, + id_class_dict_file, + output_directory, + output_prefix, + split_id_dict=None, + attr_to_split=None, + attr_to_balance=None, + gene_balance=False, + max_trials=100, + pval_threshold=0.1, + save_eval_output=True, + predict_eval=True, + predict_trainer=False, + n_hyperopt_trials=0, + save_gene_split_datasets=True, + debug_gene_split_datasets=False, + ): + """ + (Cross-)validate cell state or gene classifier. + + **Parameters** + + model_directory : Path + | Path to directory containing model + prepared_input_data_file : Path + | Path to directory containing _labeled.dataset previously prepared by Classifier.prepare_data + id_class_dict_file : Path + | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + output_directory : Path + | Path to directory where model and eval data will be saved + output_prefix : str + | Prefix for output files + split_id_dict : None, dict + | Dictionary of IDs for train and eval splits + | Three-item dictionary with keys: attr_key, train, eval + | attr_key: key specifying name of column in .dataset that contains the IDs for the data splits + | train: list of IDs in the attr_key column to include in the train split + | eval: list of IDs in the attr_key column to include in the eval split + | For example: {"attr_key": "individual", + | "train": ["patient1", "patient2", "patient3", "patient4"], + | "eval": ["patient5", "patient6"]} + | Note: only available for CellClassifiers with 1-fold split (self.classifier="cell"; self.num_crossval_splits=1) + attr_to_split : None, str + | Key for attribute on which to split data while balancing potential confounders + | e.g. "patient_id" for splitting by patient while balancing other characteristics + | Note: only available for CellClassifiers with 1-fold split (self.classifier="cell"; self.num_crossval_splits=1) + attr_to_balance : None, list + | List of attribute keys on which to balance data while splitting on attr_to_split + | e.g. ["age", "sex"] for balancing these characteristics while splitting by patient + gene_balance : None, bool + | Whether to automatically balance genes in training set. + | Only available for binary gene classifications. + max_trials : None, int + | Maximum number of trials of random splitting to try to achieve balanced other attribute + | If no split is found without significant (p < pval_threshold) differences in other attributes, will select best + pval_threshold : None, float + | P-value threshold to use for attribute balancing across splits + | E.g. if set to 0.1, will accept trial if p >= 0.1 for all attributes in attr_to_balance + save_eval_output : bool + | Whether to save cross-fold eval output + | Saves as pickle file of dictionary of eval metrics + predict_eval : bool + | Whether or not to save eval predictions + | Saves as a pickle file of self.evaluate predictions + predict_trainer : bool + | Whether or not to save eval predictions from trainer + | Saves as a pickle file of trainer predictions + n_hyperopt_trials : int + | Number of trials to run for hyperparameter optimization + | If 0, will not optimize hyperparameters + save_gene_split_datasets : bool + | Whether or not to save train, valid, and test gene-labeled datasets + """ + if self.num_crossval_splits == 0: + logger.error("num_crossval_splits must be 1 or 5 to validate.") + raise + + if (gene_balance is True) and (len(self.gene_class_dict.values()) != 2): + logger.error( + "Automatically balancing gene sets for training is only available for binary gene classifications." + ) + raise + + # ensure number of genes in each class is > 5 if validating model + if self.classifier == "gene": + insuff_classes = [k for k, v in self.gene_class_dict.items() if len(v) < 5] + if (self.num_crossval_splits > 0) and (len(insuff_classes) > 0): + logger.error( + f"Insufficient # of members in class(es) {insuff_classes} to (cross-)validate." + ) + raise + + ##### Load data and prepare output directory ##### + # load numerical id to class dictionary (id:class) + with open(id_class_dict_file, "rb") as f: + id_class_dict = pickle.load(f) + class_id_dict = {v: k for k, v in id_class_dict.items()} + + # load previously filtered and prepared data + data = pu.load_and_filter(None, self.nproc, prepared_input_data_file) + data = data.shuffle(seed=42) # reshuffle in case users provide unshuffled data + + # define output directory path + current_date = datetime.datetime.now() + datestamp = f"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}" + if output_directory[-1:] != "/": # add slash for dir if not present + output_directory = output_directory + "/" + output_dir = f"{output_directory}{datestamp}_geneformer_{self.classifier}Classifier_{output_prefix}/" + subprocess.call(f"mkdir {output_dir}", shell=True) + + # get number of classes for classifier + num_classes = cu.get_num_classes(id_class_dict) + + ##### (Cross-)validate the model ##### + results = [] + all_conf_mat = np.zeros((num_classes, num_classes)) + iteration_num = 1 + if self.classifier == "cell": + for i in trange(self.num_crossval_splits): + print( + f"****** Validation split: {iteration_num}/{self.num_crossval_splits} ******\n" + ) + ksplit_output_dir = os.path.join(output_dir, f"ksplit{iteration_num}") + if self.num_crossval_splits == 1: + # single 1-eval_size:eval_size split + if split_id_dict is not None: + data_dict = dict() + data_dict["train"] = pu.filter_by_dict( + data, + {split_id_dict["attr_key"]: split_id_dict["train"]}, + self.nproc, + ) + data_dict["test"] = pu.filter_by_dict( + data, + {split_id_dict["attr_key"]: split_id_dict["eval"]}, + self.nproc, + ) + elif attr_to_split is not None: + data_dict, balance_df = cu.balance_attr_splits( + data, + attr_to_split, + attr_to_balance, + self.eval_size, + max_trials, + pval_threshold, + self.cell_state_dict["state_key"], + self.nproc, + ) + + balance_df.to_csv( + f"{output_dir}/{output_prefix}_train_valid_balance_df.csv" + ) + else: + data_dict = data.train_test_split( + test_size=self.eval_size, + stratify_by_column=self.stratify_splits_col, + seed=42, + ) + train_data = data_dict["train"] + eval_data = data_dict["test"] + else: + # 5-fold cross-validate + num_cells = len(data) + fifth_cells = int(np.floor(num_cells * 0.2)) + num_eval = min((self.eval_size * num_cells), fifth_cells) + start = i * fifth_cells + end = start + num_eval + eval_indices = [j for j in range(start, end)] + train_indices = [ + j for j in range(num_cells) if j not in eval_indices + ] + eval_data = data.select(eval_indices) + train_data = data.select(train_indices) + if n_hyperopt_trials == 0: + trainer = self.train_classifier( + model_directory, + num_classes, + train_data, + eval_data, + ksplit_output_dir, + predict_trainer, + ) + else: + trainer = self.hyperopt_classifier( + model_directory, + num_classes, + train_data, + eval_data, + ksplit_output_dir, + n_trials=n_hyperopt_trials, + ) + if iteration_num == self.num_crossval_splits: + return + else: + iteration_num = iteration_num + 1 + continue + + result = self.evaluate_model( + trainer.model, + num_classes, + id_class_dict, + eval_data, + predict_eval, + ksplit_output_dir, + output_prefix, + ) + results += [result] + all_conf_mat = all_conf_mat + result["conf_mat"] + iteration_num = iteration_num + 1 + + elif self.classifier == "gene": + # set up (cross-)validation splits + targets = pu.flatten_list(self.gene_class_dict.values()) + labels = pu.flatten_list( + [ + [class_id_dict[label]] * len(targets) + for label, targets in self.gene_class_dict.items() + ] + ) + assert len(targets) == len(labels) + n_splits = int(1 / (1 - self.train_size)) + skf = cu.StratifiedKFold3(n_splits=n_splits, random_state=0, shuffle=True) + # (Cross-)validate + test_ratio = self.oos_test_size / (self.eval_size + self.oos_test_size) + for train_index, eval_index, test_index in tqdm( + skf.split(targets, labels, test_ratio) + ): + print( + f"****** Validation split: {iteration_num}/{self.num_crossval_splits} ******\n" + ) + ksplit_output_dir = os.path.join(output_dir, f"ksplit{iteration_num}") + # filter data for examples containing classes for this split + # subsample to max_ncells and relabel data in column "labels" + train_data, eval_data = cu.prep_gene_classifier_train_eval_split( + data, + targets, + labels, + train_index, + eval_index, + self.max_ncells, + iteration_num, + self.nproc, + gene_balance, + ) + + if save_gene_split_datasets is True: + for split_name in ["train", "valid"]: + labeled_dataset_output_path = ( + Path(output_dir) + / f"{output_prefix}_{split_name}_gene_labeled_ksplit{iteration_num}" + ).with_suffix(".dataset") + if split_name == "train": + train_data.save_to_disk(str(labeled_dataset_output_path)) + elif split_name == "valid": + eval_data.save_to_disk(str(labeled_dataset_output_path)) + + if self.oos_test_size > 0: + test_data = cu.prep_gene_classifier_split( + data, + targets, + labels, + test_index, + "test", + self.max_ncells, + iteration_num, + self.nproc, + ) + if save_gene_split_datasets is True: + test_labeled_dataset_output_path = ( + Path(output_dir) + / f"{output_prefix}_test_gene_labeled_ksplit{iteration_num}" + ).with_suffix(".dataset") + test_data.save_to_disk(str(test_labeled_dataset_output_path)) + if debug_gene_split_datasets is True: + logger.error( + "Exiting after saving gene split datasets given debug_gene_split_datasets = True." + ) + raise + if n_hyperopt_trials == 0: + trainer = self.train_classifier( + model_directory, + num_classes, + train_data, + eval_data, + ksplit_output_dir, + predict_trainer, + ) + result = self.evaluate_model( + trainer.model, + num_classes, + id_class_dict, + eval_data, + predict_eval, + ksplit_output_dir, + output_prefix, + ) + else: + trainer = self.hyperopt_classifier( + model_directory, + num_classes, + train_data, + eval_data, + ksplit_output_dir, + n_trials=n_hyperopt_trials, + ) + + model = cu.load_best_model( + ksplit_output_dir, self.model_type, num_classes + ) + + if self.oos_test_size > 0: + result = self.evaluate_model( + model, + num_classes, + id_class_dict, + test_data, + predict_eval, + ksplit_output_dir, + output_prefix, + ) + else: + if iteration_num == self.num_crossval_splits: + return + else: + iteration_num = iteration_num + 1 + continue + results += [result] + all_conf_mat = all_conf_mat + result["conf_mat"] + # break after 1 or 5 splits, each with train/eval proportions dictated by eval_size + if iteration_num == self.num_crossval_splits: + break + iteration_num = iteration_num + 1 + + all_conf_mat_df = pd.DataFrame( + all_conf_mat, columns=id_class_dict.values(), index=id_class_dict.values() + ) + all_metrics = { + "conf_matrix": all_conf_mat_df, + "macro_f1": [result["macro_f1"] for result in results], + "acc": [result["acc"] for result in results], + } + all_roc_metrics = None # roc metrics not reported for multiclass + if num_classes == 2: + mean_fpr = np.linspace(0, 1, 100) + all_tpr = [result["roc_metrics"]["interp_tpr"] for result in results] + all_roc_auc = [result["roc_metrics"]["auc"] for result in results] + all_tpr_wt = [result["roc_metrics"]["tpr_wt"] for result in results] + mean_tpr, roc_auc, roc_auc_sd = eu.get_cross_valid_roc_metrics( + all_tpr, all_roc_auc, all_tpr_wt + ) + all_roc_metrics = { + "mean_tpr": mean_tpr, + "mean_fpr": mean_fpr, + "all_roc_auc": all_roc_auc, + "roc_auc": roc_auc, + "roc_auc_sd": roc_auc_sd, + } + all_metrics["all_roc_metrics"] = all_roc_metrics + if save_eval_output is True: + eval_metrics_output_path = ( + Path(output_dir) / f"{output_prefix}_eval_metrics_dict" + ).with_suffix(".pkl") + with open(eval_metrics_output_path, "wb") as f: + pickle.dump(all_metrics, f) + + return all_metrics + + def hyperopt_classifier( + self, + model_directory, + num_classes, + train_data, + eval_data, + output_directory, + n_trials=100, + ): + """ + Fine-tune model for cell state or gene classification. + + **Parameters** + + model_directory : Path + | Path to directory containing model + num_classes : int + | Number of classes for classifier + train_data : Dataset + | Loaded training .dataset input + | For cell classifier, labels in column "label". + | For gene classifier, labels in column "labels". + eval_data : None, Dataset + | (Optional) Loaded evaluation .dataset input + | For cell classifier, labels in column "label". + | For gene classifier, labels in column "labels". + output_directory : Path + | Path to directory where fine-tuned model will be saved + n_trials : int + | Number of trials to run for hyperparameter optimization + """ + + # initiate runtime environment for raytune + import ray + from ray import tune + from ray.tune.search.hyperopt import HyperOptSearch + + ray.shutdown() # engage new ray session + ray.init() + + ##### Validate and prepare data ##### + train_data, eval_data = cu.validate_and_clean_cols( + train_data, eval_data, self.classifier + ) + + if (self.no_eval is True) and (eval_data is not None): + logger.warning( + "no_eval set to True; hyperparameter optimization requires eval, proceeding with eval" + ) + + # ensure not overwriting previously saved model + saved_model_test = os.path.join(output_directory, "pytorch_model.bin") + if os.path.isfile(saved_model_test) is True: + logger.error("Model already saved to this designated output directory.") + raise + # make output directory + subprocess.call(f"mkdir {output_directory}", shell=True) + + ##### Load model and training args ##### + model = pu.load_model( + self.model_type, + num_classes, + model_directory, + "train", + quantize=self.quantize, + ) + def_training_args, def_freeze_layers = cu.get_default_train_args( + model, self.classifier, train_data, output_directory + ) + del model + + if self.training_args is not None: + def_training_args.update(self.training_args) + logging_steps = round( + len(train_data) / def_training_args["per_device_train_batch_size"] / 10 + ) + def_training_args["logging_steps"] = logging_steps + def_training_args["output_dir"] = output_directory + if eval_data is None: + def_training_args["evaluation_strategy"] = "no" + def_training_args["load_best_model_at_end"] = False + def_training_args.update( + {"save_strategy": "epoch", "save_total_limit": 1} + ) # only save last model for each run + training_args_init = TrainingArguments(**def_training_args) + + ##### Fine-tune the model ##### + # define the data collator + if self.classifier == "cell": + data_collator = DataCollatorForCellClassification( + token_dictionary=self.gene_token_dict + ) + elif self.classifier == "gene": + data_collator = DataCollatorForGeneClassification( + token_dictionary=self.gene_token_dict + ) + + # define function to initiate model + def model_init(): + model = pu.load_model( + self.model_type, + num_classes, + model_directory, + "train", + quantize=self.quantize, + ) + + if self.freeze_layers is not None: + def_freeze_layers = self.freeze_layers + + if def_freeze_layers > 0: + modules_to_freeze = model.bert.encoder.layer[:def_freeze_layers] + for module in modules_to_freeze: + for param in module.parameters(): + param.requires_grad = False + + if self.quantize is False: + model = model.to("cuda:0") + return model + + # create the trainer + trainer = Trainer( + model_init=model_init, + args=training_args_init, + data_collator=data_collator, + train_dataset=train_data, + eval_dataset=eval_data, + compute_metrics=cu.compute_metrics, + ) + + # specify raytune hyperparameter search space + if self.ray_config is None: + logger.warning( + "No ray_config provided. Proceeding with default, but ranges may need adjustment depending on model." + ) + def_ray_config = { + "num_train_epochs": tune.choice([1]), + "learning_rate": tune.loguniform(1e-6, 1e-3), + "weight_decay": tune.uniform(0.0, 0.3), + "lr_scheduler_type": tune.choice(["linear", "cosine", "polynomial"]), + "warmup_steps": tune.uniform(100, 2000), + "seed": tune.uniform(0, 100), + "per_device_train_batch_size": tune.choice( + [def_training_args["per_device_train_batch_size"]] + ), + } + + hyperopt_search = HyperOptSearch(metric="eval_macro_f1", mode="max") + + # optimize hyperparameters + trainer.hyperparameter_search( + direction="maximize", + backend="ray", + resources_per_trial={"cpu": int(self.nproc / self.ngpu), "gpu": 1}, + hp_space=lambda _: def_ray_config + if self.ray_config is None + else self.ray_config, + search_alg=hyperopt_search, + n_trials=n_trials, # number of trials + progress_reporter=tune.CLIReporter( + max_report_frequency=600, + sort_by_metric=True, + max_progress_rows=n_trials, + mode="max", + metric="eval_macro_f1", + metric_columns=["loss", "eval_loss", "eval_accuracy", "eval_macro_f1"], + ), + storage_path=output_directory, + ) + + return trainer + + def train_classifier( + self, + model_directory, + num_classes, + train_data, + eval_data, + output_directory, + predict=False, + ): + """ + Fine-tune model for cell state or gene classification. + + **Parameters** + + model_directory : Path + | Path to directory containing model + num_classes : int + | Number of classes for classifier + train_data : Dataset + | Loaded training .dataset input + | For cell classifier, labels in column "label". + | For gene classifier, labels in column "labels". + eval_data : None, Dataset + | (Optional) Loaded evaluation .dataset input + | For cell classifier, labels in column "label". + | For gene classifier, labels in column "labels". + output_directory : Path + | Path to directory where fine-tuned model will be saved + predict : bool + | Whether or not to save eval predictions from trainer + """ + + ##### Validate and prepare data ##### + train_data, eval_data = cu.validate_and_clean_cols( + train_data, eval_data, self.classifier + ) + + if (self.no_eval is True) and (eval_data is not None): + logger.warning( + "no_eval set to True; model will be trained without evaluation." + ) + eval_data = None + + if (self.classifier == "gene") and (predict is True): + logger.warning( + "Predictions during training not currently available for gene classifiers; setting predict to False." + ) + predict = False + + # ensure not overwriting previously saved model + saved_model_test = os.path.join(output_directory, "pytorch_model.bin") + if os.path.isfile(saved_model_test) is True: + logger.error("Model already saved to this designated output directory.") + raise + # make output directory + subprocess.call(f"mkdir {output_directory}", shell=True) + + ##### Load model and training args ##### + model = pu.load_model( + self.model_type, + num_classes, + model_directory, + "train", + quantize=self.quantize, + ) + + def_training_args, def_freeze_layers = cu.get_default_train_args( + model, self.classifier, train_data, output_directory + ) + + if self.training_args is not None: + def_training_args.update(self.training_args) + logging_steps = round( + len(train_data) / def_training_args["per_device_train_batch_size"] / 10 + ) + def_training_args["logging_steps"] = logging_steps + def_training_args["output_dir"] = output_directory + if eval_data is None: + def_training_args["evaluation_strategy"] = "no" + def_training_args["load_best_model_at_end"] = False + training_args_init = TrainingArguments(**def_training_args) + + if self.freeze_layers is not None: + def_freeze_layers = self.freeze_layers + + if def_freeze_layers > 0: + modules_to_freeze = model.bert.encoder.layer[:def_freeze_layers] + for module in modules_to_freeze: + for param in module.parameters(): + param.requires_grad = False + + ##### Fine-tune the model ##### + # define the data collator + if self.classifier == "cell": + data_collator = DataCollatorForCellClassification( + token_dictionary=self.gene_token_dict + ) + elif self.classifier == "gene": + data_collator = DataCollatorForGeneClassification( + token_dictionary=self.gene_token_dict + ) + + # create the trainer + trainer = Trainer( + model=model, + args=training_args_init, + data_collator=data_collator, + train_dataset=train_data, + eval_dataset=eval_data, + compute_metrics=cu.compute_metrics, + ) + + # train the classifier + trainer.train() + trainer.save_model(output_directory) + if predict is True: + # make eval predictions and save predictions and metrics + predictions = trainer.predict(eval_data) + prediction_output_path = f"{output_directory}/predictions.pkl" + with open(prediction_output_path, "wb") as f: + pickle.dump(predictions, f) + trainer.save_metrics("eval", predictions.metrics) + return trainer + + def evaluate_model( + self, + model, + num_classes, + id_class_dict, + eval_data, + predict=False, + output_directory=None, + output_prefix=None, + ): + """ + Evaluate the fine-tuned model. + + **Parameters** + + model : nn.Module + | Loaded fine-tuned model (e.g. trainer.model) + num_classes : int + | Number of classes for classifier + id_class_dict : dict + | Loaded _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + eval_data : Dataset + | Loaded evaluation .dataset input + predict : bool + | Whether or not to save eval predictions + output_directory : Path + | Path to directory where eval data will be saved + output_prefix : str + | Prefix for output files + """ + + ##### Evaluate the model ##### + labels = id_class_dict.keys() + y_pred, y_true, logits_list = eu.classifier_predict( + model, self.classifier, eval_data, self.forward_batch_size + ) + conf_mat, macro_f1, acc, roc_metrics = eu.get_metrics( + y_pred, y_true, logits_list, num_classes, labels + ) + if predict is True: + pred_dict = { + "pred_ids": y_pred, + "label_ids": y_true, + "predictions": logits_list, + } + pred_dict_output_path = ( + Path(output_directory) / f"{output_prefix}_pred_dict" + ).with_suffix(".pkl") + with open(pred_dict_output_path, "wb") as f: + pickle.dump(pred_dict, f) + return { + "conf_mat": conf_mat, + "macro_f1": macro_f1, + "acc": acc, + "roc_metrics": roc_metrics, + } + + def evaluate_saved_model( + self, + model_directory, + id_class_dict_file, + test_data_file, + output_directory, + output_prefix, + predict=True, + ): + """ + Evaluate the fine-tuned model. + + **Parameters** + + model_directory : Path + | Path to directory containing model + id_class_dict_file : Path + | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + test_data_file : Path + | Path to directory containing test .dataset + output_directory : Path + | Path to directory where eval data will be saved + output_prefix : str + | Prefix for output files + predict : bool + | Whether or not to save eval predictions + """ + + # load numerical id to class dictionary (id:class) + with open(id_class_dict_file, "rb") as f: + id_class_dict = pickle.load(f) + + # get number of classes for classifier + num_classes = cu.get_num_classes(id_class_dict) + + # load previously filtered and prepared data + test_data = pu.load_and_filter(None, self.nproc, test_data_file) + + # load previously fine-tuned model + model = pu.load_model( + self.model_type, + num_classes, + model_directory, + "eval", + quantize=self.quantize, + ) + + # evaluate the model + result = self.evaluate_model( + model, + num_classes, + id_class_dict, + test_data, + predict=predict, + output_directory=output_directory, + output_prefix=output_prefix, + ) + + all_conf_mat_df = pd.DataFrame( + result["conf_mat"], + columns=id_class_dict.values(), + index=id_class_dict.values(), + ) + all_metrics = { + "conf_matrix": all_conf_mat_df, + "macro_f1": result["macro_f1"], + "acc": result["acc"], + } + all_roc_metrics = None # roc metrics not reported for multiclass + + if num_classes == 2: + mean_fpr = np.linspace(0, 1, 100) + mean_tpr = result["roc_metrics"]["interp_tpr"] + all_roc_auc = result["roc_metrics"]["auc"] + all_roc_metrics = { + "mean_tpr": mean_tpr, + "mean_fpr": mean_fpr, + "all_roc_auc": all_roc_auc, + } + all_metrics["all_roc_metrics"] = all_roc_metrics + test_metrics_output_path = ( + Path(output_directory) / f"{output_prefix}_test_metrics_dict" + ).with_suffix(".pkl") + with open(test_metrics_output_path, "wb") as f: + pickle.dump(all_metrics, f) + + return all_metrics + + def plot_conf_mat( + self, + conf_mat_dict, + output_directory, + output_prefix, + custom_class_order=None, + ): + """ + Plot confusion matrix results of evaluating the fine-tuned model. + + **Parameters** + + conf_mat_dict : dict + | Dictionary of model_name : confusion_matrix_DataFrame + | (all_metrics["conf_matrix"] from self.validate) + output_directory : Path + | Path to directory where plots will be saved + output_prefix : str + | Prefix for output file + custom_class_order : None, list + | List of classes in custom order for plots. + | Same order will be used for all models. + """ + + for model_name in conf_mat_dict.keys(): + eu.plot_confusion_matrix( + conf_mat_dict[model_name], + model_name, + output_directory, + output_prefix, + custom_class_order, + ) + + def plot_roc( + self, + roc_metric_dict, + model_style_dict, + title, + output_directory, + output_prefix, + ): + """ + Plot ROC curve results of evaluating the fine-tuned model. + + **Parameters** + + roc_metric_dict : dict + | Dictionary of model_name : roc_metrics + | (all_metrics["all_roc_metrics"] from self.validate) + model_style_dict : dict[dict] + | Dictionary of model_name : dictionary of style_attribute : style + | where style includes color and linestyle + | e.g. {'Model_A': {'color': 'black', 'linestyle': '-'}, 'Model_B': ...} + title : str + | Title of plot (e.g. 'Dosage-sensitive vs -insensitive factors') + output_directory : Path + | Path to directory where plots will be saved + output_prefix : str + | Prefix for output file + """ + + eu.plot_ROC( + roc_metric_dict, model_style_dict, title, output_directory, output_prefix + ) + + def plot_predictions( + self, + predictions_file, + id_class_dict_file, + title, + output_directory, + output_prefix, + custom_class_order=None, + kwargs_dict=None, + ): + """ + Plot prediction results of evaluating the fine-tuned model. + + **Parameters** + + predictions_file : path + | Path of model predictions output to plot + | (saved output from self.validate if predict_eval=True) + | (or saved output from self.evaluate_saved_model) + id_class_dict_file : Path + | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + title : str + | Title for legend containing class labels. + output_directory : Path + | Path to directory where plots will be saved + output_prefix : str + | Prefix for output file + custom_class_order : None, list + | List of classes in custom order for plots. + | Same order will be used for all models. + kwargs_dict : None, dict + | Dictionary of kwargs to pass to plotting function. + """ + # load predictions + with open(predictions_file, "rb") as f: + predictions = pickle.load(f) + + # load numerical id to class dictionary (id:class) + with open(id_class_dict_file, "rb") as f: + id_class_dict = pickle.load(f) + + if isinstance(predictions, dict): + if all( + [ + key in predictions.keys() + for key in ["pred_ids", "label_ids", "predictions"] + ] + ): + # format is output from self.evaluate_saved_model + predictions_logits = np.array(predictions["predictions"]) + true_ids = predictions["label_ids"] + else: + # format is output from self.validate if predict_eval=True + predictions_logits = predictions.predictions + true_ids = predictions.label_ids + + num_classes = len(id_class_dict.keys()) + num_predict_classes = predictions_logits.shape[1] + assert num_classes == num_predict_classes + classes = id_class_dict.values() + true_labels = [id_class_dict[idx] for idx in true_ids] + predictions_df = pd.DataFrame(predictions_logits, columns=classes) + if custom_class_order is not None: + predictions_df = predictions_df.reindex(columns=custom_class_order) + predictions_df["true"] = true_labels + custom_dict = dict(zip(classes, [i for i in range(len(classes))])) + if custom_class_order is not None: + custom_dict = dict( + zip(custom_class_order, [i for i in range(len(custom_class_order))]) + ) + predictions_df = predictions_df.sort_values( + by=["true"], key=lambda x: x.map(custom_dict) + ) + + eu.plot_predictions( + predictions_df, title, output_directory, output_prefix, kwargs_dict + ) diff --git a/geneformer/classifier_utils.py b/geneformer/classifier_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d2da349a731bbeb4dc023b48a6bd283c7381e236 --- /dev/null +++ b/geneformer/classifier_utils.py @@ -0,0 +1,648 @@ +import json +import logging +import os +import random +from collections import Counter, defaultdict + +import numpy as np +import pandas as pd +from scipy.stats import chisquare, ranksums +from sklearn.metrics import accuracy_score, f1_score +from sklearn.model_selection import StratifiedKFold, train_test_split + +from . import perturber_utils as pu + +logger = logging.getLogger(__name__) + + +def downsample_and_shuffle(data, max_ncells, max_ncells_per_class, cell_state_dict): + data = data.shuffle(seed=42) + num_cells = len(data) + # if max number of cells is defined, then subsample to this max number + if max_ncells is not None: + if num_cells > max_ncells: + data = data.select([i for i in range(max_ncells)]) + if max_ncells_per_class is not None: + class_labels = data[cell_state_dict["state_key"]] + random.seed(42) + subsample_indices = subsample_by_class(class_labels, max_ncells_per_class) + data = data.select(subsample_indices) + return data + + +# subsample labels to maximum number N per class and return indices +def subsample_by_class(labels, N): + label_indices = defaultdict(list) + # Gather indices for each label + for idx, label in enumerate(labels): + label_indices[label].append(idx) + selected_indices = [] + # Select up to N indices for each label + for label, indices in label_indices.items(): + if len(indices) > N: + selected_indices.extend(random.sample(indices, N)) + else: + selected_indices.extend(indices) + return selected_indices + + +def rename_cols(data, state_key): + data = data.rename_column(state_key, "label") + return data + + +def validate_and_clean_cols(train_data, eval_data, classifier): + # validate that data has expected label column and remove others + if classifier == "cell": + label_col = "label" + elif classifier == "gene": + label_col = "labels" + + cols_to_keep = [label_col] + ["input_ids", "length"] + if label_col not in train_data.column_names: + logger.error(f"train_data must contain column {label_col} with class labels.") + raise + else: + train_data = remove_cols(train_data, cols_to_keep) + + if eval_data is not None: + if label_col not in eval_data.column_names: + logger.error( + f"eval_data must contain column {label_col} with class labels." + ) + raise + else: + eval_data = remove_cols(eval_data, cols_to_keep) + return train_data, eval_data + + +def remove_cols(data, cols_to_keep): + other_cols = list(data.features.keys()) + other_cols = [ele for ele in other_cols if ele not in cols_to_keep] + data = data.remove_columns(other_cols) + return data + + +def remove_rare(data, rare_threshold, label, nproc): + if rare_threshold > 0: + total_cells = len(data) + label_counter = Counter(data[label]) + nonrare_label_dict = { + label: [k for k, v in label_counter if (v / total_cells) > rare_threshold] + } + data = pu.filter_by_dict(data, nonrare_label_dict, nproc) + return data + + +def label_classes(classifier, data, gene_class_dict, nproc): + if classifier == "cell": + label_set = set(data["label"]) + elif classifier == "gene": + # remove cells without any of the target genes + def if_contains_label(example): + a = pu.flatten_list(gene_class_dict.values()) + b = example["input_ids"] + return not set(a).isdisjoint(b) + + data = data.filter(if_contains_label, num_proc=nproc) + label_set = gene_class_dict.keys() + + if len(data) == 0: + logger.error( + "No cells remain after filtering for target genes. Check target gene list." + ) + raise + + class_id_dict = dict(zip(label_set, [i for i in range(len(label_set))])) + id_class_dict = {v: k for k, v in class_id_dict.items()} + + def classes_to_ids(example): + if classifier == "cell": + example["label"] = class_id_dict[example["label"]] + elif classifier == "gene": + example["labels"] = label_gene_classes( + example, class_id_dict, gene_class_dict + ) + return example + + data = data.map(classes_to_ids, num_proc=nproc) + return data, id_class_dict + + +def label_gene_classes(example, class_id_dict, gene_class_dict): + return [ + class_id_dict.get(gene_class_dict.get(token_id, -100), -100) + for token_id in example["input_ids"] + ] + + +def prep_gene_classifier_train_eval_split( + data, + targets, + labels, + train_index, + eval_index, + max_ncells, + iteration_num, + num_proc, + balance=False, +): + # generate cross-validation splits + train_data = prep_gene_classifier_split( + data, + targets, + labels, + train_index, + "train", + max_ncells, + iteration_num, + num_proc, + balance, + ) + eval_data = prep_gene_classifier_split( + data, + targets, + labels, + eval_index, + "eval", + max_ncells, + iteration_num, + num_proc, + balance, + ) + return train_data, eval_data + + +def prep_gene_classifier_split( + data, + targets, + labels, + index, + subset_name, + max_ncells, + iteration_num, + num_proc, + balance=False, +): + # generate cross-validation splits + targets = np.array(targets) + labels = np.array(labels) + targets_subset = targets[index] + labels_subset = labels[index] + label_dict_subset = dict(zip(targets_subset, labels_subset)) + + # function to filter by whether contains train or eval labels + def if_contains_subset_label(example): + a = targets_subset + b = example["input_ids"] + return not set(a).isdisjoint(b) + + # filter dataset for examples containing classes for this split + logger.info(f"Filtering data for {subset_name} genes in split {iteration_num}") + subset_data = data.filter(if_contains_subset_label, num_proc=num_proc) + logger.info( + f"Filtered {round((1-len(subset_data)/len(data))*100)}%; {len(subset_data)} remain\n" + ) + + # balance gene subsets if train + if (subset_name == "train") and (balance is True): + subset_data, label_dict_subset = balance_gene_split( + subset_data, label_dict_subset, num_proc + ) + + # subsample to max_ncells + subset_data = downsample_and_shuffle(subset_data, max_ncells, None, None) + + # relabel genes for this split + def subset_classes_to_ids(example): + example["labels"] = [ + label_dict_subset.get(token_id, -100) for token_id in example["input_ids"] + ] + return example + + subset_data = subset_data.map(subset_classes_to_ids, num_proc=num_proc) + + return subset_data + + +def prep_gene_classifier_all_data( + data, targets, labels, max_ncells, num_proc, balance=False +): + targets = np.array(targets) + labels = np.array(labels) + label_dict_train = dict(zip(targets, labels)) + + # function to filter by whether contains train labels + def if_contains_train_label(example): + a = targets + b = example["input_ids"] + return not set(a).isdisjoint(b) + + # filter dataset for examples containing classes for this split + logger.info("Filtering training data for genes to classify.") + train_data = data.filter(if_contains_train_label, num_proc=num_proc) + logger.info( + f"Filtered {round((1-len(train_data)/len(data))*100)}%; {len(train_data)} remain\n" + ) + + if balance is True: + train_data, label_dict_train = balance_gene_split( + train_data, label_dict_train, num_proc + ) + + # subsample to max_ncells + train_data = downsample_and_shuffle(train_data, max_ncells, None, None) + + # relabel genes for this split + def train_classes_to_ids(example): + example["labels"] = [ + label_dict_train.get(token_id, -100) for token_id in example["input_ids"] + ] + return example + + train_data = train_data.map(train_classes_to_ids, num_proc=num_proc) + + return train_data + + +def balance_gene_split(subset_data, label_dict_subset, num_proc): + # count occurrence of genes in each label category + label0_counts, label1_counts = count_genes_for_balancing( + subset_data, label_dict_subset, num_proc + ) + label_ratio_0to1 = label0_counts / label1_counts + + if 8 / 10 <= label_ratio_0to1 <= 10 / 8: + # gene sets already balanced + logger.info( + "Gene sets were already balanced within 0.8-1.25 fold and did not require balancing.\n" + ) + return subset_data, label_dict_subset + else: + label_ratio_0to1_orig = label_ratio_0to1 + 0 + label_dict_subset_orig = label_dict_subset.copy() + # balance gene sets + max_ntrials = 25 + boost = 1 + if label_ratio_0to1 > 10 / 8: + # downsample label 0 + for i in range(max_ntrials): + label0 = 0 + label0_genes = [k for k, v in label_dict_subset.items() if v == label0] + label0_ngenes = len(label0_genes) + label0_nremove = max( + 1, + int( + np.floor( + label0_ngenes - label0_ngenes / (label_ratio_0to1 * boost) + ) + ), + ) + random.seed(i) + label0_remove_genes = random.sample(label0_genes, label0_nremove) + label_dict_subset_new = { + k: v + for k, v in label_dict_subset.items() + if k not in label0_remove_genes + } + label0_counts, label1_counts = count_genes_for_balancing( + subset_data, label_dict_subset_new, num_proc + ) + label_ratio_0to1 = label0_counts / label1_counts + if 8 / 10 <= label_ratio_0to1 <= 10 / 8: + # if gene sets now balanced, return new filtered data and new label_dict_subset + return filter_data_balanced_genes( + subset_data, label_dict_subset_new, num_proc + ) + elif label_ratio_0to1 > 10 / 8: + boost = boost * 1.1 + elif label_ratio_0to1 < 8 / 10: + boost = boost * 0.9 + else: + # downsample label 1 + for i in range(max_ntrials): + label1 = 1 + label1_genes = [k for k, v in label_dict_subset.items() if v == label1] + label1_ngenes = len(label1_genes) + label1_nremove = max( + 1, + int( + np.floor( + label1_ngenes + - label1_ngenes / ((1 / label_ratio_0to1) * boost) + ) + ), + ) + random.seed(i) + label1_remove_genes = random.sample(label1_genes, label1_nremove) + label_dict_subset_new = { + k: v + for k, v in label_dict_subset.items() + if k not in label1_remove_genes + } + label0_counts, label1_counts = count_genes_for_balancing( + subset_data, label_dict_subset_new, num_proc + ) + label_ratio_0to1 = label0_counts / label1_counts + if 8 / 10 <= label_ratio_0to1 <= 10 / 8: + # if gene sets now balanced, return new filtered data and new label_dict_subset + return filter_data_balanced_genes( + subset_data, label_dict_subset_new, num_proc + ) + elif label_ratio_0to1 < 8 / 10: + boost = boost * 1.1 + elif label_ratio_0to1 > 10 / 8: + boost = boost * 0.9 + + assert i + 1 == max_ntrials + if (label_ratio_0to1 <= label_ratio_0to1_orig < 8 / 10) or ( + 10 / 8 > label_ratio_0to1_orig >= label_ratio_0to1 + ): + label_ratio_0to1 = label_ratio_0to1_orig + label_dict_subset_new = label_dict_subset_orig + logger.warning( + f"Gene sets were not able to be balanced within 0.8-1.25 fold after {max_ntrials} trials. Imbalance level: {label_ratio_0to1}\n" + ) + return filter_data_balanced_genes(subset_data, label_dict_subset_new, num_proc) + + +def count_genes_for_balancing(subset_data, label_dict_subset, num_proc): + def count_targets(example): + labels = [ + label_dict_subset.get(token_id, -100) for token_id in example["input_ids"] + ] + counter_labels = Counter(labels) + # get count of labels 0 or 1, or if absent, return 0 + example["labels_counts"] = [counter_labels.get(0, 0), counter_labels.get(1, 0)] + return example + + subset_data = subset_data.map(count_targets, num_proc=num_proc) + + label0_counts = sum([counts[0] for counts in subset_data["labels_counts"]]) + label1_counts = sum([counts[1] for counts in subset_data["labels_counts"]]) + + subset_data = subset_data.remove_columns("labels_counts") + + return label0_counts, label1_counts + + +def filter_data_balanced_genes(subset_data, label_dict_subset, num_proc): + # function to filter by whether contains labels + def if_contains_subset_label(example): + a = list(label_dict_subset.keys()) + b = example["input_ids"] + return not set(a).isdisjoint(b) + + # filter dataset for examples containing classes for this split + logger.info("Filtering data for balanced genes") + subset_data_len_orig = len(subset_data) + subset_data = subset_data.filter(if_contains_subset_label, num_proc=num_proc) + logger.info( + f"Filtered {round((1-len(subset_data)/subset_data_len_orig)*100)}%; {len(subset_data)} remain\n" + ) + + return subset_data, label_dict_subset + + +def balance_attr_splits( + data, + attr_to_split, + attr_to_balance, + eval_size, + max_trials, + pval_threshold, + state_key, + nproc, +): + metadata_df = pd.DataFrame({"split_attr_ids": data[attr_to_split]}) + for attr in attr_to_balance: + if attr == state_key: + metadata_df[attr] = data["label"] + else: + metadata_df[attr] = data[attr] + metadata_df = metadata_df.drop_duplicates() + + split_attr_ids = list(metadata_df["split_attr_ids"]) + assert len(split_attr_ids) == len(set(split_attr_ids)) + eval_num = round(len(split_attr_ids) * eval_size) + colnames = ( + ["trial_num", "train_ids", "eval_ids"] + + pu.flatten_list( + [ + [ + f"{attr}_train_mean_or_counts", + f"{attr}_eval_mean_or_counts", + f"{attr}_pval", + ] + for attr in attr_to_balance + ] + ) + + ["mean_pval"] + ) + balance_df = pd.DataFrame(columns=colnames) + data_dict = dict() + trial_num = 1 + for i in range(max_trials): + if not all( + count > 1 for count in list(Counter(metadata_df[state_key]).values()) + ): + logger.error( + f"Cannot balance by {attr_to_split} while retaining at least 1 occurrence of each {state_key} class in both data splits. " + ) + raise + eval_base = [] + for state in set(metadata_df[state_key]): + eval_base += list( + metadata_df.loc[ + metadata_df[state_key][metadata_df[state_key].eq(state)] + .sample(1, random_state=i) + .index + ]["split_attr_ids"] + ) + non_eval_base = [idx for idx in split_attr_ids if idx not in eval_base] + random.seed(i) + eval_ids = random.sample(non_eval_base, eval_num - len(eval_base)) + eval_base + train_ids = [idx for idx in split_attr_ids if idx not in eval_ids] + df_vals = [trial_num, train_ids, eval_ids] + pvals = [] + for attr in attr_to_balance: + train_attr = list( + metadata_df[metadata_df["split_attr_ids"].isin(train_ids)][attr] + ) + eval_attr = list( + metadata_df[metadata_df["split_attr_ids"].isin(eval_ids)][attr] + ) + if attr == state_key: + # ensure IDs are interpreted as categorical + train_attr = [str(item) for item in train_attr] + eval_attr = [str(item) for item in eval_attr] + if all(isinstance(item, (int, float)) for item in train_attr + eval_attr): + train_attr_mean = np.nanmean(train_attr) + eval_attr_mean = np.nanmean(eval_attr) + pval = ranksums(train_attr, eval_attr, nan_policy="omit").pvalue + df_vals += [train_attr_mean, eval_attr_mean, pval] + elif all(isinstance(item, (str)) for item in train_attr + eval_attr): + obs_counts = Counter(train_attr) + exp_counts = Counter(eval_attr) + all_categ = set(obs_counts.keys()).union(set(exp_counts.keys())) + obs = [obs_counts[cat] for cat in all_categ] + exp = [ + exp_counts[cat] * sum(obs) / sum(exp_counts.values()) + for cat in all_categ + ] + pval = chisquare(f_obs=obs, f_exp=exp).pvalue + train_attr_counts = str(obs_counts).strip("Counter(").strip(")") + eval_attr_counts = str(exp_counts).strip("Counter(").strip(")") + df_vals += [train_attr_counts, eval_attr_counts, pval] + else: + logger.error( + f"Inconsistent data types in attribute {attr}. " + "Cannot infer if continuous or categorical. " + "Must be all numeric (continuous) or all strings (categorical) to balance." + ) + raise + pvals += [pval] + + df_vals += [np.nanmean(pvals)] + balance_df_i = pd.DataFrame(df_vals, index=colnames).T + balance_df = pd.concat([balance_df, balance_df_i], ignore_index=True) + valid_pvals = [ + pval_i + for pval_i in pvals + if isinstance(pval_i, (int, float)) and not np.isnan(pval_i) + ] + if all(i >= pval_threshold for i in valid_pvals): + data_dict["train"] = pu.filter_by_dict( + data, {attr_to_split: balance_df_i["train_ids"][0]}, nproc + ) + data_dict["test"] = pu.filter_by_dict( + data, {attr_to_split: balance_df_i["eval_ids"][0]}, nproc + ) + return data_dict, balance_df + trial_num = trial_num + 1 + balance_max_df = balance_df.iloc[balance_df["mean_pval"].idxmax(), :] + data_dict["train"] = pu.filter_by_dict( + data, {attr_to_split: balance_df_i["train_ids"][0]}, nproc + ) + data_dict["test"] = pu.filter_by_dict( + data, {attr_to_split: balance_df_i["eval_ids"][0]}, nproc + ) + logger.warning( + f"No splits found without significant difference in attr_to_balance among {max_trials} trials. " + f"Selecting optimal split (trial #{balance_max_df['trial_num']}) from completed trials." + ) + return data_dict, balance_df + + +def get_num_classes(id_class_dict): + return len(set(id_class_dict.values())) + + +def compute_metrics(pred): + labels = pred.label_ids + preds = pred.predictions.argmax(-1) + + # calculate accuracy and macro f1 using sklearn's function + if len(labels.shape) == 1: + acc = accuracy_score(labels, preds) + macro_f1 = f1_score(labels, preds, average="macro") + else: + flat_labels = labels.flatten().tolist() + flat_preds = preds.flatten().tolist() + logit_label_paired = [ + item for item in list(zip(flat_preds, flat_labels)) if item[1] != -100 + ] + y_pred = [item[0] for item in logit_label_paired] + y_true = [item[1] for item in logit_label_paired] + + acc = accuracy_score(y_true, y_pred) + macro_f1 = f1_score(y_true, y_pred, average="macro") + + return {"accuracy": acc, "macro_f1": macro_f1} + + +def get_default_train_args(model, classifier, data, output_dir): + num_layers = pu.quant_layers(model) + freeze_layers = 0 + batch_size = 12 + if classifier == "cell": + epochs = 10 + evaluation_strategy = "epoch" + load_best_model_at_end = True + else: + epochs = 1 + evaluation_strategy = "no" + load_best_model_at_end = False + + if num_layers == 6: + default_training_args = { + "learning_rate": 5e-5, + "lr_scheduler_type": "linear", + "warmup_steps": 500, + "per_device_train_batch_size": batch_size, + "per_device_eval_batch_size": batch_size, + } + else: + default_training_args = { + "per_device_train_batch_size": batch_size, + "per_device_eval_batch_size": batch_size, + } + + training_args = { + "num_train_epochs": epochs, + "do_train": True, + "do_eval": True, + "evaluation_strategy": evaluation_strategy, + "logging_steps": np.floor(len(data) / batch_size / 8), # 8 evals per epoch + "save_strategy": "epoch", + "group_by_length": False, + "length_column_name": "length", + "disable_tqdm": False, + "weight_decay": 0.001, + "load_best_model_at_end": load_best_model_at_end, + } + training_args.update(default_training_args) + + return training_args, freeze_layers + + +def load_best_model(directory, model_type, num_classes, mode="eval"): + file_dict = dict() + for subdir, dirs, files in os.walk(directory): + for file in files: + if file.endswith("result.json"): + with open(f"{subdir}/{file}", "rb") as fp: + result_json = json.load(fp) + file_dict[f"{subdir}"] = result_json["eval_macro_f1"] + file_df = pd.DataFrame( + {"dir": file_dict.keys(), "eval_macro_f1": file_dict.values()} + ) + model_superdir = ( + "run-" + + file_df.iloc[file_df["eval_macro_f1"].idxmax()]["dir"] + .split("_objective_")[2] + .split("_")[0] + ) + + for subdir, dirs, files in os.walk(f"{directory}/{model_superdir}"): + for file in files: + if file.endswith("model.safetensors"): + model = pu.load_model(model_type, num_classes, f"{subdir}", mode) + return model + + +class StratifiedKFold3(StratifiedKFold): + def split(self, targets, labels, test_ratio=0.5, groups=None): + s = super().split(targets, labels, groups) + for train_indxs, test_indxs in s: + if test_ratio == 0: + yield train_indxs, test_indxs, None + else: + labels_test = np.array(labels)[test_indxs] + valid_indxs, test_indxs = train_test_split( + test_indxs, + stratify=labels_test, + test_size=test_ratio, + random_state=0, + ) + yield train_indxs, valid_indxs, test_indxs diff --git a/geneformer/collator_for_classification.py b/geneformer/collator_for_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..297fa666dbf0daeaa94e2ca203ace5f98570a30e --- /dev/null +++ b/geneformer/collator_for_classification.py @@ -0,0 +1,667 @@ +""" +Geneformer collator for gene and cell classification. +Huggingface data collator modified to accommodate single-cell transcriptomics data for gene and cell classification. +""" + +import warnings +from enum import Enum +from typing import Dict, List, Optional, Union + +import numpy as np +import torch +from transformers import ( + BatchEncoding, + DataCollatorForTokenClassification, + SpecialTokensMixin, +) +from transformers.utils import is_tf_available, is_torch_available, logging, to_py_obj +from transformers.utils.generic import _is_tensorflow, _is_torch + +EncodedInput = List[int] +logger = logging.get_logger(__name__) +VERY_LARGE_INTEGER = int( + 1e30 +) # This is used to set the max input length for a model with infinite size input +LARGE_INTEGER = int( + 1e20 +) # This is used when we need something big but slightly smaller than VERY_LARGE_INTEGER + +# precollator functions + + +class ExplicitEnum(Enum): + """ + Enum with more explicit error message for missing values. + """ + + @classmethod + def _missing_(cls, value): + raise ValueError( + "%r is not a valid %s, please select one of %s" + % (value, cls.__name__, str(list(cls._value2member_map_.keys()))) + ) + + +class TruncationStrategy(ExplicitEnum): + """ + Possible values for the ``truncation`` argument in :meth:`PreTrainedTokenizerBase.__call__`. Useful for + tab-completion in an IDE. + """ + + ONLY_FIRST = "only_first" + ONLY_SECOND = "only_second" + LONGEST_FIRST = "longest_first" + DO_NOT_TRUNCATE = "do_not_truncate" + + +class PaddingStrategy(ExplicitEnum): + """ + Possible values for the ``padding`` argument in :meth:`PreTrainedTokenizerBase.__call__`. Useful for tab-completion + in an IDE. + """ + + LONGEST = "longest" + MAX_LENGTH = "max_length" + DO_NOT_PAD = "do_not_pad" + + +class TensorType(ExplicitEnum): + """ + Possible values for the ``return_tensors`` argument in :meth:`PreTrainedTokenizerBase.__call__`. Useful for + tab-completion in an IDE. + """ + + PYTORCH = "pt" + TENSORFLOW = "tf" + NUMPY = "np" + JAX = "jax" + + +class PrecollatorForGeneAndCellClassification(SpecialTokensMixin): + def __init__(self, *args, **kwargs) -> None: + super().__init__(mask_token="", pad_token="") + + self.token_dictionary = kwargs.get("token_dictionary") + self.padding_side = "right" + self.model_input_names = ["input_ids"] + self._mask_token_id = self.token_dictionary.get("") + self._pad_token_id = self.token_dictionary.get("") + self._all_special_ids = [ + self.token_dictionary.get(""), + self.token_dictionary.get(""), + ] + + @property + def all_special_ids(self): + return self._all_special_ids + + @property + def mask_token_id(self): + return self._mask_token_id + + @property + def pad_token_id(self): + return self._pad_token_id + + def _get_padding_truncation_strategies( + self, + padding=True, + truncation=False, + max_length=None, + pad_to_multiple_of=None, + verbose=True, + **kwargs, + ): + """ + Find the correct padding/truncation strategy with backward compatibility for old arguments (truncation_strategy + and pad_to_max_length) and behaviors. + """ + old_truncation_strategy = kwargs.pop("truncation_strategy", "do_not_truncate") + old_pad_to_max_length = kwargs.pop("pad_to_max_length", False) + + # Backward compatibility for previous behavior, maybe we should deprecate it: + # If you only set max_length, it activates truncation for max_length + if max_length is not None and padding is False and truncation is False: + if verbose: + if not self.deprecation_warnings.get( + "Truncation-not-explicitly-activated", False + ): + logger.warning( + "Truncation was not explicitly activated but `max_length` is provided a specific value, " + "please use `truncation=True` to explicitly truncate examples to max length. " + "Defaulting to 'longest_first' truncation strategy. " + "If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy " + "more precisely by providing a specific strategy to `truncation`." + ) + self.deprecation_warnings["Truncation-not-explicitly-activated"] = True + truncation = "longest_first" + + # Get padding strategy + if padding is False and old_pad_to_max_length: + if verbose: + warnings.warn( + "The `pad_to_max_length` argument is deprecated and will be removed in a future version, " + "use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or " + "use `padding='max_length'` to pad to a max length. In this case, you can give a specific " + "length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the " + "maximal input size of the model (e.g. 512 for Bert).", + FutureWarning, + ) + if max_length is None: + padding_strategy = PaddingStrategy.LONGEST + else: + padding_strategy = PaddingStrategy.MAX_LENGTH + elif padding is not False: + if padding is True: + padding_strategy = ( + PaddingStrategy.LONGEST + ) # Default to pad to the longest sequence in the batch + elif not isinstance(padding, PaddingStrategy): + padding_strategy = PaddingStrategy(padding) + elif isinstance(padding, PaddingStrategy): + padding_strategy = padding + else: + padding_strategy = PaddingStrategy.DO_NOT_PAD + + # Get truncation strategy + if truncation is False and old_truncation_strategy != "do_not_truncate": + if verbose: + warnings.warn( + "The `truncation_strategy` argument is deprecated and will be removed in a future version, " + "use `truncation=True` to truncate examples to a max length. You can give a specific " + "length with `max_length` (e.g. `max_length=45`) or leave max_length to None to truncate to the " + "maximal input size of the model (e.g. 512 for Bert). " + " If you have pairs of inputs, you can give a specific truncation strategy selected among " + "`truncation='only_first'` (will only truncate the first sentence in the pairs) " + "`truncation='only_second'` (will only truncate the second sentence in the pairs) " + "or `truncation='longest_first'` (will iteratively remove tokens from the longest sentence in the pairs).", + FutureWarning, + ) + truncation_strategy = TruncationStrategy(old_truncation_strategy) + elif truncation is not False: + if truncation is True: + truncation_strategy = ( + TruncationStrategy.LONGEST_FIRST + ) # Default to truncate the longest sequences in pairs of inputs + elif not isinstance(truncation, TruncationStrategy): + truncation_strategy = TruncationStrategy(truncation) + elif isinstance(truncation, TruncationStrategy): + truncation_strategy = truncation + else: + truncation_strategy = TruncationStrategy.DO_NOT_TRUNCATE + + # Set max length if needed + if max_length is None: + if padding_strategy == PaddingStrategy.MAX_LENGTH: + if self.model_max_length > LARGE_INTEGER: + if verbose: + if not self.deprecation_warnings.get( + "Asking-to-pad-to-max_length", False + ): + logger.warning( + "Asking to pad to max_length but no maximum length is provided and the model has no predefined maximum length. " + "Default to no padding." + ) + self.deprecation_warnings["Asking-to-pad-to-max_length"] = True + padding_strategy = PaddingStrategy.DO_NOT_PAD + else: + max_length = self.model_max_length + + if truncation_strategy != TruncationStrategy.DO_NOT_TRUNCATE: + if self.model_max_length > LARGE_INTEGER: + if verbose: + if not self.deprecation_warnings.get( + "Asking-to-truncate-to-max_length", False + ): + logger.warning( + "Asking to truncate to max_length but no maximum length is provided and the model has no predefined maximum length. " + "Default to no truncation." + ) + self.deprecation_warnings[ + "Asking-to-truncate-to-max_length" + ] = True + truncation_strategy = TruncationStrategy.DO_NOT_TRUNCATE + else: + max_length = self.model_max_length + + # Test if we have a padding token + if padding_strategy != PaddingStrategy.DO_NOT_PAD and ( + not self.pad_token or self.pad_token_id < 0 + ): + raise ValueError( + "Asking to pad but the tokenizer does not have a padding token. " + "Please select a token to use as `pad_token` `(tokenizer.pad_token = tokenizer.eos_token e.g.)` " + "or add a new pad token via `tokenizer.add_special_tokens({'pad_token': '[PAD]'})`." + ) + + # Check that we will truncate to a multiple of pad_to_multiple_of if both are provided + if ( + truncation_strategy != TruncationStrategy.DO_NOT_TRUNCATE + and padding_strategy != PaddingStrategy.DO_NOT_PAD + and pad_to_multiple_of is not None + and max_length is not None + and (max_length % pad_to_multiple_of != 0) + ): + raise ValueError( + f"Truncation and padding are both activated but " + f"truncation length ({max_length}) is not a multiple of pad_to_multiple_of ({pad_to_multiple_of})." + ) + + return padding_strategy, truncation_strategy, max_length, kwargs + + def pad( + self, + encoded_inputs: Union[ + BatchEncoding, + List[BatchEncoding], + Dict[str, EncodedInput], + Dict[str, List[EncodedInput]], + List[Dict[str, EncodedInput]], + ], + class_type, # options: "gene" or "cell" + padding: Union[bool, str, PaddingStrategy] = True, + max_length: Optional[int] = None, + pad_to_multiple_of: Optional[int] = None, + return_attention_mask: Optional[bool] = True, + return_tensors: Optional[Union[str, TensorType]] = None, + verbose: bool = True, + ) -> BatchEncoding: + """ + Pad a single encoded input or a batch of encoded inputs up to predefined length or to the max sequence length + in the batch. + Padding side (left/right) padding token ids are defined at the tokenizer level (with ``self.padding_side``, + ``self.pad_token_id`` and ``self.pad_token_type_id``) + .. note:: + If the ``encoded_inputs`` passed are dictionary of numpy arrays, PyTorch tensors or TensorFlow tensors, the + result will use the same type unless you provide a different tensor type with ``return_tensors``. In the + case of PyTorch tensors, you will lose the specific device of your tensors however. + Args: + encoded_inputs (:class:`~transformers.BatchEncoding`, list of :class:`~transformers.BatchEncoding`, :obj:`Dict[str, List[int]]`, :obj:`Dict[str, List[List[int]]` or :obj:`List[Dict[str, List[int]]]`): + Tokenized inputs. Can represent one input (:class:`~transformers.BatchEncoding` or :obj:`Dict[str, + List[int]]`) or a batch of tokenized inputs (list of :class:`~transformers.BatchEncoding`, `Dict[str, + List[List[int]]]` or `List[Dict[str, List[int]]]`) so you can use this method during preprocessing as + well as in a PyTorch Dataloader collate function. + Instead of :obj:`List[int]` you can have tensors (numpy arrays, PyTorch tensors or TensorFlow tensors), + see the note above for the return type. + padding (:obj:`bool`, :obj:`str` or :class:`~transformers.tokenization_utils_base.PaddingStrategy`, `optional`, defaults to :obj:`True`): + Select a strategy to pad the returned sequences (according to the model's padding side and padding + index) among: + * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a + single sequence if provided). + * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the + maximum acceptable input length for the model if that argument is not provided. + * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of + different lengths). + max_length (:obj:`int`, `optional`): + Maximum length of the returned list and optionally padding length (see above). + pad_to_multiple_of (:obj:`int`, `optional`): + If set will pad the sequence to a multiple of the provided value. + This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability + >= 7.5 (Volta). + return_attention_mask (:obj:`bool`, `optional`): + Whether to return the attention mask. If left to the default, will return the attention mask according + to the specific tokenizer's default, defined by the :obj:`return_outputs` attribute. + `What are attention masks? <../glossary.html#attention-mask>`__ + return_tensors (:obj:`str` or :class:`~transformers.tokenization_utils_base.TensorType`, `optional`): + If set, will return tensors instead of list of python integers. Acceptable values are: + * :obj:`'tf'`: Return TensorFlow :obj:`tf.constant` objects. + * :obj:`'pt'`: Return PyTorch :obj:`torch.Tensor` objects. + * :obj:`'np'`: Return Numpy :obj:`np.ndarray` objects. + verbose (:obj:`bool`, `optional`, defaults to :obj:`True`): + Whether or not to print more information and warnings. + """ + # If we have a list of dicts, let's convert it in a dict of lists + # We do this to allow using this method as a collate_fn function in PyTorch Dataloader + if isinstance(encoded_inputs, (list, tuple)) and isinstance( + encoded_inputs[0], (dict, BatchEncoding) + ): + encoded_inputs = { + key: [example[key] for example in encoded_inputs] + for key in encoded_inputs[0].keys() + } + + # The model's main input name, usually `input_ids`, has be passed for padding + if self.model_input_names[0] not in encoded_inputs: + raise ValueError( + "You should supply an encoding or a list of encodings to this method" + f"that includes {self.model_input_names[0]}, but you provided {list(encoded_inputs.keys())}" + ) + + required_input = encoded_inputs[self.model_input_names[0]] + + if not required_input: + if return_attention_mask: + encoded_inputs["attention_mask"] = [] + return encoded_inputs + + # If we have PyTorch/TF/NumPy tensors/arrays as inputs, we cast them as python objects + # and rebuild them afterwards if no return_tensors is specified + # Note that we lose the specific device the tensor may be on for PyTorch + + first_element = required_input[0] + if isinstance(first_element, (list, tuple)): + # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element. + index = 0 + while len(required_input[index]) == 0: + index += 1 + if index < len(required_input): + first_element = required_input[index][0] + # At this state, if `first_element` is still a list/tuple, it's an empty one so there is nothing to do. + if not isinstance(first_element, (int, list, tuple)): + if is_tf_available() and _is_tensorflow(first_element): + return_tensors = "tf" if return_tensors is None else return_tensors + elif is_torch_available() and _is_torch(first_element): + return_tensors = "pt" if return_tensors is None else return_tensors + elif isinstance(first_element, np.ndarray): + return_tensors = "np" if return_tensors is None else return_tensors + else: + raise ValueError( + f"type of {first_element} unknown: {type(first_element)}. " + f"Should be one of a python, numpy, pytorch or tensorflow object." + ) + + for key, value in encoded_inputs.items(): + encoded_inputs[key] = to_py_obj(value) + + # Convert padding_strategy in PaddingStrategy + padding_strategy, _, max_length, _ = self._get_padding_truncation_strategies( + padding=padding, max_length=max_length, verbose=verbose + ) + + required_input = encoded_inputs[self.model_input_names[0]] + if required_input and not isinstance(required_input[0], (list, tuple)): + encoded_inputs = self._pad( + encoded_inputs, + class_type=class_type, + max_length=max_length, + padding_strategy=padding_strategy, + pad_to_multiple_of=pad_to_multiple_of, + return_attention_mask=return_attention_mask, + ) + return BatchEncoding(encoded_inputs, tensor_type=return_tensors) + + batch_size = len(required_input) + assert all( + len(v) == batch_size for v in encoded_inputs.values() + ), "Some items in the output dictionary have a different batch size than others." + + if padding_strategy == PaddingStrategy.LONGEST: + max_length = max(len(inputs) for inputs in required_input) + padding_strategy = PaddingStrategy.MAX_LENGTH + + batch_outputs = {} + for i in range(batch_size): + inputs = dict((k, v[i]) for k, v in encoded_inputs.items()) + outputs = self._pad( + inputs, + class_type=class_type, + max_length=max_length, + padding_strategy=padding_strategy, + pad_to_multiple_of=pad_to_multiple_of, + return_attention_mask=return_attention_mask, + ) + + for key, value in outputs.items(): + if key not in batch_outputs: + batch_outputs[key] = [] + batch_outputs[key].append(value) + if class_type == "cell": + del batch_outputs["label"] + return BatchEncoding(batch_outputs, tensor_type=return_tensors) + + def _pad( + self, + encoded_inputs: Union[Dict[str, EncodedInput], BatchEncoding], + class_type, # options: "gene" or "cell" + max_length: Optional[int] = None, + padding_strategy: PaddingStrategy = PaddingStrategy.LONGEST, + pad_to_multiple_of: Optional[int] = None, + return_attention_mask: Optional[bool] = True, + ) -> dict: + """ + Pad encoded inputs (on left/right and up to predefined length or max length in the batch) + Args: + encoded_inputs: Dictionary of tokenized inputs (`List[int]`) or batch of tokenized inputs (`List[List[int]]`). + max_length: maximum length of the returned list and optionally padding length (see below). + Will truncate by taking into account the special tokens. + padding_strategy: PaddingStrategy to use for padding. + - PaddingStrategy.LONGEST Pad to the longest sequence in the batch + - PaddingStrategy.MAX_LENGTH: Pad to the max length (default) + - PaddingStrategy.DO_NOT_PAD: Do not pad + The tokenizer padding sides are defined in self.padding_side: + - 'left': pads on the left of the sequences + - 'right': pads on the right of the sequences + pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value. + This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability + >= 7.5 (Volta). + return_attention_mask: (optional) Set to False to avoid returning attention mask (default: set to model specifics) + """ + # Load from model defaults + if return_attention_mask is None: + return_attention_mask = "attention_mask" in self.model_input_names + + required_input = encoded_inputs[self.model_input_names[0]] + + if padding_strategy == PaddingStrategy.LONGEST: + max_length = len(required_input) + + if ( + max_length is not None + and pad_to_multiple_of is not None + and (max_length % pad_to_multiple_of != 0) + ): + max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of + + needs_to_be_padded = ( + padding_strategy != PaddingStrategy.DO_NOT_PAD + and len(required_input) != max_length + ) + + if needs_to_be_padded: + difference = max_length - len(required_input) + if self.padding_side == "right": + if return_attention_mask: + encoded_inputs["attention_mask"] = [1] * len(required_input) + [ + 0 + ] * difference + if "token_type_ids" in encoded_inputs: + encoded_inputs["token_type_ids"] = ( + encoded_inputs["token_type_ids"] + + [self.pad_token_type_id] * difference + ) + if "special_tokens_mask" in encoded_inputs: + encoded_inputs["special_tokens_mask"] = ( + encoded_inputs["special_tokens_mask"] + [1] * difference + ) + encoded_inputs[self.model_input_names[0]] = ( + required_input + [self.pad_token_id] * difference + ) + if class_type == "gene": + encoded_inputs["labels"] = ( + encoded_inputs["labels"] + [-100] * difference + ) + elif self.padding_side == "left": + if return_attention_mask: + encoded_inputs["attention_mask"] = [0] * difference + [1] * len( + required_input + ) + if "token_type_ids" in encoded_inputs: + encoded_inputs["token_type_ids"] = [ + self.pad_token_type_id + ] * difference + encoded_inputs["token_type_ids"] + if "special_tokens_mask" in encoded_inputs: + encoded_inputs["special_tokens_mask"] = [ + 1 + ] * difference + encoded_inputs["special_tokens_mask"] + encoded_inputs[self.model_input_names[0]] = [ + self.pad_token_id + ] * difference + required_input + if class_type == "gene": + encoded_inputs["labels"] = [-100] * difference + encoded_inputs[ + "labels" + ] + else: + raise ValueError("Invalid padding strategy:" + str(self.padding_side)) + elif return_attention_mask and "attention_mask" not in encoded_inputs: + encoded_inputs["attention_mask"] = [1] * len(required_input) + + return encoded_inputs + + def get_special_tokens_mask( + self, + token_ids_0: List[int], + token_ids_1: Optional[List[int]] = None, + already_has_special_tokens: bool = False, + ) -> List[int]: + """ + Retrieves sequence ids from a token list that has no special tokens added. This method is called when adding + special tokens using the tokenizer ``prepare_for_model`` or ``encode_plus`` methods. + Args: + token_ids_0 (:obj:`List[int]`): + List of ids of the first sequence. + token_ids_1 (:obj:`List[int]`, `optional`): + List of ids of the second sequence. + already_has_special_tokens (:obj:`bool`, `optional`, defaults to :obj:`False`): + Whether or not the token list is already formatted with special tokens for the model. + Returns: + A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token. + """ + assert already_has_special_tokens and token_ids_1 is None, ( + "You cannot use ``already_has_special_tokens=False`` with this tokenizer. " + "Please use a slow (full python) tokenizer to activate this argument." + "Or set `return_special_tokens_mask=True` when calling the encoding method " + "to get the special tokens mask in any tokenizer. " + ) + + all_special_ids = self.all_special_ids # cache the property + + special_tokens_mask = [ + 1 if token in all_special_ids else 0 for token in token_ids_0 + ] + + return special_tokens_mask + + def convert_tokens_to_ids( + self, tokens: Union[str, List[str]] + ) -> Union[int, List[int]]: + """ + Converts a token string (or a sequence of tokens) in a single integer id (or a sequence of ids), using the + vocabulary. + Args: + tokens (:obj:`str` or :obj:`List[str]`): One or several token(s) to convert to token id(s). + Returns: + :obj:`int` or :obj:`List[int]`: The token id or list of token ids. + """ + if tokens is None: + return None + + if isinstance(tokens, str): + return self._convert_token_to_id_with_added_voc(tokens) + + ids = [] + for token in tokens: + ids.append(self._convert_token_to_id_with_added_voc(token)) + return ids + + def _convert_token_to_id_with_added_voc(self, token): + if token is None: + return None + + return self.token_dictionary.get(token) + + def __len__(self): + return len(self.token_dictionary) + + +# collator functions + + +class DataCollatorForGeneClassification(DataCollatorForTokenClassification): + """ + Data collator that will dynamically pad the inputs received, as well as the labels. + Args: + tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`): + The tokenizer used for encoding the data. + padding (:obj:`bool`, :obj:`str` or :class:`~transformers.tokenization_utils_base.PaddingStrategy`, `optional`, defaults to :obj:`True`): + Select a strategy to pad the returned sequences (according to the model's padding side and padding index) + among: + * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single + sequence if provided). + * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the + maximum acceptable input length for the model if that argument is not provided. + * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of + different lengths). + max_length (:obj:`int`, `optional`): + Maximum length of the returned list and optionally padding length (see above). + pad_to_multiple_of (:obj:`int`, `optional`): + If set will pad the sequence to a multiple of the provided value. + This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >= + 7.5 (Volta). + label_pad_token_id (:obj:`int`, `optional`, defaults to -100): + The id to use when padding the labels (-100 will be automatically ignore by PyTorch loss functions). + """ + + class_type = "gene" + padding: Union[bool, str, PaddingStrategy] = True + max_length: Optional[int] = None + pad_to_multiple_of: Optional[int] = None + label_pad_token_id: int = -100 + + def __init__(self, *args, **kwargs) -> None: + self.token_dictionary = kwargs.pop("token_dictionary") + super().__init__( + tokenizer=PrecollatorForGeneAndCellClassification( + token_dictionary=self.token_dictionary + ), + padding=self.padding, + max_length=self.max_length, + pad_to_multiple_of=self.pad_to_multiple_of, + label_pad_token_id=self.label_pad_token_id, + *args, + **kwargs, + ) + + def _prepare_batch(self, features): + label_name = "label" if "label" in features[0].keys() else "labels" + labels = ( + [feature[label_name] for feature in features] + if label_name in features[0].keys() + else None + ) + batch = self.tokenizer.pad( + features, + class_type=self.class_type, + padding=self.padding, + max_length=self.max_length, + pad_to_multiple_of=self.pad_to_multiple_of, + return_tensors="pt", + ) + return batch + + def __call__(self, features): + batch = self._prepare_batch(features) + + batch = {k: torch.tensor(v, dtype=torch.int64) for k, v in batch.items()} + return batch + + +class DataCollatorForCellClassification(DataCollatorForGeneClassification): + class_type = "cell" + + def _prepare_batch(self, features): + batch = super()._prepare_batch(features) + + # Special handling for labels. + # Ensure that tensor is created with the correct type + # (it should be automatically the case, but let's make sure of it.) + first = features[0] + if "label" in first and first["label"] is not None: + label = ( + first["label"].item() + if isinstance(first["label"], torch.Tensor) + else first["label"] + ) + dtype = torch.long if isinstance(label, int) else torch.float + batch["labels"] = torch.tensor([f["label"] for f in features], dtype=dtype) + + return batch diff --git a/geneformer/emb_extractor.py b/geneformer/emb_extractor.py new file mode 100644 index 0000000000000000000000000000000000000000..90a01405d6af4f100df1c9dfa5f18f0474c65f57 --- /dev/null +++ b/geneformer/emb_extractor.py @@ -0,0 +1,863 @@ +""" +Geneformer embedding extractor. + +**Description:** + +| Extracts gene or cell embeddings. +| Plots cell embeddings as heatmaps or UMAPs. +| Generates cell state embedding dictionary for use with InSilicoPerturber. + +""" + +# imports +import logging +import pickle +from collections import Counter +from pathlib import Path + +import anndata +import matplotlib.pyplot as plt +import pandas as pd +import scanpy as sc +import seaborn as sns +import torch +from tdigest import TDigest +from tqdm.auto import trange + +from . import TOKEN_DICTIONARY_FILE +from . import perturber_utils as pu + +logger = logging.getLogger(__name__) + + +# extract embeddings +def get_embs( + model, + filtered_input_data, + emb_mode, + layer_to_quant, + pad_token_id, + forward_batch_size, + token_gene_dict, + special_token=False, + summary_stat=None, + silent=False, +): + model_input_size = pu.get_model_input_size(model) + total_batch_length = len(filtered_input_data) + + if summary_stat is None: + embs_list = [] + elif summary_stat is not None: + # get # of emb dims + emb_dims = pu.get_model_emb_dims(model) + if emb_mode == "cell": + # initiate tdigests for # of emb dims + embs_tdigests = [TDigest() for _ in range(emb_dims)] + if emb_mode == "gene": + gene_set = list( + { + element + for sublist in filtered_input_data["input_ids"] + for element in sublist + } + ) + # initiate dict with genes as keys and tdigests for # of emb dims as values + embs_tdigests_dict = { + k: [TDigest() for _ in range(emb_dims)] for k in gene_set + } + + # Check if CLS and EOS token is present in the token dictionary + cls_present = any("" in value for value in token_gene_dict.values()) + eos_present = any("" in value for value in token_gene_dict.values()) + if emb_mode == "cls": + assert cls_present, " token missing in token dictionary" + # Check to make sure that the first token of the filtered input data is cls token + gene_token_dict = {v: k for k, v in token_gene_dict.items()} + cls_token_id = gene_token_dict[""] + assert ( + filtered_input_data["input_ids"][0][0] == cls_token_id + ), "First token is not token value" + elif emb_mode == "cell": + if cls_present: + logger.warning( + "CLS token present in token dictionary, excluding from average." + ) + if eos_present: + logger.warning( + "EOS token present in token dictionary, excluding from average." + ) + + overall_max_len = 0 + + for i in trange(0, total_batch_length, forward_batch_size, leave=(not silent)): + max_range = min(i + forward_batch_size, total_batch_length) + + minibatch = filtered_input_data.select([i for i in range(i, max_range)]) + + max_len = int(max(minibatch["length"])) + original_lens = torch.tensor(minibatch["length"], device="cuda") + minibatch.set_format(type="torch") + + input_data_minibatch = minibatch["input_ids"] + input_data_minibatch = pu.pad_tensor_list( + input_data_minibatch, max_len, pad_token_id, model_input_size + ) + + with torch.no_grad(): + outputs = model( + input_ids=input_data_minibatch.to("cuda"), + attention_mask=pu.gen_attention_mask(minibatch), + ) + + embs_i = outputs.hidden_states[layer_to_quant] + + if emb_mode == "cell": + if cls_present: + non_cls_embs = embs_i[:, 1:, :] # Get all layers except the embs + if eos_present: + mean_embs = pu.mean_nonpadding_embs(non_cls_embs, original_lens - 2) + else: + mean_embs = pu.mean_nonpadding_embs(non_cls_embs, original_lens - 1) + else: + mean_embs = pu.mean_nonpadding_embs(embs_i, original_lens) + if summary_stat is None: + embs_list.append(mean_embs) + elif summary_stat is not None: + # update tdigests with current batch for each emb dim + accumulate_tdigests(embs_tdigests, mean_embs, emb_dims) + del mean_embs + elif emb_mode == "gene": + if summary_stat is None: + embs_list.append(embs_i) + elif summary_stat is not None: + for h in trange(len(minibatch)): + length_h = minibatch[h]["length"] + input_ids_h = minibatch[h]["input_ids"][0:length_h] + + # double check dimensions before unsqueezing + embs_i_dim = embs_i.dim() + if embs_i_dim != 3: + logger.error( + f"Embedding tensor should have 3 dimensions, not {embs_i_dim}" + ) + raise + + embs_h = embs_i[h, :, :].unsqueeze(dim=1) + dict_h = dict(zip(input_ids_h, embs_h)) + for k in dict_h.keys(): + accumulate_tdigests( + embs_tdigests_dict[int(k)], dict_h[k], emb_dims + ) + del embs_h + del dict_h + elif emb_mode == "cls": + cls_embs = embs_i[:, 0, :].clone().detach() # CLS token layer + embs_list.append(cls_embs) + del cls_embs + + overall_max_len = max(overall_max_len, max_len) + del outputs + del minibatch + del input_data_minibatch + del embs_i + + torch.cuda.empty_cache() + + if summary_stat is None: + if (emb_mode == "cell") or (emb_mode == "cls"): + embs_stack = torch.cat(embs_list, dim=0) + elif emb_mode == "gene": + embs_stack = pu.pad_tensor_list( + embs_list, + overall_max_len, + pad_token_id, + model_input_size, + 1, + pu.pad_3d_tensor, + ) + + # calculate summary stat embs from approximated tdigests + elif summary_stat is not None: + if emb_mode == "cell": + if summary_stat == "mean": + summary_emb_list = tdigest_mean(embs_tdigests, emb_dims) + elif summary_stat == "median": + summary_emb_list = tdigest_median(embs_tdigests, emb_dims) + embs_stack = torch.tensor(summary_emb_list) + elif emb_mode == "gene": + if summary_stat == "mean": + [ + update_tdigest_dict_mean(embs_tdigests_dict, gene, emb_dims) + for gene in embs_tdigests_dict.keys() + ] + elif summary_stat == "median": + [ + update_tdigest_dict_median(embs_tdigests_dict, gene, emb_dims) + for gene in embs_tdigests_dict.keys() + ] + return embs_tdigests_dict + + return embs_stack + + +def accumulate_tdigests(embs_tdigests, mean_embs, emb_dims): + # note: tdigest batch update known to be slow so updating serially + [ + embs_tdigests[j].update(mean_embs[i, j].item()) + for i in range(mean_embs.size(0)) + for j in range(emb_dims) + ] + + +def update_tdigest_dict(embs_tdigests_dict, gene, gene_embs, emb_dims): + embs_tdigests_dict[gene] = accumulate_tdigests( + embs_tdigests_dict[gene], gene_embs, emb_dims + ) + + +def update_tdigest_dict_mean(embs_tdigests_dict, gene, emb_dims): + embs_tdigests_dict[gene] = tdigest_mean(embs_tdigests_dict[gene], emb_dims) + + +def update_tdigest_dict_median(embs_tdigests_dict, gene, emb_dims): + embs_tdigests_dict[gene] = tdigest_median(embs_tdigests_dict[gene], emb_dims) + + +def summarize_gene_embs(h, minibatch, embs_i, embs_tdigests_dict, emb_dims): + length_h = minibatch[h]["length"] + input_ids_h = minibatch[h]["input_ids"][0:length_h] + embs_h = embs_i[h, :, :].unsqueeze(dim=1) + dict_h = dict(zip(input_ids_h, embs_h)) + [ + update_tdigest_dict(embs_tdigests_dict, k, dict_h[k], emb_dims) + for k in dict_h.keys() + ] + + +def tdigest_mean(embs_tdigests, emb_dims): + return [embs_tdigests[i].trimmed_mean(0, 100) for i in range(emb_dims)] + + +def tdigest_median(embs_tdigests, emb_dims): + return [embs_tdigests[i].percentile(50) for i in range(emb_dims)] + + +def label_cell_embs(embs, downsampled_data, emb_labels): + embs_df = pd.DataFrame(embs.cpu().numpy()) + if emb_labels is not None: + for label in emb_labels: + emb_label = downsampled_data[label] + embs_df[label] = emb_label + return embs_df + + +def label_gene_embs(embs, downsampled_data, token_gene_dict): + gene_set = { + element for sublist in downsampled_data["input_ids"] for element in sublist + } + gene_emb_dict = {k: [] for k in gene_set} + for i in range(embs.size()[0]): + length = downsampled_data[i]["length"] + dict_i = dict( + zip( + downsampled_data[i]["input_ids"][0:length], + embs[i, :, :].unsqueeze(dim=1), + ) + ) + for k in dict_i.keys(): + gene_emb_dict[k].append(dict_i[k]) + for k in gene_emb_dict.keys(): + gene_emb_dict[k] = ( + torch.squeeze(torch.mean(torch.stack(gene_emb_dict[k]), dim=0), dim=0) + .cpu() + .numpy() + ) + embs_df = pd.DataFrame(gene_emb_dict).T + embs_df.index = [token_gene_dict[token] for token in embs_df.index] + return embs_df + + +def plot_umap(embs_df, emb_dims, label, output_file, kwargs_dict, seed=0): + only_embs_df = embs_df.iloc[:, :emb_dims] + only_embs_df.index = pd.RangeIndex(0, only_embs_df.shape[0], name=None).astype(str) + only_embs_df.columns = pd.RangeIndex(0, only_embs_df.shape[1], name=None).astype( + str + ) + vars_dict = {"embs": only_embs_df.columns} + obs_dict = {"cell_id": list(only_embs_df.index), f"{label}": list(embs_df[label])} + adata = anndata.AnnData(X=only_embs_df, obs=obs_dict, var=vars_dict) + sc.tl.pca(adata, svd_solver="arpack") + sc.pp.neighbors(adata, random_state=seed) + sc.tl.umap(adata, random_state=seed) + sns.set(rc={"figure.figsize": (10, 10)}, font_scale=2.3) + sns.set_style("white") + default_kwargs_dict = {"size": 200} + if kwargs_dict is not None: + default_kwargs_dict.update(kwargs_dict) + + cats = set(embs_df[label]) + + with plt.rc_context(): + ax = sc.pl.umap(adata, color=label, show=False, **default_kwargs_dict) + ax.legend( + markerscale=2, + frameon=False, + loc="center left", + bbox_to_anchor=(1, 0.5), + ncol=(1 if len(cats) <= 14 else 2 if len(cats) <= 30 else 3), + ) + plt.show() + plt.savefig(output_file, bbox_inches="tight") + + +def gen_heatmap_class_colors(labels, df): + pal = sns.cubehelix_palette( + len(Counter(labels).keys()), + light=0.9, + dark=0.1, + hue=1, + reverse=True, + start=1, + rot=-2, + ) + lut = dict(zip(map(str, Counter(labels).keys()), pal)) + colors = pd.Series(labels, index=df.index).map(lut) + return colors + + +def gen_heatmap_class_dict(classes, label_colors_series): + class_color_dict_df = pd.DataFrame( + {"classes": classes, "color": label_colors_series} + ) + class_color_dict_df = class_color_dict_df.drop_duplicates(subset=["classes"]) + return dict(zip(class_color_dict_df["classes"], class_color_dict_df["color"])) + + +def make_colorbar(embs_df, label): + labels = list(embs_df[label]) + + cell_type_colors = gen_heatmap_class_colors(labels, embs_df) + label_colors = pd.DataFrame(cell_type_colors, columns=[label]) + + # create dictionary for colors and classes + label_color_dict = gen_heatmap_class_dict(labels, label_colors[label]) + return label_colors, label_color_dict + + +def plot_heatmap(embs_df, emb_dims, label, output_file, kwargs_dict): + sns.set_style("white") + sns.set(font_scale=2) + plt.figure(figsize=(15, 15), dpi=150) + label_colors, label_color_dict = make_colorbar(embs_df, label) + + default_kwargs_dict = { + "row_cluster": True, + "col_cluster": True, + "row_colors": label_colors, + "standard_scale": 1, + "linewidths": 0, + "xticklabels": False, + "yticklabels": False, + "figsize": (15, 15), + "center": 0, + "cmap": "magma", + } + + if kwargs_dict is not None: + default_kwargs_dict.update(kwargs_dict) + g = sns.clustermap( + embs_df.iloc[:, 0:emb_dims].apply(pd.to_numeric), **default_kwargs_dict + ) + + plt.setp(g.ax_row_colors.get_xmajorticklabels(), rotation=45, ha="right") + + for label_color in list(label_color_dict.keys()): + g.ax_col_dendrogram.bar( + 0, 0, color=label_color_dict[label_color], label=label_color, linewidth=0 + ) + + g.ax_col_dendrogram.legend( + title=f"{label}", + loc="lower center", + ncol=4, + bbox_to_anchor=(0.5, 1), + facecolor="white", + ) + plt.show() + logger.info(f"Output file: {output_file}") + plt.savefig(output_file, bbox_inches="tight") + + +class EmbExtractor: + valid_option_dict = { + "model_type": {"Pretrained", "GeneClassifier", "CellClassifier"}, + "num_classes": {int}, + "emb_mode": {"cls", "cell", "gene"}, + "cell_emb_style": {"mean_pool"}, + "gene_emb_style": {"mean_pool"}, + "filter_data": {None, dict}, + "max_ncells": {None, int}, + "emb_layer": {-1, 0}, + "emb_label": {None, list}, + "labels_to_plot": {None, list}, + "forward_batch_size": {int}, + "token_dictionary_file": {None, str}, + "nproc": {int}, + "summary_stat": {None, "mean", "median", "exact_mean", "exact_median"}, + } + + def __init__( + self, + model_type="Pretrained", + num_classes=0, + emb_mode="cls", + cell_emb_style="mean_pool", + gene_emb_style="mean_pool", + filter_data=None, + max_ncells=1000, + emb_layer=-1, + emb_label=None, + labels_to_plot=None, + forward_batch_size=100, + nproc=4, + summary_stat=None, + token_dictionary_file=None, + ): + """ + Initialize embedding extractor. + + **Parameters:** + + model_type : {"Pretrained", "GeneClassifier", "CellClassifier"} + | Whether model is the pretrained Geneformer or a fine-tuned gene or cell classifier. + num_classes : int + | If model is a gene or cell classifier, specify number of classes it was trained to classify. + | For the pretrained Geneformer model, number of classes is 0 as it is not a classifier. + emb_mode : {"cls", "cell", "gene"} + | Whether to output CLS, cell, or gene embeddings. + | CLS embeddings are cell embeddings derived from the CLS token in the front of the rank value encoding. + cell_emb_style : {"mean_pool"} + | Method for summarizing cell embeddings if not using CLS token. + | Currently only option is mean pooling of gene embeddings for given cell. + gene_emb_style : "mean_pool" + | Method for summarizing gene embeddings. + | Currently only option is mean pooling of contextual gene embeddings for given gene. + filter_data : None, dict + | Default is to extract embeddings from all input data. + | Otherwise, dictionary specifying .dataset column name and list of values to filter by. + max_ncells : None, int + | Maximum number of cells to extract embeddings from. + | Default is 1000 cells randomly sampled from input data. + | If None, will extract embeddings from all cells. + emb_layer : {-1, 0} + | Embedding layer to extract. + | The last layer is most specifically weighted to optimize the given learning objective. + | Generally, it is best to extract the 2nd to last layer to get a more general representation. + | -1: 2nd to last layer + | 0: last layer + emb_label : None, list + | List of column name(s) in .dataset to add as labels to embedding output. + labels_to_plot : None, list + | Cell labels to plot. + | Shown as color bar in heatmap. + | Shown as cell color in umap. + | Plotting umap requires labels to plot. + forward_batch_size : int + | Batch size for forward pass. + nproc : int + | Number of CPU processes to use. + summary_stat : {None, "mean", "median", "exact_mean", "exact_median"} + | If exact_mean or exact_median, outputs only exact mean or median embedding of input data. + | If mean or median, outputs only approximated mean or median embedding of input data. + | Non-exact recommended if encountering memory constraints while generating goal embedding positions. + | Non-exact is slower but more memory-efficient. + token_dictionary_file : Path + | Default is the Geneformer token dictionary + | Path to pickle file containing token dictionary (Ensembl ID:token). + + **Examples:** + + .. code-block :: python + + >>> from geneformer import EmbExtractor + >>> embex = EmbExtractor(model_type="CellClassifier", + ... num_classes=3, + ... emb_mode="cell", + ... filter_data={"cell_type":["cardiomyocyte"]}, + ... max_ncells=1000, + ... emb_layer=-1, + ... emb_label=["disease", "cell_type"], + ... labels_to_plot=["disease", "cell_type"]) + + """ + + self.model_type = model_type + self.num_classes = num_classes + self.emb_mode = emb_mode + self.cell_emb_style = cell_emb_style + self.gene_emb_style = gene_emb_style + self.filter_data = filter_data + self.max_ncells = max_ncells + self.emb_layer = emb_layer + self.emb_label = emb_label + self.labels_to_plot = labels_to_plot + self.token_dictionary_file = token_dictionary_file + self.forward_batch_size = forward_batch_size + self.nproc = nproc + if (summary_stat is not None) and ("exact" in summary_stat): + self.summary_stat = None + self.exact_summary_stat = summary_stat + else: + self.summary_stat = summary_stat + self.exact_summary_stat = None + + self.validate_options() + + # load token dictionary (Ensembl IDs:token) + if self.token_dictionary_file is None: + token_dictionary_file = TOKEN_DICTIONARY_FILE + with open(token_dictionary_file, "rb") as f: + self.gene_token_dict = pickle.load(f) + + self.token_gene_dict = {v: k for k, v in self.gene_token_dict.items()} + self.pad_token_id = self.gene_token_dict.get("") + + def validate_options(self): + # confirm arguments are within valid options and compatible with each other + for attr_name, valid_options in self.valid_option_dict.items(): + attr_value = self.__dict__[attr_name] + if not isinstance(attr_value, (list, dict)): + if attr_value in valid_options: + continue + valid_type = False + for option in valid_options: + if (option in [int, list, dict, bool, str]) and isinstance( + attr_value, option + ): + valid_type = True + break + if valid_type: + continue + logger.error( + f"Invalid option for {attr_name}. " + f"Valid options for {attr_name}: {valid_options}" + ) + raise + + if self.filter_data is not None: + for key, value in self.filter_data.items(): + if not isinstance(value, list): + self.filter_data[key] = [value] + logger.warning( + "Values in filter_data dict must be lists. " + f"Changing {key} value to list ([{value}])." + ) + + def extract_embs( + self, + model_directory, + input_data_file, + output_directory, + output_prefix, + output_torch_embs=False, + cell_state=None, + ): + """ + Extract embeddings from input data and save as results in output_directory. + + **Parameters:** + + model_directory : Path + | Path to directory containing model + input_data_file : Path + | Path to directory containing .dataset inputs + output_directory : Path + | Path to directory where embedding data will be saved as csv + output_prefix : str + | Prefix for output file + output_torch_embs : bool + | Whether or not to also output the embeddings as a tensor. + | Note, if true, will output embeddings as both dataframe and tensor. + cell_state : dict + | Cell state key and value for state embedding extraction. + + **Examples:** + + .. code-block :: python + + >>> embs = embex.extract_embs("path/to/model", + ... "path/to/input_data", + ... "path/to/output_directory", + ... "output_prefix") + + """ + + filtered_input_data = pu.load_and_filter( + self.filter_data, self.nproc, input_data_file + ) + + # Check to make sure that all the labels exist in the tokenized data: + if self.emb_label is not None: + for label in self.emb_label: + assert label in filtered_input_data.features.keys(), f"Attribute `{label}` not present in dataset features" + + if cell_state is not None: + filtered_input_data = pu.filter_by_dict( + filtered_input_data, cell_state, self.nproc + ) + downsampled_data = pu.downsample_and_sort(filtered_input_data, self.max_ncells) + model = pu.load_model( + self.model_type, self.num_classes, model_directory, mode="eval" + ) + layer_to_quant = pu.quant_layers(model) + self.emb_layer + embs = get_embs( + model=model, + filtered_input_data=downsampled_data, + emb_mode=self.emb_mode, + layer_to_quant=layer_to_quant, + pad_token_id=self.pad_token_id, + forward_batch_size=self.forward_batch_size, + token_gene_dict=self.token_gene_dict, + summary_stat=self.summary_stat, + ) + + if self.emb_mode == "cell": + if self.summary_stat is None: + embs_df = label_cell_embs(embs, downsampled_data, self.emb_label) + elif self.summary_stat is not None: + embs_df = pd.DataFrame(embs.cpu().numpy()).T + elif self.emb_mode == "gene": + if self.summary_stat is None: + embs_df = label_gene_embs(embs, downsampled_data, self.token_gene_dict) + elif self.summary_stat is not None: + embs_df = pd.DataFrame(embs).T + embs_df.index = [self.token_gene_dict[token] for token in embs_df.index] + elif self.emb_mode == "cls": + embs_df = label_cell_embs(embs, downsampled_data, self.emb_label) + + # save embeddings to output_path + if cell_state is None: + output_path = (Path(output_directory) / output_prefix).with_suffix(".csv") + embs_df.to_csv(output_path) + + if self.exact_summary_stat == "exact_mean": + embs = embs.mean(dim=0) + emb_dims = pu.get_model_emb_dims(model) + embs_df = pd.DataFrame( + embs_df[0 : emb_dims - 1].mean(axis="rows"), + columns=[self.exact_summary_stat], + ).T + elif self.exact_summary_stat == "exact_median": + embs = torch.median(embs, dim=0)[0] + emb_dims = pu.get_model_emb_dims(model) + embs_df = pd.DataFrame( + embs_df[0 : emb_dims - 1].median(axis="rows"), + columns=[self.exact_summary_stat], + ).T + + if cell_state is not None: + return embs + else: + if output_torch_embs: + return embs_df, embs + else: + return embs_df + + def get_state_embs( + self, + cell_states_to_model, + model_directory, + input_data_file, + output_directory, + output_prefix, + output_torch_embs=True, + ): + """ + Extract exact mean or exact median cell state embedding positions from input data and save as results in output_directory. + + **Parameters:** + + cell_states_to_model : None, dict + | Cell states to model if testing perturbations that achieve goal state change. + | Four-item dictionary with keys: state_key, start_state, goal_state, and alt_states + | state_key: key specifying name of column in .dataset that defines the start/goal states + | start_state: value in the state_key column that specifies the start state + | goal_state: value in the state_key column taht specifies the goal end state + | alt_states: list of values in the state_key column that specify the alternate end states + | For example: + | {"state_key": "disease", + | "start_state": "dcm", + | "goal_state": "nf", + | "alt_states": ["hcm", "other1", "other2"]} + model_directory : Path + | Path to directory containing model + input_data_file : Path + | Path to directory containing .dataset inputs + output_directory : Path + | Path to directory where embedding data will be saved as csv + output_prefix : str + | Prefix for output file + output_torch_embs : bool + | Whether or not to also output the embeddings as a tensor. + | Note, if true, will output embeddings as both dataframe and tensor. + + **Outputs** + + | Outputs state_embs_dict for use with in silico perturber. + | Format is dictionary of embedding positions of each cell state to model shifts from/towards. + | Keys specify each possible cell state to model. + | Values are target embedding positions as torch.tensor. + | For example: + | {"nf": emb_nf, + | "hcm": emb_hcm, + | "dcm": emb_dcm, + | "other1": emb_other1, + | "other2": emb_other2} + """ + + pu.validate_cell_states_to_model(cell_states_to_model) + valid_summary_stats = ["exact_mean", "exact_median"] + if self.exact_summary_stat not in valid_summary_stats: + logger.error( + "For extracting state embs, summary_stat in EmbExtractor " + f"must be set to option in {valid_summary_stats}" + ) + raise + + if self.emb_label is not None: + logger.error( + "For extracting state embs, emb_label should be None since labels are based on state embs dict keys." + ) + raise + + state_embs_dict = dict() + state_key = cell_states_to_model["state_key"] + for k, v in cell_states_to_model.items(): + if k == "state_key": + continue + elif (k == "start_state") or (k == "goal_state"): + state_embs_dict[v] = self.extract_embs( + model_directory, + input_data_file, + output_directory, + output_prefix, + output_torch_embs, + cell_state={state_key: v}, + ) + else: # k == "alt_states" + for alt_state in v: + state_embs_dict[alt_state] = self.extract_embs( + model_directory, + input_data_file, + output_directory, + output_prefix, + output_torch_embs, + cell_state={state_key: alt_state}, + ) + + output_path = (Path(output_directory) / output_prefix).with_suffix(".pkl") + with open(output_path, "wb") as fp: + pickle.dump(state_embs_dict, fp) + + return state_embs_dict + + def plot_embs( + self, + embs, + plot_style, + output_directory, + output_prefix, + max_ncells_to_plot=1000, + kwargs_dict=None, + ): + """ + Plot embeddings, coloring by provided labels. + + **Parameters:** + + embs : pandas.core.frame.DataFrame + | Pandas dataframe containing embeddings output from extract_embs + plot_style : str + | Style of plot: "heatmap" or "umap" + output_directory : Path + | Path to directory where plots will be saved as pdf + output_prefix : str + | Prefix for output file + max_ncells_to_plot : None, int + | Maximum number of cells to plot. + | Default is 1000 cells randomly sampled from embeddings. + | If None, will plot embeddings from all cells. + kwargs_dict : dict + | Dictionary of kwargs to pass to plotting function. + + **Examples:** + + .. code-block :: python + + >>> embex.plot_embs(embs=embs, + ... plot_style="heatmap", + ... output_directory="path/to/output_directory", + ... output_prefix="output_prefix") + + """ + + if plot_style not in ["heatmap", "umap"]: + logger.error( + "Invalid option for 'plot_style'. " "Valid options: {'heatmap','umap'}" + ) + raise + + if (plot_style == "umap") and (self.labels_to_plot is None): + logger.error("Plotting UMAP requires 'labels_to_plot'. ") + raise + + if max_ncells_to_plot is not None: + if max_ncells_to_plot > self.max_ncells: + max_ncells_to_plot = self.max_ncells + logger.warning( + "max_ncells_to_plot must be <= max_ncells. " + f"Changing max_ncells_to_plot to {self.max_ncells}." + ) + elif max_ncells_to_plot < self.max_ncells: + embs = embs.sample(max_ncells_to_plot, axis=0) + + if self.emb_label is None: + label_len = 0 + else: + label_len = len(self.emb_label) + + emb_dims = embs.shape[1] - label_len + + if self.emb_label is None: + emb_labels = None + else: + emb_labels = embs.columns[emb_dims:] + + if plot_style == "umap": + for label in self.labels_to_plot: + if label not in emb_labels: + logger.warning( + f"Label {label} from labels_to_plot " + f"not present in provided embeddings dataframe." + ) + continue + output_prefix_label = output_prefix + f"_umap_{label}" + output_file = ( + Path(output_directory) / output_prefix_label + ).with_suffix(".pdf") + plot_umap(embs, emb_dims, label, output_file, kwargs_dict) + + if plot_style == "heatmap": + for label in self.labels_to_plot: + if label not in emb_labels: + logger.warning( + f"Label {label} from labels_to_plot " + f"not present in provided embeddings dataframe." + ) + continue + output_prefix_label = output_prefix + f"_heatmap_{label}" + output_file = ( + Path(output_directory) / output_prefix_label + ).with_suffix(".pdf") + plot_heatmap(embs, emb_dims, label, output_file, kwargs_dict) diff --git a/geneformer/evaluation_utils.py b/geneformer/evaluation_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b42833785819a08d9afc1cdb84a210c46a9e94ea --- /dev/null +++ b/geneformer/evaluation_utils.py @@ -0,0 +1,287 @@ +import logging +import math +import pickle +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +import torch +from datasets.utils.logging import disable_progress_bar, enable_progress_bar +from sklearn import preprocessing +from sklearn.metrics import ( + ConfusionMatrixDisplay, + accuracy_score, + auc, + confusion_matrix, + f1_score, + roc_curve, +) +from tqdm.auto import trange + +from . import TOKEN_DICTIONARY_FILE +from .emb_extractor import make_colorbar + +logger = logging.getLogger(__name__) + + +def preprocess_classifier_batch(cell_batch, max_len, label_name): + if max_len is None: + max_len = max([len(i) for i in cell_batch["input_ids"]]) + + # load token dictionary (Ensembl IDs:token) + with open(TOKEN_DICTIONARY_FILE, "rb") as f: + gene_token_dict = pickle.load(f) + + def pad_label_example(example): + example[label_name] = np.pad( + example[label_name], + (0, max_len - len(example["input_ids"])), + mode="constant", + constant_values=-100, + ) + example["input_ids"] = np.pad( + example["input_ids"], + (0, max_len - len(example["input_ids"])), + mode="constant", + constant_values=gene_token_dict.get(""), + ) + example["attention_mask"] = ( + example["input_ids"] != gene_token_dict.get("") + ).astype(int) + return example + + padded_batch = cell_batch.map(pad_label_example) + return padded_batch + + +# Function to find the largest number smaller +# than or equal to N that is divisible by k +def find_largest_div(N, K): + rem = N % K + if rem == 0: + return N + else: + return N - rem + + +def vote(logit_list): + m = max(logit_list) + logit_list.index(m) + indices = [i for i, x in enumerate(logit_list) if x == m] + if len(indices) > 1: + return "tie" + else: + return indices[0] + + +def py_softmax(vector): + e = np.exp(vector) + return e / e.sum() + + +def classifier_predict(model, classifier_type, evalset, forward_batch_size): + if classifier_type == "gene": + label_name = "labels" + elif classifier_type == "cell": + label_name = "label" + + predict_logits = [] + predict_labels = [] + model.eval() + + # ensure there is at least 2 examples in each batch to avoid incorrect tensor dims + evalset_len = len(evalset) + max_divisible = find_largest_div(evalset_len, forward_batch_size) + if len(evalset) - max_divisible == 1: + evalset_len = max_divisible + + max_evalset_len = max(evalset.select([i for i in range(evalset_len)])["length"]) + + disable_progress_bar() # disable progress bar for preprocess_classifier_batch mapping + for i in trange(0, evalset_len, forward_batch_size): + max_range = min(i + forward_batch_size, evalset_len) + batch_evalset = evalset.select([i for i in range(i, max_range)]) + padded_batch = preprocess_classifier_batch( + batch_evalset, max_evalset_len, label_name + ) + padded_batch.set_format(type="torch") + + input_data_batch = padded_batch["input_ids"] + attn_msk_batch = padded_batch["attention_mask"] + label_batch = padded_batch[label_name] + with torch.no_grad(): + outputs = model( + input_ids=input_data_batch.to("cuda"), + attention_mask=attn_msk_batch.to("cuda"), + labels=label_batch.to("cuda"), + ) + predict_logits += [torch.squeeze(outputs.logits.to("cpu"))] + predict_labels += [torch.squeeze(label_batch.to("cpu"))] + + enable_progress_bar() + logits_by_cell = torch.cat(predict_logits) + last_dim = len(logits_by_cell.shape) - 1 + all_logits = logits_by_cell.reshape(-1, logits_by_cell.shape[last_dim]) + labels_by_cell = torch.cat(predict_labels) + all_labels = torch.flatten(labels_by_cell) + logit_label_paired = [ + item + for item in list(zip(all_logits.tolist(), all_labels.tolist())) + if item[1] != -100 + ] + y_pred = [vote(item[0]) for item in logit_label_paired] + y_true = [item[1] for item in logit_label_paired] + logits_list = [item[0] for item in logit_label_paired] + return y_pred, y_true, logits_list + + +def get_metrics(y_pred, y_true, logits_list, num_classes, labels): + conf_mat = confusion_matrix(y_true, y_pred, labels=list(labels)) + macro_f1 = f1_score(y_true, y_pred, average="macro") + acc = accuracy_score(y_true, y_pred) + roc_metrics = None # roc metrics not reported for multiclass + if num_classes == 2: + y_score = [py_softmax(item)[1] for item in logits_list] + fpr, tpr, _ = roc_curve(y_true, y_score) + mean_fpr = np.linspace(0, 1, 100) + interp_tpr = np.interp(mean_fpr, fpr, tpr) + interp_tpr[0] = 0.0 + tpr_wt = len(tpr) + roc_auc = auc(fpr, tpr) + roc_metrics = { + "fpr": fpr, + "tpr": tpr, + "interp_tpr": interp_tpr, + "auc": roc_auc, + "tpr_wt": tpr_wt, + } + return conf_mat, macro_f1, acc, roc_metrics + + +# get cross-validated mean and sd metrics +def get_cross_valid_roc_metrics(all_tpr, all_roc_auc, all_tpr_wt): + wts = [count / sum(all_tpr_wt) for count in all_tpr_wt] + all_weighted_tpr = [a * b for a, b in zip(all_tpr, wts)] + mean_tpr = np.sum(all_weighted_tpr, axis=0) + mean_tpr[-1] = 1.0 + all_weighted_roc_auc = [a * b for a, b in zip(all_roc_auc, wts)] + roc_auc = np.sum(all_weighted_roc_auc) + roc_auc_sd = math.sqrt(np.average((all_roc_auc - roc_auc) ** 2, weights=wts)) + return mean_tpr, roc_auc, roc_auc_sd + + +# plot ROC curve +def plot_ROC(roc_metric_dict, model_style_dict, title, output_dir, output_prefix): + fig = plt.figure() + fig.set_size_inches(10, 8) + sns.set(font_scale=2) + sns.set_style("white") + lw = 3 + for model_name in roc_metric_dict.keys(): + mean_fpr = roc_metric_dict[model_name]["mean_fpr"] + mean_tpr = roc_metric_dict[model_name]["mean_tpr"] + roc_auc = roc_metric_dict[model_name]["roc_auc"] + roc_auc_sd = roc_metric_dict[model_name]["roc_auc_sd"] + color = model_style_dict[model_name]["color"] + linestyle = model_style_dict[model_name]["linestyle"] + if len(roc_metric_dict[model_name]["all_roc_auc"]) > 1: + label = f"{model_name} (AUC {roc_auc:0.2f} $\pm$ {roc_auc_sd:0.2f})" + else: + label = f"{model_name} (AUC {roc_auc:0.2f})" + plt.plot( + mean_fpr, mean_tpr, color=color, linestyle=linestyle, lw=lw, label=label + ) + + plt.plot([0, 1], [0, 1], color="black", lw=lw, linestyle="--") + plt.xlim([0.0, 1.0]) + plt.ylim([0.0, 1.05]) + plt.xlabel("False Positive Rate") + plt.ylabel("True Positive Rate") + plt.title(title) + plt.legend(loc="lower right") + + output_file = (Path(output_dir) / f"{output_prefix}_roc").with_suffix(".pdf") + plt.savefig(output_file, bbox_inches="tight") + plt.show() + + +# plot confusion matrix +def plot_confusion_matrix( + conf_mat_df, title, output_dir, output_prefix, custom_class_order +): + fig = plt.figure() + fig.set_size_inches(10, 10) + sns.set(font_scale=1) + sns.set_style("whitegrid", {"axes.grid": False}) + if custom_class_order is not None: + conf_mat_df = conf_mat_df.reindex( + index=custom_class_order, columns=custom_class_order + ) + display_labels = generate_display_labels(conf_mat_df) + conf_mat = preprocessing.normalize(conf_mat_df.to_numpy(), norm="l1") + display = ConfusionMatrixDisplay( + confusion_matrix=conf_mat, display_labels=display_labels + ) + display.plot(cmap="Blues", values_format=".2g") + plt.title(title) + plt.show() + + output_file = (Path(output_dir) / f"{output_prefix}_conf_mat").with_suffix(".pdf") + display.figure_.savefig(output_file, bbox_inches="tight") + + +def generate_display_labels(conf_mat_df): + display_labels = [] + i = 0 + for label in conf_mat_df.index: + display_labels += [f"{label}\nn={conf_mat_df.iloc[i,:].sum():.0f}"] + i = i + 1 + return display_labels + + +def plot_predictions(predictions_df, title, output_dir, output_prefix, kwargs_dict): + sns.set(font_scale=2) + plt.figure(figsize=(10, 10), dpi=150) + label_colors, label_color_dict = make_colorbar(predictions_df, "true") + predictions_df = predictions_df.drop(columns=["true"]) + predict_colors_list = [label_color_dict[label] for label in predictions_df.columns] + predict_label_list = [label for label in predictions_df.columns] + predict_colors = pd.DataFrame( + pd.Series(predict_colors_list, index=predict_label_list), columns=["predicted"] + ) + + default_kwargs_dict = { + "row_cluster": False, + "col_cluster": False, + "row_colors": label_colors, + "col_colors": predict_colors, + "linewidths": 0, + "xticklabels": False, + "yticklabels": False, + "center": 0, + "cmap": "vlag", + } + + if kwargs_dict is not None: + default_kwargs_dict.update(kwargs_dict) + g = sns.clustermap(predictions_df, **default_kwargs_dict) + + plt.setp(g.ax_row_colors.get_xmajorticklabels(), rotation=45, ha="right") + + for label_color in list(label_color_dict.keys()): + g.ax_col_dendrogram.bar( + 0, 0, color=label_color_dict[label_color], label=label_color, linewidth=0 + ) + + g.ax_col_dendrogram.legend( + title=f"{title}", + loc="lower center", + ncol=4, + bbox_to_anchor=(0.5, 1), + facecolor="white", + ) + + output_file = (Path(output_dir) / f"{output_prefix}_pred").with_suffix(".pdf") + plt.savefig(output_file, bbox_inches="tight") diff --git a/geneformer/in_silico_perturber.py b/geneformer/in_silico_perturber.py new file mode 100644 index 0000000000000000000000000000000000000000..d2c6601ba67f240f3ef9f17aaf20ed14d73a2b71 --- /dev/null +++ b/geneformer/in_silico_perturber.py @@ -0,0 +1,1579 @@ +""" +Geneformer in silico perturber. + +**Usage:** + +.. code-block :: python + + >>> from geneformer import InSilicoPerturber + >>> isp = InSilicoPerturber(perturb_type="delete", + ... perturb_rank_shift=None, + ... genes_to_perturb="all", + ... model_type="CellClassifier", + ... num_classes=0, + ... emb_mode="cell", + ... filter_data={"cell_type":["cardiomyocyte"]}, + ... cell_states_to_model={"state_key": "disease", "start_state": "dcm", "goal_state": "nf", "alt_states": ["hcm", "other1", "other2"]}, + ... state_embs_dict ={"nf": emb_nf, "hcm": emb_hcm, "dcm": emb_dcm, "other1": emb_other1, "other2": emb_other2}, + ... max_ncells=None, + ... emb_layer=0, + ... forward_batch_size=100, + ... nproc=16) + >>> isp.perturb_data("path/to/model", + ... "path/to/input_data", + ... "path/to/output_directory", + ... "output_prefix") + +**Description:** + +| Performs in silico perturbation (e.g. deletion or overexpression) of defined set of genes or all genes in sample of cells. +| Outputs impact of perturbation on cell or gene embeddings. +| Output files are analyzed with ``in_silico_perturber_stats``. + +""" + +import logging + +# imports +import os +import pickle +from collections import defaultdict + +import torch +from datasets import Dataset +from multiprocess import set_start_method +from tqdm.auto import trange + +from . import TOKEN_DICTIONARY_FILE +from . import perturber_utils as pu +from .emb_extractor import get_embs + +import datasets +datasets.logging.disable_progress_bar() + + +logger = logging.getLogger(__name__) + + +class InSilicoPerturber: + valid_option_dict = { + "perturb_type": {"delete", "overexpress", "inhibit", "activate"}, + "perturb_rank_shift": {None, 1, 2, 3}, + "genes_to_perturb": {"all", list}, + "combos": {0, 1}, + "anchor_gene": {None, str}, + "model_type": {"Pretrained", "GeneClassifier", "CellClassifier", "MTLCellClassifier", "MTLCellClassifier-Quantized"}, + "num_classes": {int}, + "emb_mode": {"cls", "cell", "cls_and_gene", "cell_and_gene"}, + "cell_emb_style": {"mean_pool"}, + "filter_data": {None, dict}, + "cell_states_to_model": {None, dict}, + "state_embs_dict": {None, dict}, + "max_ncells": {None, int}, + "cell_inds_to_perturb": {"all", dict}, + "emb_layer": {-1, 0}, + "token_dictionary_file": {None, str}, + "forward_batch_size": {int}, + "nproc": {int}, + } + + def __init__( + self, + perturb_type="delete", + perturb_rank_shift=None, + genes_to_perturb="all", + combos=0, + anchor_gene=None, + model_type="Pretrained", + num_classes=0, + emb_mode="cls", + cell_emb_style="mean_pool", + filter_data=None, + cell_states_to_model=None, + state_embs_dict=None, + max_ncells=None, + cell_inds_to_perturb="all", + emb_layer=-1, + forward_batch_size=100, + nproc=4, + token_dictionary_file=None, + clear_mem_ncells=1000, + ): + """ + Initialize in silico perturber. + + **Parameters:** + + perturb_type : {"delete", "overexpress", "inhibit", "activate"} + | Type of perturbation. + | "delete": delete gene from rank value encoding + | "overexpress": move gene to front of rank value encoding + | *(TBA)* "inhibit": move gene to lower quartile of rank value encoding + | *(TBA)* "activate": move gene to higher quartile of rank value encoding + *(TBA)* perturb_rank_shift : None, {1,2,3} + | Number of quartiles by which to shift rank of gene. + | For example, if perturb_type="activate" and perturb_rank_shift=1: + | genes in 4th quartile will move to middle of 3rd quartile. + | genes in 3rd quartile will move to middle of 2nd quartile. + | genes in 2nd quartile will move to middle of 1st quartile. + | genes in 1st quartile will move to front of rank value encoding. + | For example, if perturb_type="inhibit" and perturb_rank_shift=2: + | genes in 1st quartile will move to middle of 3rd quartile. + | genes in 2nd quartile will move to middle of 4th quartile. + | genes in 3rd or 4th quartile will move to bottom of rank value encoding. + genes_to_perturb : "all", list + | Default is perturbing each gene detected in each cell in the dataset. + | Otherwise, may provide a list of ENSEMBL IDs of genes to perturb. + | If gene list is provided, then perturber will only test perturbing them all together + | (rather than testing each possible combination of the provided genes). + combos : {0,1} + | Whether to perturb genes individually (0) or in pairs (1). + anchor_gene : None, str + | ENSEMBL ID of gene to use as anchor in combination perturbations. + | For example, if combos=1 and anchor_gene="ENSG00000148400": + | anchor gene will be perturbed in combination with each other gene. + model_type : {"Pretrained", "GeneClassifier", "CellClassifier", "MTLCellClassifier", "MTLCellClassifier-Quantized"} + | Whether model is the pretrained Geneformer or a fine-tuned gene, cell, or multitask cell classifier (+/- 8bit quantization). + num_classes : int + | If model is a gene or cell classifier, specify number of classes it was trained to classify. + | For the pretrained Geneformer model, number of classes is 0 as it is not a classifier. + emb_mode : {"cls", "cell", "cls_and_gene","cell_and_gene"} + | Whether to output impact of perturbation on CLS token, cell, and/or gene embeddings. + | Gene embedding shifts only available as compared to original cell, not comparing to goal state. + cell_emb_style : "mean_pool" + | Method for summarizing cell embeddings if not using CLS token. + | Currently only option is mean pooling of gene embeddings for given cell. + filter_data : None, dict + | Default is to use all input data for in silico perturbation study. + | Otherwise, dictionary specifying .dataset column name and list of values to filter by. + cell_states_to_model : None, dict + | Cell states to model if testing perturbations that achieve goal state change. + | Four-item dictionary with keys: state_key, start_state, goal_state, and alt_states + | state_key: key specifying name of column in .dataset that defines the start/goal states + | start_state: value in the state_key column that specifies the start state + | goal_state: value in the state_key column taht specifies the goal end state + | alt_states: list of values in the state_key column that specify the alternate end states + | For example: {"state_key": "disease", + | "start_state": "dcm", + | "goal_state": "nf", + | "alt_states": ["hcm", "other1", "other2"]} + state_embs_dict : None, dict + | Embedding positions of each cell state to model shifts from/towards (e.g. mean or median). + | Dictionary with keys specifying each possible cell state to model. + | Values are target embedding positions as torch.tensor. + | For example: {"nf": emb_nf, + | "hcm": emb_hcm, + | "dcm": emb_dcm, + | "other1": emb_other1, + | "other2": emb_other2} + max_ncells : None, int + | Maximum number of cells to test. + | If None, will test all cells. + cell_inds_to_perturb : "all", list + | Default is perturbing each cell in the dataset. + | Otherwise, may provide a dict of indices of cells to perturb with keys start_ind and end_ind. + | start_ind: the first index to perturb. + | end_ind: the last index to perturb (exclusive). + | Indices will be selected *after* the filter_data criteria and sorting. + | Useful for splitting extremely large datasets across separate GPUs. + emb_layer : {-1, 0} + | Embedding layer to use for quantification. + | 0: last layer (recommended for questions closely tied to model's training objective) + | -1: 2nd to last layer (recommended for questions requiring more general representations) + forward_batch_size : int + | Batch size for forward pass. + nproc : int + | Number of CPU processes to use. + token_dictionary_file : Path + | Path to pickle file containing token dictionary (Ensembl ID:token). + clear_mem_ncells : int + | Clear memory every n cells. + """ + try: + set_start_method("spawn") + except RuntimeError: + pass + + self.perturb_type = perturb_type + self.perturb_rank_shift = perturb_rank_shift + self.genes_to_perturb = genes_to_perturb + self.combos = combos + self.anchor_gene = anchor_gene + if self.genes_to_perturb == "all": + self.perturb_group = False + else: + self.perturb_group = True + if (self.anchor_gene is not None) or (self.combos != 0): + self.anchor_gene = None + self.combos = 0 + logger.warning( + "anchor_gene set to None and combos set to 0. " + "If providing list of genes to perturb, " + "list of genes_to_perturb will be perturbed together, " + "without anchor gene or combinations." + ) + self.model_type = model_type + self.num_classes = num_classes + self.emb_mode = emb_mode + self.cell_emb_style = cell_emb_style + self.filter_data = filter_data + self.cell_states_to_model = cell_states_to_model + self.state_embs_dict = state_embs_dict + self.max_ncells = max_ncells + self.cell_inds_to_perturb = cell_inds_to_perturb + self.emb_layer = emb_layer + self.forward_batch_size = forward_batch_size + self.nproc = nproc + self.token_dictionary_file = token_dictionary_file + self.clear_mem_ncells = clear_mem_ncells + + self.validate_options() + + # load token dictionary (Ensembl IDs:token) + if self.token_dictionary_file is None: + token_dictionary_file = TOKEN_DICTIONARY_FILE + with open(token_dictionary_file, "rb") as f: + self.gene_token_dict = pickle.load(f) + self.token_gene_dict = {v: k for k, v in self.gene_token_dict.items()} + + self.pad_token_id = self.gene_token_dict.get("") + self.cls_token_id = self.gene_token_dict.get("") + self.eos_token_id = self.gene_token_dict.get("") + + # Identify if special token is present in the token dictionary + if (self.cls_token_id is not None) and (self.eos_token_id is not None): + self.special_token = True + else: + if "cls" in self.emb_mode: + logger.error( + f"emb_mode set to {self.emb_mode} but or token not in token dictionary." + ) + raise + self.special_token = False + + if self.anchor_gene is None: + self.anchor_token = None + else: + try: + self.anchor_token = [self.gene_token_dict[self.anchor_gene]] + except KeyError: + logger.error(f"Anchor gene {self.anchor_gene} not in token dictionary.") + raise + + if self.genes_to_perturb == "all": + self.tokens_to_perturb = "all" + else: + missing_genes = [ + gene + for gene in self.genes_to_perturb + if gene not in self.gene_token_dict.keys() + ] + if len(missing_genes) == len(self.genes_to_perturb): + logger.error( + "None of the provided genes to perturb are in token dictionary." + ) + raise + elif len(missing_genes) > 0: + logger.warning( + f"Genes to perturb {missing_genes} are not in token dictionary." + ) + self.tokens_to_perturb = [ + self.gene_token_dict.get(gene) for gene in self.genes_to_perturb + ] + + def validate_options(self): + # first disallow options under development + if self.perturb_type in ["inhibit", "activate"]: + logger.error( + "In silico inhibition and activation currently under development. " + "Current valid options for 'perturb_type': 'delete' or 'overexpress'" + ) + raise + if (self.combos > 0) and (self.anchor_gene is None): + logger.error( + "Combination perturbation without anchor gene is currently under development. " + "Currently, must provide anchor gene for combination perturbation." + ) + raise + + # confirm arguments are within valid options and compatible with each other + for attr_name, valid_options in self.valid_option_dict.items(): + attr_value = self.__dict__[attr_name] + if type(attr_value) not in {list, dict}: + if attr_value in valid_options: + continue + if attr_name in ["anchor_gene"]: + if type(attr_name) in {str}: + continue + valid_type = False + for option in valid_options: + if (option in [bool, int, list, dict, str]) and isinstance( + attr_value, option + ): + valid_type = True + break + if valid_type: + continue + logger.error( + f"Invalid option for {attr_name}. " + f"Valid options for {attr_name}: {valid_options}" + ) + raise + + if self.perturb_type in ["delete", "overexpress"]: + if self.perturb_rank_shift is not None: + if self.perturb_type == "delete": + logger.warning( + "perturb_rank_shift set to None. " + "If perturb type is delete then gene is deleted entirely " + "rather than shifted by quartile" + ) + elif self.perturb_type == "overexpress": + logger.warning( + "perturb_rank_shift set to None. " + "If perturb type is overexpress then gene is moved to front " + "of rank value encoding rather than shifted by quartile" + ) + self.perturb_rank_shift = None + + if (self.anchor_gene is not None) and (self.emb_mode == "cell_and_gene"): + self.emb_mode = "cell" + logger.warning( + "emb_mode set to 'cell'. " + "Currently, analysis with anchor gene " + "only outputs effect on cell embeddings." + ) + + if self.cell_states_to_model is not None: + pu.validate_cell_states_to_model(self.cell_states_to_model) + + if self.anchor_gene is not None: + self.anchor_gene = None + logger.warning( + "anchor_gene set to None. " + "Currently, anchor gene not available " + "when modeling multiple cell states." + ) + + if self.state_embs_dict is None: + logger.error( + "state_embs_dict must be provided for mode with cell_states_to_model. " + "Format is dictionary with keys specifying each possible cell state to model. " + "Values are target embedding positions as torch.tensor." + ) + raise + + for state_emb in self.state_embs_dict.values(): + if not torch.is_tensor(state_emb): + logger.error( + "state_embs_dict must be dictionary with values being torch.tensor." + ) + raise + + keys_absent = [] + for k, v in self.cell_states_to_model.items(): + if (k == "start_state") or (k == "goal_state"): + if v not in self.state_embs_dict.keys(): + keys_absent.append(v) + if k == "alt_states": + for state in v: + if state not in self.state_embs_dict.keys(): + keys_absent.append(state) + if len(keys_absent) > 0: + logger.error( + "Each start_state, goal_state, and alt_states in cell_states_to_model " + "must be a key in state_embs_dict with the value being " + "the state's embedding position as torch.tensor. " + f"Missing keys: {keys_absent}" + ) + raise + + if self.perturb_type in ["inhibit", "activate"]: + if self.perturb_rank_shift is None: + logger.error( + "If perturb_type is inhibit or activate then " + "quartile to shift by must be specified." + ) + raise + + if self.filter_data is not None: + for key, value in self.filter_data.items(): + if not isinstance(value, list): + self.filter_data[key] = [value] + logger.warning( + "Values in filter_data dict must be lists. " + f"Changing {key} value to list ([{value}])." + ) + + if self.cell_inds_to_perturb != "all": + if set(self.cell_inds_to_perturb.keys()) != {"start", "end"}: + logger.error( + "If cell_inds_to_perturb is a dictionary, keys must be 'start' and 'end'." + ) + raise + if ( + self.cell_inds_to_perturb["start"] < 0 + or self.cell_inds_to_perturb["end"] < 0 + ): + logger.error("cell_inds_to_perturb must be positive.") + raise + + def perturb_data( + self, model_directory, input_data_file, output_directory, output_prefix + ): + """ + Perturb genes in input data and save as results in output_directory. + + **Parameters:** + + model_directory : Path + | Path to directory containing model + input_data_file : Path + | Path to directory containing .dataset inputs + output_directory : Path + | Path to directory where perturbation data will be saved as batched pickle files + output_prefix : str + | Prefix for output files + """ + + ### format output path ### + output_path_prefix = os.path.join( + output_directory, f"in_silico_{self.perturb_type}_{output_prefix}" + ) + + ### load model and define parameters ### + model = pu.load_model( + self.model_type, self.num_classes, model_directory, mode="eval" + ) + self.max_len = pu.get_model_input_size(model) + layer_to_quant = pu.quant_layers(model) + self.emb_layer + + ### filter input data ### + # general filtering of input data based on filter_data argument + filtered_input_data = pu.load_and_filter( + self.filter_data, self.nproc, input_data_file + ) + + # Ensure emb_mode is cls if first token of the filtered input data is cls token + if self.special_token: + if (filtered_input_data["input_ids"][0][0] == self.cls_token_id) and ( + "cls" not in self.emb_mode + ): + logger.error( + "Emb mode 'cls' or 'cls_and_gene' required when first token is ." + ) + raise + if "cls" in self.emb_mode: + if (filtered_input_data["input_ids"][0][0] != self.cls_token_id) or ( + filtered_input_data["input_ids"][0][-1] != self.eos_token_id + ): + logger.error( + "Emb mode 'cls' and 'cls_and_gene' require that first token is and last token is ." + ) + raise + + filtered_input_data = self.apply_additional_filters(filtered_input_data) + + if self.perturb_group is True: + if (self.special_token) and ("cls" in self.emb_mode): + self.isp_perturb_set_special( + model, filtered_input_data, layer_to_quant, output_path_prefix + ) + else: + self.isp_perturb_set( + model, filtered_input_data, layer_to_quant, output_path_prefix + ) + else: + if (self.special_token) and ("cls" in self.emb_mode): + self.isp_perturb_all_special( + model, filtered_input_data, layer_to_quant, output_path_prefix + ) + else: + self.isp_perturb_all( + model, filtered_input_data, layer_to_quant, output_path_prefix + ) + + def apply_additional_filters(self, filtered_input_data): + # additional filtering of input data dependent on isp mode + if self.cell_states_to_model is not None: + # filter for cells with start_state and log result + filtered_input_data = pu.filter_data_by_start_state( + filtered_input_data, self.cell_states_to_model, self.nproc + ) + + if (self.tokens_to_perturb != "all") and (self.perturb_type != "overexpress"): + # filter for cells with tokens_to_perturb and log result + filtered_input_data = pu.filter_data_by_tokens_and_log( + filtered_input_data, + self.tokens_to_perturb, + self.nproc, + "genes_to_perturb", + ) + + if self.anchor_token is not None: + # filter for cells with anchor gene and log result + filtered_input_data = pu.filter_data_by_tokens_and_log( + filtered_input_data, self.anchor_token, self.nproc, "anchor_gene" + ) + + # downsample and sort largest to smallest to encounter memory constraints earlier + filtered_input_data = pu.downsample_and_sort( + filtered_input_data, self.max_ncells + ) + + # slice dataset if cells_inds_to_perturb is not "all" + if self.cell_inds_to_perturb != "all": + filtered_input_data = pu.slice_by_inds_to_perturb( + filtered_input_data, self.cell_inds_to_perturb + ) + + return filtered_input_data + + def isp_perturb_set( + self, + model, + filtered_input_data: Dataset, + layer_to_quant: int, + output_path_prefix: str, + ): + def make_group_perturbation_batch(example): + example_input_ids = example["input_ids"] + example["tokens_to_perturb"] = self.tokens_to_perturb + indices_to_perturb = [ + example_input_ids.index(token) if token in example_input_ids else None + for token in self.tokens_to_perturb + ] + indices_to_perturb = [ + item for item in indices_to_perturb if item is not None + ] + if len(indices_to_perturb) > 0: + example["perturb_index"] = indices_to_perturb + else: + # -100 indicates tokens to overexpress are not present in rank value encoding + example["perturb_index"] = [-100] + if self.perturb_type == "delete": + example = pu.delete_indices(example) + elif self.perturb_type == "overexpress": + example = pu.overexpress_tokens( + example, self.max_len, self.special_token + ) + example["n_overflow"] = pu.calc_n_overflow( + self.max_len, + example["length"], + self.tokens_to_perturb, + indices_to_perturb, + ) + return example + + total_batch_length = len(filtered_input_data) + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states(self.cell_states_to_model) + } + + perturbed_data = filtered_input_data.map( + make_group_perturbation_batch, num_proc=self.nproc + ) + + if self.perturb_type == "overexpress": + filtered_input_data = filtered_input_data.add_column( + "n_overflow", perturbed_data["n_overflow"] + ) + # remove overflow genes from original data so that embeddings are comparable + # i.e. if original cell has genes 0:2047 and you want to overexpress new gene 2048, + # then the perturbed cell will be 2048+0:2046 so we compare it to an original cell 0:2046. + # (otherwise we will be modeling the effect of both deleting 2047 and adding 2048, + # rather than only adding 2048) + filtered_input_data = filtered_input_data.map( + pu.truncate_by_n_overflow, num_proc=self.nproc + ) + + if self.emb_mode == "cell_and_gene": + stored_gene_embs_dict = defaultdict(list) + + # iterate through batches + for i in trange(0, total_batch_length, self.forward_batch_size): + max_range = min(i + self.forward_batch_size, total_batch_length) + inds_select = [i for i in range(i, max_range)] + + minibatch = filtered_input_data.select(inds_select) + perturbation_batch = perturbed_data.select(inds_select) + + if self.cell_emb_style == "mean_pool": + full_original_emb = get_embs( + model, + minibatch, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + token_gene_dict=self.token_gene_dict, + summary_stat=None, + silent=True, + ) + indices_to_perturb = perturbation_batch["perturb_index"] + # remove indices that were perturbed + original_emb = pu.remove_perturbed_indices_set( + full_original_emb, + self.perturb_type, + indices_to_perturb, + self.tokens_to_perturb, + minibatch["length"], + ) + full_perturbation_emb = get_embs( + model, + perturbation_batch, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + token_gene_dict=self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + # remove overexpressed genes + if self.perturb_type == "overexpress": + perturbation_emb = full_perturbation_emb[ + :, len(self.tokens_to_perturb) :, : + ] + + elif self.perturb_type == "delete": + perturbation_emb = full_perturbation_emb[ + :, : max(perturbation_batch["length"]), : + ] + + n_perturbation_genes = perturbation_emb.size()[1] + + # if no goal states, the cosine similarties are the mean of gene cosine similarities + if ( + self.cell_states_to_model is None + or self.emb_mode == "cell_and_gene" + ): + gene_cos_sims = pu.quant_cos_sims( + perturbation_emb, + original_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="gene", + ) + + # if there are goal states, the cosine similarities are the cell cosine similarities + if self.cell_states_to_model is not None: + original_cell_emb = pu.mean_nonpadding_embs( + full_original_emb, + torch.tensor(minibatch["length"], device="cuda"), + dim=1, + ) + perturbation_cell_emb = pu.mean_nonpadding_embs( + full_perturbation_emb, + torch.tensor(perturbation_batch["length"], device="cuda"), + dim=1, + ) + cell_cos_sims = pu.quant_cos_sims( + perturbation_cell_emb, + original_cell_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="cell", + ) + + # get cosine similarities in gene embeddings + # if getting gene embeddings, need gene names + if self.emb_mode == "cell_and_gene": + gene_list = minibatch["input_ids"] + # need to truncate gene_list + gene_list = [ + [g for g in genes if g not in self.tokens_to_perturb][ + :n_perturbation_genes + ] + for genes in gene_list + ] + + for cell_i, genes in enumerate(gene_list): + for gene_j, affected_gene in enumerate(genes): + if len(self.genes_to_perturb) > 1: + tokens_to_perturb = tuple(self.tokens_to_perturb) + else: + tokens_to_perturb = self.tokens_to_perturb[0] + + # fill in the gene cosine similarities + try: + stored_gene_embs_dict[ + (tokens_to_perturb, affected_gene) + ].append(gene_cos_sims[cell_i, gene_j].item()) + except KeyError: + stored_gene_embs_dict[ + (tokens_to_perturb, affected_gene) + ] = gene_cos_sims[cell_i, gene_j].item() + else: + gene_list = None + + if self.cell_states_to_model is None: + # calculate the mean of the gene cosine similarities for cell shift + # tensor of nonpadding lengths for each cell + if self.perturb_type == "overexpress": + # subtract number of genes that were overexpressed + # since they are removed before getting cos sims + n_overexpressed = len(self.tokens_to_perturb) + nonpadding_lens = [ + x - n_overexpressed for x in perturbation_batch["length"] + ] + else: + nonpadding_lens = perturbation_batch["length"] + cos_sims_data = pu.mean_nonpadding_embs( + gene_cos_sims, torch.tensor(nonpadding_lens, device="cuda") + ) + cos_sims_dict = self.update_perturbation_dictionary( + cos_sims_dict, + cos_sims_data, + gene_list, + ) + else: + cos_sims_data = cell_cos_sims + for state in cos_sims_dict.keys(): + cos_sims_dict[state] = self.update_perturbation_dictionary( + cos_sims_dict[state], + cos_sims_data[state], + gene_list, + ) + del minibatch + del perturbation_batch + del original_emb + del perturbation_emb + del cos_sims_data + + torch.cuda.empty_cache() + + pu.write_perturbation_dictionary( + cos_sims_dict, + f"{output_path_prefix}_cell_embs_dict_{self.tokens_to_perturb}", + ) + + if self.emb_mode == "cell_and_gene": + pu.write_perturbation_dictionary( + stored_gene_embs_dict, + f"{output_path_prefix}_gene_embs_dict_{self.tokens_to_perturb}", + ) + + def isp_perturb_set_special( + self, + model, + filtered_input_data: Dataset, + layer_to_quant: int, + output_path_prefix: str, + ): + def make_group_perturbation_batch(example): + example_input_ids = example["input_ids"] + example["tokens_to_perturb"] = self.tokens_to_perturb + indices_to_perturb = [ + example_input_ids.index(token) if token in example_input_ids else None + for token in self.tokens_to_perturb + ] + indices_to_perturb = [ + item for item in indices_to_perturb if item is not None + ] + if len(indices_to_perturb) > 0: + example["perturb_index"] = indices_to_perturb + else: + # -100 indicates tokens to overexpress are not present in rank value encoding + example["perturb_index"] = [-100] + if self.perturb_type == "delete": + example = pu.delete_indices(example) + elif self.perturb_type == "overexpress": + example = pu.overexpress_tokens( + example, self.max_len, self.special_token + ) + example["n_overflow"] = pu.calc_n_overflow( + self.max_len, + example["length"], + self.tokens_to_perturb, + indices_to_perturb, + ) + return example + + total_batch_length = len(filtered_input_data) + + + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states(self.cell_states_to_model) + } + + perturbed_data = filtered_input_data.map( + make_group_perturbation_batch, num_proc=self.nproc + ) + + if self.perturb_type == "overexpress": + filtered_input_data = filtered_input_data.add_column( + "n_overflow", perturbed_data["n_overflow"] + ) + filtered_input_data = filtered_input_data.map( + pu.truncate_by_n_overflow_special, num_proc=self.nproc + ) + + if self.emb_mode == "cls_and_gene": + stored_gene_embs_dict = defaultdict(list) + + # iterate through batches + for i in trange(0, total_batch_length, self.forward_batch_size): + max_range = min(i + self.forward_batch_size, total_batch_length) + inds_select = [i for i in range(i, max_range)] + + minibatch = filtered_input_data.select(inds_select) + perturbation_batch = perturbed_data.select(inds_select) + + ##### CLS Embedding Mode ##### + if self.emb_mode == "cls": + indices_to_perturb = perturbation_batch["perturb_index"] + + original_cls_emb = get_embs( + model, + minibatch, + "cls", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + token_gene_dict=self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + perturbation_cls_emb = get_embs( + model, + perturbation_batch, + "cls", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + token_gene_dict=self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + # Calculate the cosine similarities + cls_cos_sims = pu.quant_cos_sims( + perturbation_cls_emb, + original_cls_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="cell", + ) + + # Update perturbation dictionary + if self.cell_states_to_model is None: + cos_sims_dict = self.update_perturbation_dictionary( + cos_sims_dict, + cls_cos_sims, + gene_list=None, + ) + else: + for state in cos_sims_dict.keys(): + cos_sims_dict[state] = self.update_perturbation_dictionary( + cos_sims_dict[state], + cls_cos_sims[state], + gene_list=None, + ) + + ##### CLS and Gene Embedding Mode ##### + elif self.emb_mode == "cls_and_gene": + full_original_emb = get_embs( + model, + minibatch, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + indices_to_perturb = perturbation_batch["perturb_index"] + + # remove indices that were perturbed + original_emb = pu.remove_perturbed_indices_set( + full_original_emb, + self.perturb_type, + indices_to_perturb, + self.tokens_to_perturb, + minibatch["length"], + ) + + full_perturbation_emb = get_embs( + model, + perturbation_batch, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + # remove special tokens and padding + original_emb = original_emb[:, 1:-1, :] + if self.perturb_type == "overexpress": + perturbation_emb = full_perturbation_emb[ + :, 1 + len(self.tokens_to_perturb) : -1, : + ] + elif self.perturb_type == "delete": + perturbation_emb = full_perturbation_emb[ + :, 1 : max(perturbation_batch["length"]) - 1, : + ] + + n_perturbation_genes = perturbation_emb.size()[1] + + # truncate the original embedding as necessary + if self.perturb_type == "overexpress": + def calc_perturbation_length(ids): + if ids == [-100]: + return 0 + else: + return len(ids) + + max_tensor_size = max([length - calc_perturbation_length(ids) - 2 for length, ids in zip(minibatch["length"], indices_to_perturb)]) + + max_n_overflow = max(minibatch["n_overflow"]) + if max_n_overflow > 0 and perturbation_emb.size()[1] < original_emb.size()[1]: + original_emb = original_emb[:, 0 : perturbation_emb.size()[1], :] + elif perturbation_emb.size()[1] < original_emb.size()[1]: + original_emb = original_emb[:, 0:max_tensor_size, :] + + gene_cos_sims = pu.quant_cos_sims( + perturbation_emb, + original_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="gene", + ) + + # get cls emb + original_cls_emb = full_original_emb[:, 0, :] + perturbation_cls_emb = full_perturbation_emb[:, 0, :] + + cls_cos_sims = pu.quant_cos_sims( + perturbation_cls_emb, + original_cls_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="cell", + ) + + # get cosine similarities in gene embeddings + # since getting gene embeddings, need gene names + + gene_list = minibatch["input_ids"] + # need to truncate gene_list + genes_to_exclude = self.tokens_to_perturb + [ + self.cls_token_id, + self.eos_token_id, + ] + gene_list = [ + [g for g in genes if g not in genes_to_exclude][ + :n_perturbation_genes + ] + for genes in gene_list + ] + + for cell_i, genes in enumerate(gene_list): + for gene_j, affected_gene in enumerate(genes): + if len(self.genes_to_perturb) > 1: + tokens_to_perturb = tuple(self.tokens_to_perturb) + else: + tokens_to_perturb = self.tokens_to_perturb[0] + + # fill in the gene cosine similarities + try: + stored_gene_embs_dict[ + (tokens_to_perturb, affected_gene) + ].append(gene_cos_sims[cell_i, gene_j].item()) + except KeyError: + stored_gene_embs_dict[ + (tokens_to_perturb, affected_gene) + ] = gene_cos_sims[cell_i, gene_j].item() + + if self.cell_states_to_model is None: + cos_sims_dict = self.update_perturbation_dictionary( + cos_sims_dict, + cls_cos_sims, + gene_list=None, + ) + else: + for state in cos_sims_dict.keys(): + cos_sims_dict[state] = self.update_perturbation_dictionary( + cos_sims_dict[state], + cls_cos_sims[state], + gene_list=None, + ) + del full_original_emb + del original_emb + del full_perturbation_emb + del perturbation_emb + del gene_cos_sims + + del original_cls_emb + del perturbation_cls_emb + del cls_cos_sims + del minibatch + del perturbation_batch + + torch.cuda.empty_cache() + + pu.write_perturbation_dictionary( + cos_sims_dict, + f"{output_path_prefix}_cell_embs_dict_{self.tokens_to_perturb}", + ) + + if self.emb_mode == "cls_and_gene": + pu.write_perturbation_dictionary( + stored_gene_embs_dict, + f"{output_path_prefix}_gene_embs_dict_{self.tokens_to_perturb}", + ) + + def isp_perturb_all( + self, + model, + filtered_input_data: Dataset, + layer_to_quant: int, + output_path_prefix: str, + ): + pickle_batch = -1 + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states(self.cell_states_to_model) + } + + if self.emb_mode == "cell_and_gene": + stored_gene_embs_dict = defaultdict(list) + + num_inds_perturbed = 1 + self.combos + for h in trange(len(filtered_input_data)): + example_cell = filtered_input_data.select([h]) + full_original_emb = get_embs( + model, + example_cell, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + if self.cell_states_to_model is not None: + original_cell_emb = pu.compute_nonpadded_cell_embedding( + full_original_emb, "mean_pool" + ) + + # gene_list is used to assign cos sims back to genes + gene_list = example_cell["input_ids"][0][:] + # need to remove the anchor gene + if self.anchor_token is not None: + for token in self.anchor_token: + gene_list.remove(token) + # index 0 is not overexpressed so remove + if self.perturb_type == "overexpress": + gene_list = gene_list[num_inds_perturbed:] + # remove perturbed index for gene list dict + perturbed_gene_dict = { + gene: gene_list[:i] + gene_list[i + 1 :] + for i, gene in enumerate(gene_list) + } + + perturbation_batch, indices_to_perturb = pu.make_perturbation_batch( + example_cell, + self.perturb_type, + self.tokens_to_perturb, + self.anchor_token, + self.combos, + self.nproc, + ) + + ispall_total_batch_length = len(perturbation_batch) + for i in trange( + 0, ispall_total_batch_length, self.forward_batch_size, leave=False + ): + ispall_max_range = min( + i + self.forward_batch_size, ispall_total_batch_length + ) + perturbation_minibatch = perturbation_batch.select( + [i for i in range(i, ispall_max_range)] + ) + indices_to_perturb_mini = indices_to_perturb[i:ispall_max_range] + gene_list_mini = gene_list[ + i:ispall_max_range + ] # only perturbed genes from this minibatch + + full_perturbation_emb = get_embs( + model, + perturbation_minibatch, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + del perturbation_minibatch + + # need to remove overexpressed gene to quantify cosine shifts + if self.perturb_type == "overexpress": + perturbation_emb = full_perturbation_emb[:, num_inds_perturbed:, :] + + elif self.perturb_type == "delete": + perturbation_emb = full_perturbation_emb + + if ( + self.cell_states_to_model is None + or self.emb_mode == "cell_and_gene" + ): + original_emb_minibatch = pu.make_comparison_batch( + full_original_emb, indices_to_perturb_mini, perturb_group=False + ) + gene_cos_sims = pu.quant_cos_sims( + perturbation_emb, + original_emb_minibatch, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="gene", + ) + del original_emb_minibatch + + if self.cell_states_to_model is not None: + perturbation_cell_emb = pu.compute_nonpadded_cell_embedding( + full_perturbation_emb, "mean_pool" + ) + + cell_cos_sims = pu.quant_cos_sims( + perturbation_cell_emb, + original_cell_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="cell", + ) + del perturbation_cell_emb + + if self.emb_mode == "cell_and_gene": + for perturbation_i, perturbed_gene in enumerate(gene_list_mini): + for gene_j, affected_gene in enumerate( + perturbed_gene_dict[perturbed_gene] + ): + try: + stored_gene_embs_dict[ + (perturbed_gene, affected_gene) + ].append(gene_cos_sims[perturbation_i, gene_j].item()) + except KeyError: + stored_gene_embs_dict[ + (perturbed_gene, affected_gene) + ] = gene_cos_sims[perturbation_i, gene_j].item() + + del full_perturbation_emb + + if self.cell_states_to_model is None: + cos_sims_data = torch.mean(gene_cos_sims, dim=1) + cos_sims_dict = self.update_perturbation_dictionary( + cos_sims_dict, + cos_sims_data, + gene_list_mini, + ) + else: + cos_sims_data = cell_cos_sims + for state in cos_sims_dict.keys(): + cos_sims_dict[state] = self.update_perturbation_dictionary( + cos_sims_dict[state], + cos_sims_data[state], + gene_list_mini, + ) + + # save dict to disk every self.clear_mem_ncells/10 (default 100) simulated cells + if i % self.clear_mem_ncells / 10 == 0: + pu.write_perturbation_dictionary( + cos_sims_dict, + f"{output_path_prefix}_dict_cell_embs_{h}batch{pickle_batch}", + ) + if self.emb_mode == "cell_and_gene": + pu.write_perturbation_dictionary( + stored_gene_embs_dict, + f"{output_path_prefix}_dict_gene_embs_{h}batch{pickle_batch}", + ) + + # reset and clear memory every self.clear_mem_ncells (default 1000) simulated cells or at the end of the example cell + if i % self.clear_mem_ncells == 0: + pickle_batch += 1 + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states( + self.cell_states_to_model + ) + } + + if self.emb_mode == "cell_and_gene": + stored_gene_embs_dict = defaultdict(list) + + torch.cuda.empty_cache() + + pu.write_perturbation_dictionary( + cos_sims_dict, + f"{output_path_prefix}_dict_cell_embs_{h}batch{pickle_batch}", + ) + + if self.emb_mode == "cell_and_gene": + pu.write_perturbation_dictionary( + stored_gene_embs_dict, + f"{output_path_prefix}_dict_gene_embs_{h}batch{pickle_batch}", + ) + + pickle_batch = -1 + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states(self.cell_states_to_model) + } + + if self.emb_mode == "cell_and_gene": + stored_gene_embs_dict = defaultdict(list) + + # clear memory between cells + del perturbation_batch + del full_original_emb + if self.cell_states_to_model is not None: + del original_cell_emb + torch.cuda.empty_cache() + + def isp_perturb_all_special( + self, + model, + filtered_input_data: Dataset, + layer_to_quant: int, + output_path_prefix: str, + ): + pickle_batch = -1 + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states(self.cell_states_to_model) + } + + if self.emb_mode == "cls_and_gene": + stored_gene_embs_dict = defaultdict(list) + + num_inds_perturbed = 1 + self.combos + for h in trange(len(filtered_input_data)): + example_cell = filtered_input_data.select([h]) + + # get original example cell cls and/or gene embs for comparison + if self.emb_mode == "cls": + original_cls_emb = get_embs( + model, + example_cell, + "cls", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + elif self.emb_mode == "cls_and_gene": + full_original_emb = get_embs( + model, + example_cell, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + original_cls_emb = full_original_emb[:, 0, :].clone().detach() + + # gene_list is used to assign cos sims back to genes + gene_list = example_cell["input_ids"][0][:] + + # need to remove special tokens + for token in [self.cls_token_id, self.eos_token_id]: + gene_list.remove(token) + # need to remove the anchor gene + if self.anchor_token is not None: + for token in self.anchor_token: + gene_list.remove(token) + # index 0 is not overexpressed so remove + if self.perturb_type == "overexpress": + gene_list = gene_list[num_inds_perturbed:] + # remove perturbed index for gene list dict + perturbed_gene_dict = { + gene: gene_list[:i] + gene_list[i + 1 :] + for i, gene in enumerate(gene_list) + } + + perturbation_batch, indices_to_perturb = pu.make_perturbation_batch_special( + example_cell, + self.perturb_type, + self.tokens_to_perturb, + self.anchor_token, + self.combos, + self.nproc, + ) + + ispall_total_batch_length = len(perturbation_batch) + for i in trange( + 0, ispall_total_batch_length, self.forward_batch_size, leave=False + ): + ispall_max_range = min( + i + self.forward_batch_size, ispall_total_batch_length + ) + perturbation_minibatch = perturbation_batch.select( + [i for i in range(i, ispall_max_range)] + ) + indices_to_perturb_mini = indices_to_perturb[i:ispall_max_range] + gene_list_mini = gene_list[ + i:ispall_max_range + ] # only perturbed genes from this minibatch + + ##### CLS Embedding Mode ##### + if self.emb_mode == "cls": + # Extract cls embeddings from perturbed cells + perturbation_cls_emb = get_embs( + model, + perturbation_minibatch, + "cls", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + # Calculate cosine similarities + cls_cos_sims = pu.quant_cos_sims( + perturbation_cls_emb, + original_cls_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="cell", + ) + + if self.cell_states_to_model is None: + cos_sims_dict = self.update_perturbation_dictionary( + cos_sims_dict, + cls_cos_sims, + gene_list_mini, + ) + else: + for state in cos_sims_dict.keys(): + cos_sims_dict[state] = self.update_perturbation_dictionary( + cos_sims_dict[state], + cls_cos_sims[state], + gene_list_mini, + ) + + del perturbation_minibatch + del perturbation_cls_emb + del cls_cos_sims + + ##### CLS and Gene Embedding Mode ##### + elif self.emb_mode == "cls_and_gene": + full_perturbation_emb = get_embs( + model, + perturbation_minibatch, + "gene", + layer_to_quant, + self.pad_token_id, + self.forward_batch_size, + self.token_gene_dict, + summary_stat=None, + silent=True, + ) + + # need to remove overexpressed gene and cls/eos to quantify cosine shifts + if self.perturb_type == "overexpress": + perturbation_emb = ( + full_perturbation_emb[:, 1 + num_inds_perturbed : -1, :] + .clone() + .detach() + ) + elif self.perturb_type == "delete": + perturbation_emb = ( + full_perturbation_emb[:, 1:-1, :].clone().detach() + ) + + original_emb_minibatch = pu.make_comparison_batch( + full_original_emb, indices_to_perturb_mini, perturb_group=False + ) + + original_emb_minibatch = ( + original_emb_minibatch[:, 1:-1, :].clone().detach() + ) + gene_cos_sims = pu.quant_cos_sims( + perturbation_emb, + original_emb_minibatch, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="gene", + ) + + for perturbation_i, perturbed_gene in enumerate(gene_list_mini): + for gene_j, affected_gene in enumerate( + perturbed_gene_dict[perturbed_gene] + ): + try: + stored_gene_embs_dict[ + (perturbed_gene, affected_gene) + ].append(gene_cos_sims[perturbation_i, gene_j].item()) + except KeyError: + stored_gene_embs_dict[ + (perturbed_gene, affected_gene) + ] = gene_cos_sims[perturbation_i, gene_j].item() + + # get cls emb + perturbation_cls_emb = ( + full_perturbation_emb[:, 0, :].clone().detach() + ) + + cls_cos_sims = pu.quant_cos_sims( + perturbation_cls_emb, + original_cls_emb, + self.cell_states_to_model, + self.state_embs_dict, + emb_mode="cell", + ) + + if self.cell_states_to_model is None: + cos_sims_dict = self.update_perturbation_dictionary( + cos_sims_dict, + cls_cos_sims, + gene_list_mini, + ) + else: + for state in cos_sims_dict.keys(): + cos_sims_dict[state] = self.update_perturbation_dictionary( + cos_sims_dict[state], + cls_cos_sims[state], + gene_list_mini, + ) + + del perturbation_minibatch + del original_emb_minibatch + del full_perturbation_emb + del perturbation_emb + del perturbation_cls_emb + del cls_cos_sims + del gene_cos_sims + + # save dict to disk every self.clear_mem_ncells/10 (default 100) simulated cells + if i % max(1, self.clear_mem_ncells / 10) == 0: + pu.write_perturbation_dictionary( + cos_sims_dict, + f"{output_path_prefix}_dict_cell_embs_{h}batch{pickle_batch}", + ) + if self.emb_mode == "cls_and_gene": + pu.write_perturbation_dictionary( + stored_gene_embs_dict, + f"{output_path_prefix}_dict_gene_embs_{h}batch{pickle_batch}", + ) + + # reset and clear memory every self.clear_mem_ncells (default 1000) simulated cells or at the end of the example cell + if i % self.clear_mem_ncells == 0: + pickle_batch += 1 + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states( + self.cell_states_to_model + ) + } + + if self.emb_mode == "cls_and_gene": + stored_gene_embs_dict = defaultdict(list) + + torch.cuda.empty_cache() + + pu.write_perturbation_dictionary( + cos_sims_dict, + f"{output_path_prefix}_dict_cell_embs_{h}batch{pickle_batch}", + ) + + if self.emb_mode == "cls_and_gene": + pu.write_perturbation_dictionary( + stored_gene_embs_dict, + f"{output_path_prefix}_dict_gene_embs_{h}batch{pickle_batch}", + ) + + pickle_batch = -1 + if self.cell_states_to_model is None: + cos_sims_dict = defaultdict(list) + else: + cos_sims_dict = { + state: defaultdict(list) + for state in pu.get_possible_states(self.cell_states_to_model) + } + + if self.emb_mode == "cls_and_gene": + stored_gene_embs_dict = defaultdict(list) + + # clear memory between cells + del perturbation_batch + del original_cls_emb + if self.emb_mode == "cls_and_gene": + del full_original_emb + torch.cuda.empty_cache() + + def update_perturbation_dictionary( + self, + cos_sims_dict: defaultdict, + cos_sims_data: torch.Tensor, + gene_list=None, + ): + if gene_list is not None and cos_sims_data.shape[0] != len(gene_list): + logger.error( + f"len(cos_sims_data.shape[0]) != len(gene_list). \n \ + {cos_sims_data.shape[0]=}.\n \ + {len(gene_list)=}." + ) + raise + + if self.perturb_group is True: + if len(self.tokens_to_perturb) > 1: + perturbed_genes = tuple(self.tokens_to_perturb) + else: + perturbed_genes = self.tokens_to_perturb[0] + + # if cell embeddings, can just append + # shape will be (batch size, 1) + cos_sims_data = torch.squeeze(cos_sims_data).tolist() + + # handle case of single cell left + if not isinstance(cos_sims_data, list): + cos_sims_data = [cos_sims_data] + + cos_sims_dict[(perturbed_genes, "cell_emb")] += cos_sims_data + + else: + for i, cos in enumerate(cos_sims_data.tolist()): + cos_sims_dict[(gene_list[i], "cell_emb")].append(cos) + + return cos_sims_dict diff --git a/geneformer/in_silico_perturber_stats.py b/geneformer/in_silico_perturber_stats.py new file mode 100644 index 0000000000000000000000000000000000000000..9ec98a8caee4e4ca623c5ecc7c18c36210806cce --- /dev/null +++ b/geneformer/in_silico_perturber_stats.py @@ -0,0 +1,1104 @@ +""" +Geneformer in silico perturber stats generator. + +**Usage:** + +.. code-block :: python + + >>> from geneformer import InSilicoPerturberStats + >>> ispstats = InSilicoPerturberStats(mode="goal_state_shift", + ... cell_states_to_model={"state_key": "disease", + ... "start_state": "dcm", + ... "goal_state": "nf", + ... "alt_states": ["hcm", "other1", "other2"]}) + >>> ispstats.get_stats("path/to/input_data", + ... None, + ... "path/to/output_directory", + ... "output_prefix") + +**Description:** + +| Aggregates data or calculates stats for in silico perturbations based on type of statistics specified in InSilicoPerturberStats. +| Input data is raw in silico perturbation results in the form of dictionaries outputted by ``in_silico_perturber``. + +""" + + +import logging +import os +import pickle +import random +from pathlib import Path + +import numpy as np +import pandas as pd +import statsmodels.stats.multitest as smt +from scipy.stats import ranksums +from sklearn.mixture import GaussianMixture +from tqdm.auto import tqdm, trange + +from . import ENSEMBL_DICTIONARY_FILE, TOKEN_DICTIONARY_FILE +from .perturber_utils import flatten_list, validate_cell_states_to_model + +logger = logging.getLogger(__name__) + + +# invert dictionary keys/values +def invert_dict(dictionary): + return {v: k for k, v in dictionary.items()} + + +def read_dict(cos_sims_dict, cell_or_gene_emb, anchor_token): + if cell_or_gene_emb == "cell": + cell_emb_dict = { + k: v for k, v in cos_sims_dict.items() if v and "cell_emb" in k + } + return [cell_emb_dict] + elif cell_or_gene_emb == "gene": + if anchor_token is None: + gene_emb_dict = {k: v for k, v in cos_sims_dict.items() if v} + else: + gene_emb_dict = { + k: v for k, v in cos_sims_dict.items() if v and anchor_token == k[0] + } + return [gene_emb_dict] + + +# read raw dictionary files +def read_dictionaries( + input_data_directory, + cell_or_gene_emb, + anchor_token, + cell_states_to_model, + pickle_suffix, +): + file_found = False + file_path_list = [] + if cell_states_to_model is None: + dict_list = [] + else: + validate_cell_states_to_model(cell_states_to_model) + cell_states_to_model_valid = { + state: value + for state, value in cell_states_to_model.items() + if state != "state_key" + and cell_states_to_model[state] is not None + and cell_states_to_model[state] != [] + } + cell_states_list = [] + # flatten all state values into list + for state in cell_states_to_model_valid: + value = cell_states_to_model_valid[state] + if isinstance(value, list): + cell_states_list += value + else: + cell_states_list.append(value) + state_dict = {state_value: dict() for state_value in cell_states_list} + for file in os.listdir(input_data_directory): + # process only files with given suffix (e.g. "_raw.pickle") + if file.endswith(pickle_suffix): + file_found = True + file_path_list += [f"{input_data_directory}/{file}"] + for file_path in tqdm(file_path_list): + with open(file_path, "rb") as fp: + cos_sims_dict = pickle.load(fp) + if cell_states_to_model is None: + dict_list += read_dict(cos_sims_dict, cell_or_gene_emb, anchor_token) + else: + for state_value in cell_states_list: + new_dict = read_dict( + cos_sims_dict[state_value], cell_or_gene_emb, anchor_token + )[0] + for key in new_dict: + try: + state_dict[state_value][key] += new_dict[key] + except KeyError: + state_dict[state_value][key] = new_dict[key] + + if not file_found: + logger.error( + "No raw data for processing found within provided directory. " + "Please ensure data files end with '{pickle_suffix}'." + ) + raise + if cell_states_to_model is None: + return dict_list + else: + return state_dict + + +# get complete gene list +def get_gene_list(dict_list, mode): + if mode == "cell": + position = 0 + elif mode == "gene": + position = 1 + gene_set = set() + if isinstance(dict_list, list): + for dict_i in dict_list: + gene_set.update([k[position] for k, v in dict_i.items() if v]) + elif isinstance(dict_list, dict): + for state, dict_i in dict_list.items(): + gene_set.update([k[position] for k, v in dict_i.items() if v]) + else: + logger.error( + "dict_list should be a list, or if modeling shift to goal states, a dict. " + f"{type(dict_list)} is not the correct format." + ) + raise + gene_list = list(gene_set) + if mode == "gene": + gene_list.remove("cell_emb") + gene_list.sort() + return gene_list + + +def token_tuple_to_ensembl_ids(token_tuple, gene_token_id_dict): + try: + return tuple([gene_token_id_dict.get(i, np.nan) for i in token_tuple]) + except TypeError: + return gene_token_id_dict.get(token_tuple, np.nan) + + +def n_detections(token, dict_list, mode, anchor_token): + cos_sim_megalist = [] + for dict_i in dict_list: + if mode == "cell": + cos_sim_megalist += dict_i.get((token, "cell_emb"), []) + elif mode == "gene": + cos_sim_megalist += dict_i.get((anchor_token, token), []) + return len(cos_sim_megalist) + + +def get_fdr(pvalues): + return list(smt.multipletests(pvalues, alpha=0.05, method="fdr_bh")[1]) + + +def get_impact_component(test_value, gaussian_mixture_model): + impact_border = gaussian_mixture_model.means_[0][0] + nonimpact_border = gaussian_mixture_model.means_[1][0] + if test_value > nonimpact_border: + impact_component = 0 + elif test_value < impact_border: + impact_component = 1 + else: + impact_component_raw = gaussian_mixture_model.predict([[test_value]])[0] + if impact_component_raw == 1: + impact_component = 0 + elif impact_component_raw == 0: + impact_component = 1 + return impact_component + + +# aggregate data for single perturbation in multiple cells +def isp_aggregate_grouped_perturb(cos_sims_df, dict_list, genes_perturbed): + names = ["Cosine_sim", "Gene"] + cos_sims_full_dfs = [] + if isinstance(genes_perturbed, list): + if len(genes_perturbed) > 1: + gene_ids_df = cos_sims_df.loc[ + np.isin( + [set(idx) for idx in cos_sims_df["Ensembl_ID"]], + set(genes_perturbed), + ), + :, + ] + else: + gene_ids_df = cos_sims_df.loc[ + np.isin(cos_sims_df["Ensembl_ID"], genes_perturbed), : + ] + else: + logger.error( + "aggregate_data is for perturbation of single gene or single group of genes. genes_to_perturb should be formatted as list." + ) + raise + + if gene_ids_df.empty: + logger.error("genes_to_perturb not found in data.") + raise + + tokens = gene_ids_df["Gene"] + symbols = gene_ids_df["Gene_name"] + + for token, symbol in zip(tokens, symbols): + cos_shift_data = [] + for dict_i in dict_list: + cos_shift_data += dict_i.get((token, "cell_emb"), []) + + df = pd.DataFrame(columns=names) + df["Cosine_sim"] = cos_shift_data + df["Gene"] = symbol + cos_sims_full_dfs.append(df) + + return pd.concat(cos_sims_full_dfs) + + +def find(variable, x): + try: + if x in variable: # Test if variable is iterable and contains x + return True + elif x == variable: + return True + except (ValueError, TypeError): + return x == variable # Test if variable is x if non-iterable + + +def isp_aggregate_gene_shifts( + cos_sims_df, dict_list, gene_token_id_dict, gene_id_name_dict, token_dtype +): + cos_shift_data = dict() + for i in trange(cos_sims_df.shape[0]): + token = cos_sims_df["Gene"][i] + for dict_i in dict_list: + if token_dtype == "nontuple": + affected_pairs = [k for k, v in dict_i.items() if k[0] == token] + else: + affected_pairs = [k for k, v in dict_i.items() if find(k[0], token)] + for key in affected_pairs: + if key in cos_shift_data.keys(): + cos_shift_data[key] += dict_i.get(key, []) + else: + cos_shift_data[key] = dict_i.get(key, []) + + cos_data_mean = { + k: [np.mean(v), np.std(v), len(v)] for k, v in cos_shift_data.items() + } + cos_sims_full_df = pd.DataFrame() + cos_sims_full_df["Perturbed"] = [k[0] for k, v in cos_data_mean.items()] + cos_sims_full_df["Gene_name"] = [ + cos_sims_df[cos_sims_df["Gene"] == k[0]]["Gene_name"].item() + for k, v in cos_data_mean.items() + ] + cos_sims_full_df["Ensembl_ID"] = [ + cos_sims_df[cos_sims_df["Gene"] == k[0]]["Ensembl_ID"].item() + for k, v in cos_data_mean.items() + ] + + cos_sims_full_df["Affected"] = [k[1] for k, v in cos_data_mean.items()] + cos_sims_full_df["Affected_gene_name"] = [ + gene_id_name_dict.get(gene_token_id_dict.get(token, np.nan), np.nan) + for token in cos_sims_full_df["Affected"] + ] + cos_sims_full_df["Affected_Ensembl_ID"] = [ + gene_token_id_dict.get(token, np.nan) for token in cos_sims_full_df["Affected"] + ] + cos_sims_full_df["Cosine_sim_mean"] = [v[0] for k, v in cos_data_mean.items()] + cos_sims_full_df["Cosine_sim_stdev"] = [v[1] for k, v in cos_data_mean.items()] + cos_sims_full_df["N_Detections"] = [v[2] for k, v in cos_data_mean.items()] + + specific_val = "cell_emb" + cos_sims_full_df["temp"] = list(cos_sims_full_df["Affected"] == specific_val) + # reorder so cell embs are at the top and all are subordered by magnitude of cosine sim + cos_sims_full_df = cos_sims_full_df.sort_values( + by=(["temp", "Cosine_sim_mean"]), ascending=[False, True] + ).drop("temp", axis=1) + + return cos_sims_full_df + + +# stats comparing cos sim shifts towards goal state of test perturbations vs random perturbations +def isp_stats_to_goal_state( + cos_sims_df, result_dict, cell_states_to_model, genes_perturbed +): + if ( + ("alt_states" not in cell_states_to_model.keys()) + or (len(cell_states_to_model["alt_states"]) == 0) + or (cell_states_to_model["alt_states"] == [None]) + ): + alt_end_state_exists = False + elif (len(cell_states_to_model["alt_states"]) > 0) and ( + cell_states_to_model["alt_states"] != [None] + ): + alt_end_state_exists = True + + # for single perturbation in multiple cells, there are no random perturbations to compare to + if genes_perturbed != "all": + cos_sims_full_df = pd.DataFrame() + + cos_shift_data_end = [] + token = cos_sims_df["Gene"][0] + cos_shift_data_end += result_dict[cell_states_to_model["goal_state"]].get( + (token, "cell_emb"), [] + ) + cos_sims_full_df["Shift_to_goal_end"] = [np.mean(cos_shift_data_end)] + if alt_end_state_exists is True: + for alt_state in cell_states_to_model["alt_states"]: + cos_shift_data_alt_state = [] + cos_shift_data_alt_state += result_dict.get(alt_state).get( + (token, "cell_emb"), [] + ) + cos_sims_full_df[f"Shift_to_alt_end_{alt_state}"] = [ + np.mean(cos_shift_data_alt_state) + ] + + # sort by shift to desired state + cos_sims_full_df = cos_sims_full_df.sort_values( + by=["Shift_to_goal_end"], ascending=[False] + ) + return cos_sims_full_df + + elif genes_perturbed == "all": + goal_end_random_megalist = [] + if alt_end_state_exists is True: + alt_end_state_random_dict = { + alt_state: [] for alt_state in cell_states_to_model["alt_states"] + } + for i in trange(cos_sims_df.shape[0]): + token = cos_sims_df["Gene"][i] + goal_end_random_megalist += result_dict[ + cell_states_to_model["goal_state"] + ].get((token, "cell_emb"), []) + if alt_end_state_exists is True: + for alt_state in cell_states_to_model["alt_states"]: + alt_end_state_random_dict[alt_state] += result_dict[alt_state].get( + (token, "cell_emb"), [] + ) + + # downsample to improve speed of ranksums + if len(goal_end_random_megalist) > 100_000: + random.seed(42) + goal_end_random_megalist = random.sample( + goal_end_random_megalist, k=100_000 + ) + if alt_end_state_exists is True: + for alt_state in cell_states_to_model["alt_states"]: + if len(alt_end_state_random_dict[alt_state]) > 100_000: + random.seed(42) + alt_end_state_random_dict[alt_state] = random.sample( + alt_end_state_random_dict[alt_state], k=100_000 + ) + + names = [ + "Gene", + "Gene_name", + "Ensembl_ID", + "Shift_to_goal_end", + "Goal_end_vs_random_pval", + ] + if alt_end_state_exists is True: + [ + names.append(f"Shift_to_alt_end_{alt_state}") + for alt_state in cell_states_to_model["alt_states"] + ] + names.append(names.pop(names.index("Goal_end_vs_random_pval"))) + [ + names.append(f"Alt_end_vs_random_pval_{alt_state}") + for alt_state in cell_states_to_model["alt_states"] + ] + cos_sims_full_df = pd.DataFrame(columns=names) + + n_detections_dict = dict() + for i in trange(cos_sims_df.shape[0]): + token = cos_sims_df["Gene"][i] + name = cos_sims_df["Gene_name"][i] + ensembl_id = cos_sims_df["Ensembl_ID"][i] + goal_end_cos_sim_megalist = result_dict[ + cell_states_to_model["goal_state"] + ].get((token, "cell_emb"), []) + n_detections_dict[token] = len(goal_end_cos_sim_megalist) + mean_goal_end = np.mean(goal_end_cos_sim_megalist) + pval_goal_end = ranksums( + goal_end_random_megalist, goal_end_cos_sim_megalist + ).pvalue + + if alt_end_state_exists is True: + alt_end_state_dict = { + alt_state: [] for alt_state in cell_states_to_model["alt_states"] + } + for alt_state in cell_states_to_model["alt_states"]: + alt_end_state_dict[alt_state] = result_dict[alt_state].get( + (token, "cell_emb"), [] + ) + alt_end_state_dict[f"{alt_state}_mean"] = np.mean( + alt_end_state_dict[alt_state] + ) + alt_end_state_dict[f"{alt_state}_pval"] = ranksums( + alt_end_state_random_dict[alt_state], + alt_end_state_dict[alt_state], + ).pvalue + + results_dict = dict() + results_dict["Gene"] = token + results_dict["Gene_name"] = name + results_dict["Ensembl_ID"] = ensembl_id + results_dict["Shift_to_goal_end"] = mean_goal_end + results_dict["Goal_end_vs_random_pval"] = pval_goal_end + if alt_end_state_exists is True: + for alt_state in cell_states_to_model["alt_states"]: + results_dict[f"Shift_to_alt_end_{alt_state}"] = alt_end_state_dict[ + f"{alt_state}_mean" + ] + results_dict[ + f"Alt_end_vs_random_pval_{alt_state}" + ] = alt_end_state_dict[f"{alt_state}_pval"] + + cos_sims_df_i = pd.DataFrame(results_dict, index=[i]) + cos_sims_full_df = pd.concat([cos_sims_full_df, cos_sims_df_i]) + + cos_sims_full_df["Goal_end_FDR"] = get_fdr( + list(cos_sims_full_df["Goal_end_vs_random_pval"]) + ) + if alt_end_state_exists is True: + for alt_state in cell_states_to_model["alt_states"]: + cos_sims_full_df[f"Alt_end_FDR_{alt_state}"] = get_fdr( + list(cos_sims_full_df[f"Alt_end_vs_random_pval_{alt_state}"]) + ) + + # quantify number of detections of each gene + cos_sims_full_df["N_Detections"] = [ + n_detections_dict[token] for token in cos_sims_full_df["Gene"] + ] + + # sort by shift to desired state + cos_sims_full_df["Sig"] = [ + 1 if fdr < 0.05 else 0 for fdr in cos_sims_full_df["Goal_end_FDR"] + ] + cos_sims_full_df = cos_sims_full_df.sort_values( + by=["Sig", "Shift_to_goal_end", "Goal_end_FDR"], + ascending=[False, False, True], + ) + + return cos_sims_full_df + + +# stats comparing cos sim shifts of test perturbations vs null distribution +def isp_stats_vs_null(cos_sims_df, dict_list, null_dict_list): + cos_sims_full_df = cos_sims_df.copy() + + cos_sims_full_df["Test_avg_shift"] = np.zeros(cos_sims_df.shape[0], dtype=float) + cos_sims_full_df["Null_avg_shift"] = np.zeros(cos_sims_df.shape[0], dtype=float) + cos_sims_full_df["Test_vs_null_avg_shift"] = np.zeros( + cos_sims_df.shape[0], dtype=float + ) + cos_sims_full_df["Test_vs_null_pval"] = np.zeros(cos_sims_df.shape[0], dtype=float) + cos_sims_full_df["Test_vs_null_FDR"] = np.zeros(cos_sims_df.shape[0], dtype=float) + cos_sims_full_df["N_Detections_test"] = np.zeros( + cos_sims_df.shape[0], dtype="uint32" + ) + cos_sims_full_df["N_Detections_null"] = np.zeros( + cos_sims_df.shape[0], dtype="uint32" + ) + + for i in trange(cos_sims_df.shape[0]): + token = cos_sims_df["Gene"][i] + test_shifts = [] + null_shifts = [] + + for dict_i in dict_list: + test_shifts += dict_i.get((token, "cell_emb"), []) + + for dict_i in null_dict_list: + null_shifts += dict_i.get((token, "cell_emb"), []) + + cos_sims_full_df.loc[i, "Test_avg_shift"] = np.mean(test_shifts) + cos_sims_full_df.loc[i, "Null_avg_shift"] = np.mean(null_shifts) + cos_sims_full_df.loc[i, "Test_vs_null_avg_shift"] = np.mean( + test_shifts + ) - np.mean(null_shifts) + cos_sims_full_df.loc[i, "Test_vs_null_pval"] = ranksums( + test_shifts, null_shifts, nan_policy="omit" + ).pvalue + # remove nan values + cos_sims_full_df.Test_vs_null_pval = np.where( + np.isnan(cos_sims_full_df.Test_vs_null_pval), + 1, + cos_sims_full_df.Test_vs_null_pval, + ) + cos_sims_full_df.loc[i, "N_Detections_test"] = len(test_shifts) + cos_sims_full_df.loc[i, "N_Detections_null"] = len(null_shifts) + + cos_sims_full_df["Test_vs_null_FDR"] = get_fdr( + cos_sims_full_df["Test_vs_null_pval"] + ) + + cos_sims_full_df["Sig"] = [ + 1 if fdr < 0.05 else 0 for fdr in cos_sims_full_df["Test_vs_null_FDR"] + ] + cos_sims_full_df = cos_sims_full_df.sort_values( + by=["Sig", "Test_vs_null_avg_shift", "Test_vs_null_FDR"], + ascending=[False, False, True], + ) + return cos_sims_full_df + + +# stats for identifying perturbations with largest effect within a given set of cells +# fits a mixture model to 2 components (impact vs. non-impact) and +# reports the most likely component for each test perturbation +# Note: because assumes given perturbation has a consistent effect in the cells tested, +# we recommend only using the mixture model strategy with uniform cell populations +def isp_stats_mixture_model(cos_sims_df, dict_list, combos, anchor_token): + names = ["Gene", "Gene_name", "Ensembl_ID"] + + if combos == 0: + names += ["Test_avg_shift"] + elif combos == 1: + names += [ + "Anchor_shift", + "Test_token_shift", + "Sum_of_indiv_shifts", + "Combo_shift", + "Combo_minus_sum_shift", + ] + + names += ["Impact_component", "Impact_component_percent"] + + cos_sims_full_df = pd.DataFrame(columns=names) + avg_values = [] + gene_names = [] + + for i in trange(cos_sims_df.shape[0]): + token = cos_sims_df["Gene"][i] + name = cos_sims_df["Gene_name"][i] + ensembl_id = cos_sims_df["Ensembl_ID"][i] + cos_shift_data = [] + + for dict_i in dict_list: + if (combos == 0) and (anchor_token is not None): + cos_shift_data += dict_i.get((anchor_token, token), []) + else: + cos_shift_data += dict_i.get((token, "cell_emb"), []) + + # Extract values for current gene + if combos == 0: + test_values = cos_shift_data + elif combos == 1: + test_values = [] + for tup in cos_shift_data: + test_values.append(tup[2]) + + if len(test_values) > 0: + avg_value = np.mean(test_values) + avg_values.append(avg_value) + gene_names.append(name) + + # fit Gaussian mixture model to dataset of mean for each gene + avg_values_to_fit = np.array(avg_values).reshape(-1, 1) + gm = GaussianMixture(n_components=2, random_state=0).fit(avg_values_to_fit) + + for i in trange(cos_sims_df.shape[0]): + token = cos_sims_df["Gene"][i] + name = cos_sims_df["Gene_name"][i] + ensembl_id = cos_sims_df["Ensembl_ID"][i] + cos_shift_data = [] + + for dict_i in dict_list: + if (combos == 0) and (anchor_token is not None): + cos_shift_data += dict_i.get((anchor_token, token), []) + else: + cos_shift_data += dict_i.get((token, "cell_emb"), []) + + if combos == 0: + mean_test = np.mean(cos_shift_data) + impact_components = [ + get_impact_component(value, gm) for value in cos_shift_data + ] + elif combos == 1: + anchor_cos_sim_megalist = [ + anchor for anchor, token, combo in cos_shift_data + ] + token_cos_sim_megalist = [token for anchor, token, combo in cos_shift_data] + anchor_plus_token_cos_sim_megalist = [ + 1 - ((1 - anchor) + (1 - token)) + for anchor, token, combo in cos_shift_data + ] + combo_anchor_token_cos_sim_megalist = [ + combo for anchor, token, combo in cos_shift_data + ] + combo_minus_sum_cos_sim_megalist = [ + combo - (1 - ((1 - anchor) + (1 - token))) + for anchor, token, combo in cos_shift_data + ] + + mean_anchor = np.mean(anchor_cos_sim_megalist) + mean_token = np.mean(token_cos_sim_megalist) + mean_sum = np.mean(anchor_plus_token_cos_sim_megalist) + mean_test = np.mean(combo_anchor_token_cos_sim_megalist) + mean_combo_minus_sum = np.mean(combo_minus_sum_cos_sim_megalist) + + impact_components = [ + get_impact_component(value, gm) + for value in combo_anchor_token_cos_sim_megalist + ] + + impact_component = get_impact_component(mean_test, gm) + impact_component_percent = np.mean(impact_components) * 100 + + data_i = [token, name, ensembl_id] + if combos == 0: + data_i += [mean_test] + elif combos == 1: + data_i += [ + mean_anchor, + mean_token, + mean_sum, + mean_test, + mean_combo_minus_sum, + ] + data_i += [impact_component, impact_component_percent] + + cos_sims_df_i = pd.DataFrame(dict(zip(names, data_i)), index=[i]) + cos_sims_full_df = pd.concat([cos_sims_full_df, cos_sims_df_i]) + + # quantify number of detections of each gene + if anchor_token is None: + cos_sims_full_df["N_Detections"] = [ + n_detections(i, dict_list, "cell", anchor_token) + for i in cos_sims_full_df["Gene"] + ] + else: + cos_sims_full_df["N_Detections"] = [ + n_detections(i, dict_list, "gene", anchor_token) + for i in cos_sims_full_df["Gene"] + ] + + if combos == 0: + cos_sims_full_df = cos_sims_full_df.sort_values( + by=["Impact_component", "Test_avg_shift"], ascending=[False, True] + ) + elif combos == 1: + cos_sims_full_df = cos_sims_full_df.sort_values( + by=["Impact_component", "Combo_minus_sum_shift"], ascending=[False, True] + ) + return cos_sims_full_df + + +class InSilicoPerturberStats: + valid_option_dict = { + "mode": { + "goal_state_shift", + "vs_null", + "mixture_model", + "aggregate_data", + "aggregate_gene_shifts", + }, + "genes_perturbed": {"all", list}, + "combos": {0, 1}, + "anchor_gene": {None, str}, + "cell_states_to_model": {None, dict}, + "pickle_suffix": {None, str}, + } + + def __init__( + self, + mode="mixture_model", + genes_perturbed="all", + combos=0, + anchor_gene=None, + cell_states_to_model=None, + pickle_suffix="_raw.pickle", + token_dictionary_file=TOKEN_DICTIONARY_FILE, + gene_name_id_dictionary_file=ENSEMBL_DICTIONARY_FILE, + ): + """ + Initialize in silico perturber stats generator. + + **Parameters:** + + mode : {"goal_state_shift", "vs_null", "mixture_model", "aggregate_data", "aggregate_gene_shifts"} + | Type of stats. + | "goal_state_shift": perturbation vs. random for desired cell state shift + | "vs_null": perturbation vs. null from provided null distribution dataset + | "mixture_model": perturbation in impact vs. no impact component of mixture model (no goal direction) + | "aggregate_data": aggregates cosine shifts for single perturbation in multiple cells + | "aggregate_gene_shifts": aggregates cosine shifts of genes in response to perturbation(s) + genes_perturbed : "all", list + | Genes perturbed in isp experiment. + | Default is assuming genes_to_perturb in isp experiment was "all" (each gene in each cell). + | Otherwise, may provide a list of ENSEMBL IDs of genes perturbed as a group all together. + combos : {0,1,2} + | Whether genex perturbed in isp experiment were perturbed individually (0), in pairs (1), or in triplets (2). + anchor_gene : None, str + | ENSEMBL ID of gene to use as anchor in combination perturbations or in testing effect on downstream genes. + | For example, if combos=1 and anchor_gene="ENSG00000136574": + | analyzes data for anchor gene perturbed in combination with each other gene. + | However, if combos=0 and anchor_gene="ENSG00000136574": + | analyzes data for the effect of anchor gene's perturbation on the embedding of each other gene. + cell_states_to_model: None, dict + | Cell states to model if testing perturbations that achieve goal state change. + | Four-item dictionary with keys: state_key, start_state, goal_state, and alt_states + | state_key: key specifying name of column in .dataset that defines the start/goal states + | start_state: value in the state_key column that specifies the start state + | goal_state: value in the state_key column taht specifies the goal end state + | alt_states: list of values in the state_key column that specify the alternate end states + | For example: {"state_key": "disease", + | "start_state": "dcm", + | "goal_state": "nf", + | "alt_states": ["hcm", "other1", "other2"]} + token_dictionary_file : Path + | Path to pickle file containing token dictionary (Ensembl ID:token). + gene_name_id_dictionary_file : Path + | Path to pickle file containing gene name to ID dictionary (gene name:Ensembl ID). + """ + + self.mode = mode + self.genes_perturbed = genes_perturbed + self.combos = combos + self.anchor_gene = anchor_gene + self.cell_states_to_model = cell_states_to_model + self.pickle_suffix = pickle_suffix + + self.validate_options() + + # load token dictionary (Ensembl IDs:token) + with open(token_dictionary_file, "rb") as f: + self.gene_token_dict = pickle.load(f) + + # load gene name dictionary (gene name:Ensembl ID) + with open(gene_name_id_dictionary_file, "rb") as f: + self.gene_name_id_dict = pickle.load(f) + + if anchor_gene is None: + self.anchor_token = None + else: + self.anchor_token = self.gene_token_dict[self.anchor_gene] + + def validate_options(self): + for attr_name, valid_options in self.valid_option_dict.items(): + attr_value = self.__dict__[attr_name] + if type(attr_value) not in {list, dict}: + if attr_name in {"anchor_gene"}: + continue + elif attr_value in valid_options: + continue + valid_type = False + for option in valid_options: + if (option in [str, int, list, dict]) and isinstance( + attr_value, option + ): + valid_type = True + break + if not valid_type: + logger.error( + f"Invalid option for {attr_name}. " + f"Valid options for {attr_name}: {valid_options}" + ) + raise + + if self.cell_states_to_model is not None: + if len(self.cell_states_to_model.items()) == 1: + logger.warning( + "The single value dictionary for cell_states_to_model will be " + "replaced with a dictionary with named keys for start, goal, and alternate states. " + "Please specify state_key, start_state, goal_state, and alt_states " + "in the cell_states_to_model dictionary for future use. " + "For example, cell_states_to_model={" + "'state_key': 'disease', " + "'start_state': 'dcm', " + "'goal_state': 'nf', " + "'alt_states': ['hcm', 'other1', 'other2']}" + ) + for key, value in self.cell_states_to_model.items(): + if (len(value) == 3) and isinstance(value, tuple): + if ( + isinstance(value[0], list) + and isinstance(value[1], list) + and isinstance(value[2], list) + ): + if len(value[0]) == 1 and len(value[1]) == 1: + all_values = value[0] + value[1] + value[2] + if len(all_values) == len(set(all_values)): + continue + # reformat to the new named key format + state_values = flatten_list(list(self.cell_states_to_model.values())) + self.cell_states_to_model = { + "state_key": list(self.cell_states_to_model.keys())[0], + "start_state": state_values[0][0], + "goal_state": state_values[1][0], + "alt_states": state_values[2:][0], + } + elif set(self.cell_states_to_model.keys()) == { + "state_key", + "start_state", + "goal_state", + "alt_states", + }: + if ( + (self.cell_states_to_model["state_key"] is None) + or (self.cell_states_to_model["start_state"] is None) + or (self.cell_states_to_model["goal_state"] is None) + ): + logger.error( + "Please specify 'state_key', 'start_state', and 'goal_state' in cell_states_to_model." + ) + raise + + if ( + self.cell_states_to_model["start_state"] + == self.cell_states_to_model["goal_state"] + ): + logger.error("All states must be unique.") + raise + + if self.cell_states_to_model["alt_states"] is not None: + if not isinstance(self.cell_states_to_model["alt_states"], list): + logger.error( + "self.cell_states_to_model['alt_states'] must be a list (even if it is one element)." + ) + raise + if len(self.cell_states_to_model["alt_states"]) != len( + set(self.cell_states_to_model["alt_states"]) + ): + logger.error("All states must be unique.") + raise + + elif set(self.cell_states_to_model.keys()) == { + "state_key", + "start_state", + "goal_state", + }: + self.cell_states_to_model["alt_states"] = [] + else: + logger.error( + "cell_states_to_model must only have the following four keys: " + "'state_key', 'start_state', 'goal_state', 'alt_states'." + "For example, cell_states_to_model={" + "'state_key': 'disease', " + "'start_state': 'dcm', " + "'goal_state': 'nf', " + "'alt_states': ['hcm', 'other1', 'other2']}" + ) + raise + + if self.anchor_gene is not None: + self.anchor_gene = None + logger.warning( + "anchor_gene set to None. " + "Currently, anchor gene not available " + "when modeling multiple cell states." + ) + + if self.combos > 0: + if self.anchor_gene is None: + logger.error( + "Currently, stats are only supported for combination " + "in silico perturbation run with anchor gene. Please add " + "anchor gene when using with combos > 0. " + ) + raise + + if (self.mode == "mixture_model") and (self.genes_perturbed != "all"): + logger.error( + "Mixture model mode requires multiple gene perturbations to fit model " + "so is incompatible with a single grouped perturbation." + ) + raise + if (self.mode == "aggregate_data") and (self.genes_perturbed == "all"): + logger.error( + "Simple data aggregation mode is for single perturbation in multiple cells " + "so is incompatible with a genes_perturbed being 'all'." + ) + raise + + def get_stats( + self, + input_data_directory, + null_dist_data_directory, + output_directory, + output_prefix, + null_dict_list=None, + ): + """ + Get stats for in silico perturbation data and save as results in output_directory. + + **Parameters:** + + input_data_directory : Path + | Path to directory containing cos_sim dictionary inputs + null_dist_data_directory : Path + | Path to directory containing null distribution cos_sim dictionary inputs + output_directory : Path + | Path to directory where perturbation data will be saved as .csv + output_prefix : str + | Prefix for output .csv + null_dict_list: list[dict] + | List of loaded null distribution dictionary if more than one comparison vs. the null is to be performed + + **Outputs:** + + Definition of possible columns in .csv output file. + + | Of note, not all columns will be present in all output files. + | Some columns are specific to particular perturbation modes. + + | "Gene": gene token + | "Gene_name": gene name + | "Ensembl_ID": gene Ensembl ID + | "N_Detections": number of cells in which each gene or gene combination was detected in the input dataset + | "Sig": 1 if FDR<0.05, otherwise 0 + + | "Shift_to_goal_end": cosine shift from start state towards goal end state in response to given perturbation + | "Shift_to_alt_end": cosine shift from start state towards alternate end state in response to given perturbation + | "Goal_end_vs_random_pval": pvalue of cosine shift from start state towards goal end state by Wilcoxon + | pvalue compares shift caused by perturbing given gene compared to random genes + | "Alt_end_vs_random_pval": pvalue of cosine shift from start state towards alternate end state by Wilcoxon + | pvalue compares shift caused by perturbing given gene compared to random genes + | "Goal_end_FDR": Benjamini-Hochberg correction of "Goal_end_vs_random_pval" + | "Alt_end_FDR": Benjamini-Hochberg correction of "Alt_end_vs_random_pval" + + | "Test_avg_shift": cosine shift in response to given perturbation in cells from test distribution + | "Null_avg_shift": cosine shift in response to given perturbation in cells from null distribution (e.g. random cells) + | "Test_vs_null_avg_shift": difference in cosine shift in cells from test vs. null distribution + | (i.e. "Test_avg_shift" minus "Null_avg_shift") + | "Test_vs_null_pval": pvalue of cosine shift in test vs. null distribution + | "Test_vs_null_FDR": Benjamini-Hochberg correction of "Test_vs_null_pval" + | "N_Detections_test": "N_Detections" in cells from test distribution + | "N_Detections_null": "N_Detections" in cells from null distribution + + | "Anchor_shift": cosine shift in response to given perturbation of anchor gene + | "Test_token_shift": cosine shift in response to given perturbation of test gene + | "Sum_of_indiv_shifts": sum of cosine shifts in response to individually perturbing test and anchor genes + | "Combo_shift": cosine shift in response to given perturbation of both anchor and test gene(s) in combination + | "Combo_minus_sum_shift": difference of cosine shifts in response combo perturbation vs. sum of individual perturbations + | (i.e. "Combo_shift" minus "Sum_of_indiv_shifts") + | "Impact_component": whether the given perturbation was modeled to be within the impact component by the mixture model + | 1: within impact component; 0: not within impact component + | "Impact_component_percent": percent of cells in which given perturbation was modeled to be within impact component + + | In case of aggregating data / gene shifts: + | "Perturbed": ID(s) of gene(s) being perturbed + | "Affected": ID of affected gene or "cell_emb" indicating the impact on the cell embedding as a whole + | "Cosine_sim_mean": mean of cosine similarity of cell or affected gene in original vs. perturbed + | "Cosine_sim_stdev": standard deviation of cosine similarity of cell or affected gene in original vs. perturbed + """ + + if self.mode not in [ + "goal_state_shift", + "vs_null", + "mixture_model", + "aggregate_data", + "aggregate_gene_shifts", + ]: + logger.error( + "Currently, only modes available are stats for goal_state_shift, " + "vs_null (comparing to null distribution), " + "mixture_model (fitting mixture model for perturbations with or without impact), " + "and aggregating data for single perturbations or for gene embedding shifts." + ) + raise + + self.gene_token_id_dict = invert_dict(self.gene_token_dict) + self.gene_id_name_dict = invert_dict(self.gene_name_id_dict) + + # obtain total gene list + if (self.combos == 0) and (self.anchor_token is not None): + # cos sim data for effect of gene perturbation on the embedding of each other gene + dict_list = read_dictionaries( + input_data_directory, + "gene", + self.anchor_token, + self.cell_states_to_model, + self.pickle_suffix, + ) + gene_list = get_gene_list(dict_list, "gene") + elif ( + (self.combos == 0) + and (self.anchor_token is None) + and (self.mode == "aggregate_gene_shifts") + ): + dict_list = read_dictionaries( + input_data_directory, + "gene", + self.anchor_token, + self.cell_states_to_model, + self.pickle_suffix, + ) + gene_list = get_gene_list(dict_list, "cell") + else: + # cos sim data for effect of gene perturbation on the embedding of each cell + dict_list = read_dictionaries( + input_data_directory, + "cell", + self.anchor_token, + self.cell_states_to_model, + self.pickle_suffix, + ) + gene_list = get_gene_list(dict_list, "cell") + + # initiate results dataframe + cos_sims_df_initial = pd.DataFrame( + { + "Gene": gene_list, + "Gene_name": [self.token_to_gene_name(item) for item in gene_list], + "Ensembl_ID": [ + token_tuple_to_ensembl_ids(genes, self.gene_token_id_dict) + if self.genes_perturbed != "all" + else self.gene_token_id_dict[genes[1]] + if isinstance(genes, tuple) + else self.gene_token_id_dict[genes] + for genes in gene_list + ], + }, + index=[i for i in range(len(gene_list))], + ) + + if self.mode == "goal_state_shift": + cos_sims_df = isp_stats_to_goal_state( + cos_sims_df_initial, + dict_list, + self.cell_states_to_model, + self.genes_perturbed, + ) + + elif self.mode == "vs_null": + if null_dict_list is None: + null_dict_list = read_dictionaries( + null_dist_data_directory, + "cell", + self.anchor_token, + self.cell_states_to_model, + self.pickle_suffix, + ) + cos_sims_df = isp_stats_vs_null( + cos_sims_df_initial, dict_list, null_dict_list + ) + + elif self.mode == "mixture_model": + cos_sims_df = isp_stats_mixture_model( + cos_sims_df_initial, dict_list, self.combos, self.anchor_token + ) + + elif self.mode == "aggregate_data": + cos_sims_df = isp_aggregate_grouped_perturb( + cos_sims_df_initial, dict_list, self.genes_perturbed + ) + + elif self.mode == "aggregate_gene_shifts": + if (self.genes_perturbed == "all") and (self.combos == 0): + tuple_types = [ + True if isinstance(genes, tuple) else False for genes in gene_list + ] + if all(tuple_types): + token_dtype = "tuple" + elif not any(tuple_types): + token_dtype = "nontuple" + else: + token_dtype = "mix" + else: + token_dtype = "mix" + + cos_sims_df = isp_aggregate_gene_shifts( + cos_sims_df_initial, + dict_list, + self.gene_token_id_dict, + self.gene_id_name_dict, + token_dtype, + ) + + # save perturbation stats to output_path + output_path = (Path(output_directory) / output_prefix).with_suffix(".csv") + cos_sims_df.to_csv(output_path) + + def token_to_gene_name(self, item): + if np.issubdtype(type(item), np.integer): + return self.gene_id_name_dict.get( + self.gene_token_id_dict.get(item, np.nan), np.nan + ) + if isinstance(item, tuple): + return tuple( + [ + self.gene_id_name_dict.get( + self.gene_token_id_dict.get(i, np.nan), np.nan + ) + for i in item + ] + ) diff --git a/geneformer/mtl/__init__.py b/geneformer/mtl/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..06788a56ac11397d1698a74381d466b7b7bd98b7 --- /dev/null +++ b/geneformer/mtl/__init__.py @@ -0,0 +1 @@ +# ruff: noqa: F401 \ No newline at end of file diff --git a/geneformer/mtl/collators.py b/geneformer/mtl/collators.py new file mode 100644 index 0000000000000000000000000000000000000000..63546f93a05c857781198be88de027f5fb9e827f --- /dev/null +++ b/geneformer/mtl/collators.py @@ -0,0 +1,76 @@ +# imports +import torch +import pickle +from ..collator_for_classification import DataCollatorForGeneClassification +from .. import TOKEN_DICTIONARY_FILE + +"""Geneformer collator for multi-task cell classification.""" + +class DataCollatorForMultitaskCellClassification(DataCollatorForGeneClassification): + class_type = "cell" + + @staticmethod + def load_token_dictionary(): + with open(TOKEN_DICTIONARY_FILE, 'rb') as f: + return pickle.load(f) + + def __init__(self, *args, **kwargs) -> None: + # Load the token dictionary + token_dictionary = self.load_token_dictionary() + # Use the loaded token dictionary + super().__init__(token_dictionary=token_dictionary, *args, **kwargs) + + def _prepare_batch(self, features): + # Process inputs as usual + batch = self.tokenizer.pad( + features, + class_type=self.class_type, + padding=self.padding, + max_length=self.max_length, + pad_to_multiple_of=self.pad_to_multiple_of, + return_tensors="pt", + ) + + # Check if labels are present + if "label" in features[0]: + # Initialize labels dictionary for all tasks + labels = {task: [] for task in features[0]["label"].keys()} + # Populate labels for each task + for feature in features: + for task, label in feature["label"].items(): + labels[task].append(label) + + # Convert label lists to tensors, handling dictionaries appropriately + for task in labels: + if isinstance(labels[task][0], (list, torch.Tensor)): + dtype = torch.long + labels[task] = torch.tensor(labels[task], dtype=dtype) + elif isinstance(labels[task][0], dict): + # Handle dict specifically if needed + pass # Resolve nested data structure + + # Update the batch to include task-specific labels + batch["labels"] = labels + else: + # If no labels are present, create empty labels for all tasks + batch["labels"] = { + task: torch.tensor([], dtype=torch.long) + for task in features[0]["input_ids"].keys() + } + + return batch + + def __call__(self, features): + batch = self._prepare_batch(features) + for k, v in batch.items(): + if torch.is_tensor(v): + batch[k] = v.clone().detach() + elif isinstance(v, dict): + # Assuming nested structure needs conversion + batch[k] = { + task: torch.tensor(labels, dtype=torch.int64) + for task, labels in v.items() + } + else: + batch[k] = torch.tensor(v, dtype=torch.int64) + return batch \ No newline at end of file diff --git a/geneformer/mtl/data.py b/geneformer/mtl/data.py new file mode 100644 index 0000000000000000000000000000000000000000..402ca952b5357932a6ff7cb9f5d0ec21551d44b8 --- /dev/null +++ b/geneformer/mtl/data.py @@ -0,0 +1,162 @@ +import os +from .collators import DataCollatorForMultitaskCellClassification +from .imports import * + +def validate_columns(dataset, required_columns, dataset_type): + """Ensures required columns are present in the dataset.""" + missing_columns = [col for col in required_columns if col not in dataset.column_names] + if missing_columns: + raise KeyError( + f"Missing columns in {dataset_type} dataset: {missing_columns}. " + f"Available columns: {dataset.column_names}" + ) + + +def create_label_mappings(dataset, task_to_column): + """Creates label mappings for the dataset.""" + task_label_mappings = {} + num_labels_list = [] + for task, column in task_to_column.items(): + unique_values = sorted(set(dataset[column])) + mapping = {label: idx for idx, label in enumerate(unique_values)} + task_label_mappings[task] = mapping + num_labels_list.append(len(unique_values)) + return task_label_mappings, num_labels_list + + +def save_label_mappings(mappings, path): + """Saves label mappings to a pickle file.""" + with open(path, "wb") as f: + pickle.dump(mappings, f) + + +def load_label_mappings(path): + """Loads label mappings from a pickle file.""" + with open(path, "rb") as f: + return pickle.load(f) + + +def transform_dataset(dataset, task_to_column, task_label_mappings, config, is_test): + """Transforms the dataset to the required format.""" + transformed_dataset = [] + cell_id_mapping = {} + + for idx, record in enumerate(dataset): + transformed_record = { + "input_ids": torch.tensor(record["input_ids"], dtype=torch.long), + "cell_id": idx, # Index-based cell ID + } + + if not is_test: + label_dict = { + task: task_label_mappings[task][record[column]] + for task, column in task_to_column.items() + } + else: + label_dict = {task: -1 for task in config["task_names"]} + + transformed_record["label"] = label_dict + transformed_dataset.append(transformed_record) + cell_id_mapping[idx] = record.get("unique_cell_id", idx) + + return transformed_dataset, cell_id_mapping + + +def load_and_preprocess_data(dataset_path, config, is_test=False, dataset_type=""): + """Main function to load and preprocess data.""" + try: + dataset = load_from_disk(dataset_path) + + # Setup task and column mappings + task_names = [f"task{i+1}" for i in range(len(config["task_columns"]))] + task_to_column = dict(zip(task_names, config["task_columns"])) + config["task_names"] = task_names + + label_mappings_path = os.path.join( + config["results_dir"], + f"task_label_mappings{'_val' if dataset_type == 'validation' else ''}.pkl" + ) + + if not is_test: + validate_columns(dataset, task_to_column.values(), dataset_type) + + # Create and save label mappings + task_label_mappings, num_labels_list = create_label_mappings(dataset, task_to_column) + save_label_mappings(task_label_mappings, label_mappings_path) + else: + # Load existing mappings for test data + task_label_mappings = load_label_mappings(label_mappings_path) + num_labels_list = [len(mapping) for mapping in task_label_mappings.values()] + + # Transform dataset + transformed_dataset, cell_id_mapping = transform_dataset( + dataset, task_to_column, task_label_mappings, config, is_test + ) + + return transformed_dataset, cell_id_mapping, num_labels_list + + except KeyError as e: + raise ValueError(f"Configuration error or dataset key missing: {e}") + except Exception as e: + raise RuntimeError(f"Error during data loading or preprocessing: {e}") + + +def preload_and_process_data(config): + """Preloads and preprocesses train and validation datasets.""" + # Process train data and save mappings + train_data = load_and_preprocess_data(config["train_path"], config, dataset_type="train") + + # Process validation data and save mappings + val_data = load_and_preprocess_data(config["val_path"], config, dataset_type="validation") + + # Validate that the mappings match + validate_label_mappings(config) + + return (*train_data, *val_data[:2]) # Return train and val data along with mappings + + +def validate_label_mappings(config): + """Ensures train and validation label mappings are consistent.""" + train_mappings_path = os.path.join(config["results_dir"], "task_label_mappings.pkl") + val_mappings_path = os.path.join(config["results_dir"], "task_label_mappings_val.pkl") + train_mappings = load_label_mappings(train_mappings_path) + val_mappings = load_label_mappings(val_mappings_path) + + for task_name in config["task_names"]: + if train_mappings[task_name] != val_mappings[task_name]: + raise ValueError( + f"Mismatch in label mappings for task '{task_name}'.\n" + f"Train Mapping: {train_mappings[task_name]}\n" + f"Validation Mapping: {val_mappings[task_name]}" + ) + + +def get_data_loader(preprocessed_dataset, batch_size): + """Creates a DataLoader with optimal settings.""" + return DataLoader( + preprocessed_dataset, + batch_size=batch_size, + shuffle=True, + collate_fn=DataCollatorForMultitaskCellClassification(), + num_workers=os.cpu_count(), + pin_memory=True, + ) + + +def preload_data(config): + """Preprocesses train and validation data for trials.""" + train_loader = get_data_loader(*preload_and_process_data(config)[:2], config["batch_size"]) + val_loader = get_data_loader(*preload_and_process_data(config)[2:4], config["batch_size"]) + return train_loader, val_loader + + +def load_and_preprocess_test_data(config): + """Loads and preprocesses test data.""" + return load_and_preprocess_data(config["test_path"], config, is_test=True) + + +def prepare_test_loader(config): + """Prepares DataLoader for test data.""" + test_dataset, cell_id_mapping, num_labels_list = load_and_preprocess_test_data(config) + test_loader = get_data_loader(test_dataset, config["batch_size"]) + return test_loader, cell_id_mapping, num_labels_list diff --git a/geneformer/mtl/eval_utils.py b/geneformer/mtl/eval_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0a8ea4babe4ab1e48cc56280ee03423075cf7563 --- /dev/null +++ b/geneformer/mtl/eval_utils.py @@ -0,0 +1,88 @@ +import pandas as pd + +from .imports import * # noqa # isort:skip +from .data import prepare_test_loader # noqa # isort:skip +from .model import GeneformerMultiTask + + +def evaluate_test_dataset(model, device, test_loader, cell_id_mapping, config): + task_pred_labels = {task_name: [] for task_name in config["task_names"]} + task_pred_probs = {task_name: [] for task_name in config["task_names"]} + cell_ids = [] + + # # Load task label mappings from pickle file + # with open(f"{config['results_dir']}/task_label_mappings.pkl", "rb") as f: + # task_label_mappings = pickle.load(f) + + model.eval() + with torch.no_grad(): + for batch in test_loader: + input_ids = batch["input_ids"].to(device) + attention_mask = batch["attention_mask"].to(device) + _, logits, _ = model(input_ids, attention_mask) + for sample_idx in range(len(batch["input_ids"])): + cell_id = cell_id_mapping[batch["cell_id"][sample_idx].item()] + cell_ids.append(cell_id) + for i, task_name in enumerate(config["task_names"]): + pred_label = torch.argmax(logits[i][sample_idx], dim=-1).item() + pred_prob = ( + torch.softmax(logits[i][sample_idx], dim=-1).cpu().numpy() + ) + task_pred_labels[task_name].append(pred_label) + task_pred_probs[task_name].append(pred_prob) + + # Save test predictions with cell IDs and probabilities to CSV + test_results_dir = config["results_dir"] + os.makedirs(test_results_dir, exist_ok=True) + test_preds_file = os.path.join(test_results_dir, "test_preds.csv") + + rows = [] + for sample_idx in range(len(cell_ids)): + row = {"Cell ID": cell_ids[sample_idx]} + for task_name in config["task_names"]: + row[f"{task_name} Prediction"] = task_pred_labels[task_name][sample_idx] + row[f"{task_name} Probabilities"] = ",".join( + map(str, task_pred_probs[task_name][sample_idx]) + ) + rows.append(row) + + df = pd.DataFrame(rows) + df.to_csv(test_preds_file, index=False) + print(f"Test predictions saved to {test_preds_file}") + + +def load_and_evaluate_test_model(config): + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + test_loader, cell_id_mapping, num_labels_list = prepare_test_loader(config) + model_directory = os.path.join(config["model_save_path"], "GeneformerMultiTask") + hyperparams_path = os.path.join(model_directory, "hyperparameters.json") + + # Load the saved best hyperparameters + with open(hyperparams_path, "r") as f: + best_hyperparams = json.load(f) + + # Extract the task weights if present, otherwise set to None + task_weights = best_hyperparams.get("task_weights", None) + normalized_task_weights = task_weights if task_weights else [] + + # Print the loaded hyperparameters + print("Loaded hyperparameters:") + for param, value in best_hyperparams.items(): + if param == "task_weights": + print(f"normalized_task_weights: {value}") + else: + print(f"{param}: {value}") + + best_model_path = os.path.join(model_directory, "pytorch_model.bin") + best_model = GeneformerMultiTask( + config["pretrained_path"], + num_labels_list, + dropout_rate=best_hyperparams["dropout_rate"], + use_task_weights=config["use_task_weights"], + task_weights=normalized_task_weights, + ) + best_model.load_state_dict(torch.load(best_model_path)) + best_model.to(device) + + evaluate_test_dataset(best_model, device, test_loader, cell_id_mapping, config) + print("Evaluation completed.") diff --git a/geneformer/mtl/imports.py b/geneformer/mtl/imports.py new file mode 100644 index 0000000000000000000000000000000000000000..4fe9e90945a10a3d79cc487fa15431f2915e5683 --- /dev/null +++ b/geneformer/mtl/imports.py @@ -0,0 +1,43 @@ +import functools +import gc +import json +import os +import pickle +import sys +import warnings +from enum import Enum +from itertools import chain +from typing import Dict, List, Optional, Union + +import numpy as np +import optuna +import pandas as pd +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +from datasets import load_from_disk +from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, roc_curve +from sklearn.model_selection import train_test_split +from sklearn.preprocessing import LabelEncoder +from torch.utils.data import DataLoader +from transformers import ( + AdamW, + BatchEncoding, + BertConfig, + BertModel, + DataCollatorForTokenClassification, + SpecialTokensMixin, + get_cosine_schedule_with_warmup, + get_linear_schedule_with_warmup, + get_scheduler, +) +from transformers.utils import logging, to_py_obj + +from .collators import DataCollatorForMultitaskCellClassification + +# local modules +from .data import get_data_loader, preload_and_process_data +from .model import GeneformerMultiTask +from .optuna_utils import create_optuna_study +from .utils import save_model diff --git a/geneformer/mtl/model.py b/geneformer/mtl/model.py new file mode 100644 index 0000000000000000000000000000000000000000..393ebfad4f44f98d748845ea1ae81d66139988f5 --- /dev/null +++ b/geneformer/mtl/model.py @@ -0,0 +1,121 @@ +import torch +import torch.nn as nn +from transformers import BertConfig, BertModel + + +class AttentionPool(nn.Module): + """Attention-based pooling layer.""" + + def __init__(self, hidden_size): + super(AttentionPool, self).__init__() + self.attention_weights = nn.Parameter(torch.randn(hidden_size, 1)) + nn.init.xavier_uniform_( + self.attention_weights + ) # https://pytorch.org/docs/stable/nn.init.html + + def forward(self, hidden_states): + attention_scores = torch.matmul(hidden_states, self.attention_weights) + attention_scores = torch.softmax(attention_scores, dim=1) + pooled_output = torch.sum(hidden_states * attention_scores, dim=1) + return pooled_output + + +class GeneformerMultiTask(nn.Module): + def __init__( + self, + pretrained_path, + num_labels_list, + dropout_rate=0.1, + use_task_weights=False, + task_weights=None, + max_layers_to_freeze=0, + use_attention_pooling=False, + ): + super(GeneformerMultiTask, self).__init__() + self.config = BertConfig.from_pretrained(pretrained_path) + self.bert = BertModel(self.config) + self.num_labels_list = num_labels_list + self.use_task_weights = use_task_weights + self.dropout = nn.Dropout(dropout_rate) + self.use_attention_pooling = use_attention_pooling + + if use_task_weights and ( + task_weights is None or len(task_weights) != len(num_labels_list) + ): + raise ValueError( + "Task weights must be defined and match the number of tasks when 'use_task_weights' is True." + ) + self.task_weights = ( + task_weights if use_task_weights else [1.0] * len(num_labels_list) + ) + + # Freeze the specified initial layers + for layer in self.bert.encoder.layer[:max_layers_to_freeze]: + for param in layer.parameters(): + param.requires_grad = False + + self.attention_pool = ( + AttentionPool(self.config.hidden_size) if use_attention_pooling else None + ) + + self.classification_heads = nn.ModuleList( + [ + nn.Linear(self.config.hidden_size, num_labels) + for num_labels in num_labels_list + ] + ) + # initialization of the classification heads: https://pytorch.org/docs/stable/nn.init.html + for head in self.classification_heads: + nn.init.xavier_uniform_(head.weight) + nn.init.zeros_(head.bias) + + def forward(self, input_ids, attention_mask, labels=None): + try: + outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask) + except Exception as e: + raise RuntimeError(f"Error during BERT forward pass: {e}") + + sequence_output = outputs.last_hidden_state + + try: + pooled_output = ( + self.attention_pool(sequence_output) + if self.use_attention_pooling + else sequence_output[:, 0, :] + ) + pooled_output = self.dropout(pooled_output) + except Exception as e: + raise RuntimeError(f"Error during pooling and dropout: {e}") + + total_loss = 0 + logits = [] + losses = [] + + for task_id, (head, num_labels) in enumerate( + zip(self.classification_heads, self.num_labels_list) + ): + try: + task_logits = head(pooled_output) + except Exception as e: + raise RuntimeError( + f"Error during forward pass of classification head {task_id}: {e}" + ) + + logits.append(task_logits) + + if labels is not None: + try: + loss_fct = nn.CrossEntropyLoss() + task_loss = loss_fct( + task_logits.view(-1, num_labels), labels[task_id].view(-1) + ) + if self.use_task_weights: + task_loss *= self.task_weights[task_id] + total_loss += task_loss + losses.append(task_loss.item()) + except Exception as e: + raise RuntimeError( + f"Error during loss computation for task {task_id}: {e}" + ) + + return total_loss, logits, losses if labels is not None else logits diff --git a/geneformer/mtl/optuna_utils.py b/geneformer/mtl/optuna_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..47f375e90f4030e15feb7bc1245ffbba3e6a086e --- /dev/null +++ b/geneformer/mtl/optuna_utils.py @@ -0,0 +1,27 @@ +import optuna +from optuna.integration import TensorBoardCallback + + +def save_trial_callback(study, trial, trials_result_path): + with open(trials_result_path, "a") as f: + f.write( + f"Trial {trial.number}: Value (F1 Macro): {trial.value}, Params: {trial.params}\n" + ) + + +def create_optuna_study(objective, n_trials, trials_result_path, tensorboard_log_dir): + study = optuna.create_study(direction="maximize") + + # init TensorBoard callback + tensorboard_callback = TensorBoardCallback( + dirname=tensorboard_log_dir, metric_name="F1 Macro" + ) + + # callback and TensorBoard callback + callbacks = [ + lambda study, trial: save_trial_callback(study, trial, trials_result_path), + tensorboard_callback, + ] + + study.optimize(objective, n_trials=n_trials, callbacks=callbacks) + return study diff --git a/geneformer/mtl/train.py b/geneformer/mtl/train.py new file mode 100644 index 0000000000000000000000000000000000000000..5dee1fb8baf594fb137dce3802a44cc0118f1558 --- /dev/null +++ b/geneformer/mtl/train.py @@ -0,0 +1,380 @@ +import os +import random + +import numpy as np +import pandas as pd +import torch +from torch.utils.tensorboard import SummaryWriter +from tqdm import tqdm + +from .imports import * +from .model import GeneformerMultiTask +from .utils import calculate_task_specific_metrics, get_layer_freeze_range + + +def set_seed(seed): + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + + +def initialize_wandb(config): + if config.get("use_wandb", False): + import wandb + + wandb.init(project=config["wandb_project"], config=config) + print("Weights & Biases (wandb) initialized and will be used for logging.") + else: + print( + "Weights & Biases (wandb) is not enabled. Logging will use other methods." + ) + + +def create_model(config, num_labels_list, device): + model = GeneformerMultiTask( + config["pretrained_path"], + num_labels_list, + dropout_rate=config["dropout_rate"], + use_task_weights=config["use_task_weights"], + task_weights=config["task_weights"], + max_layers_to_freeze=config["max_layers_to_freeze"], + use_attention_pooling=config["use_attention_pooling"], + ) + if config["use_data_parallel"]: + model = nn.DataParallel(model) + return model.to(device) + + +def setup_optimizer_and_scheduler(model, config, total_steps): + optimizer = AdamW( + model.parameters(), + lr=config["learning_rate"], + weight_decay=config["weight_decay"], + ) + warmup_steps = int(config["warmup_ratio"] * total_steps) + + if config["lr_scheduler_type"] == "linear": + scheduler = get_linear_schedule_with_warmup( + optimizer, num_warmup_steps=warmup_steps, num_training_steps=total_steps + ) + elif config["lr_scheduler_type"] == "cosine": + scheduler = get_cosine_schedule_with_warmup( + optimizer, + num_warmup_steps=warmup_steps, + num_training_steps=total_steps, + num_cycles=0.5, + ) + + return optimizer, scheduler + + +def train_epoch( + model, train_loader, optimizer, scheduler, device, config, writer, epoch +): + model.train() + progress_bar = tqdm(train_loader, desc=f"Epoch {epoch+1}/{config['epochs']}") + for batch_idx, batch in enumerate(progress_bar): + optimizer.zero_grad() + input_ids = batch["input_ids"].to(device) + attention_mask = batch["attention_mask"].to(device) + labels = [ + batch["labels"][task_name].to(device) for task_name in config["task_names"] + ] + + loss, _, _ = model(input_ids, attention_mask, labels) + loss.backward() + + if config["gradient_clipping"]: + torch.nn.utils.clip_grad_norm_(model.parameters(), config["max_grad_norm"]) + + optimizer.step() + scheduler.step() + + writer.add_scalar( + "Training Loss", loss.item(), epoch * len(train_loader) + batch_idx + ) + if config.get("use_wandb", False): + import wandb + + wandb.log({"Training Loss": loss.item()}) + + # Update progress bar + progress_bar.set_postfix({"loss": f"{loss.item():.4f}"}) + + return loss.item() # Return the last batch loss + + +def validate_model(model, val_loader, device, config): + model.eval() + val_loss = 0.0 + task_true_labels = {task_name: [] for task_name in config["task_names"]} + task_pred_labels = {task_name: [] for task_name in config["task_names"]} + task_pred_probs = {task_name: [] for task_name in config["task_names"]} + + with torch.no_grad(): + for batch in val_loader: + input_ids = batch["input_ids"].to(device) + attention_mask = batch["attention_mask"].to(device) + labels = [ + batch["labels"][task_name].to(device) + for task_name in config["task_names"] + ] + loss, logits, _ = model(input_ids, attention_mask, labels) + val_loss += loss.item() + + for sample_idx in range(len(batch["input_ids"])): + for i, task_name in enumerate(config["task_names"]): + true_label = batch["labels"][task_name][sample_idx].item() + pred_label = torch.argmax(logits[i][sample_idx], dim=-1).item() + pred_prob = ( + torch.softmax(logits[i][sample_idx], dim=-1).cpu().numpy() + ) + task_true_labels[task_name].append(true_label) + task_pred_labels[task_name].append(pred_label) + task_pred_probs[task_name].append(pred_prob) + + val_loss /= len(val_loader) + return val_loss, task_true_labels, task_pred_labels, task_pred_probs + + +def log_metrics(task_metrics, val_loss, config, writer, epochs): + for task_name, metrics in task_metrics.items(): + print( + f"{task_name} - Validation F1 Macro: {metrics['f1']:.4f}, Validation Accuracy: {metrics['accuracy']:.4f}" + ) + if config.get("use_wandb", False): + import wandb + + wandb.log( + { + f"{task_name} Validation F1 Macro": metrics["f1"], + f"{task_name} Validation Accuracy": metrics["accuracy"], + } + ) + + writer.add_scalar("Validation Loss", val_loss, epochs) + for task_name, metrics in task_metrics.items(): + writer.add_scalar(f"{task_name} - Validation F1 Macro", metrics["f1"], epochs) + writer.add_scalar( + f"{task_name} - Validation Accuracy", metrics["accuracy"], epochs + ) + + +def save_validation_predictions( + val_cell_id_mapping, + task_true_labels, + task_pred_labels, + task_pred_probs, + config, + trial_number=None, +): + if trial_number is not None: + trial_results_dir = os.path.join(config["results_dir"], f"trial_{trial_number}") + os.makedirs(trial_results_dir, exist_ok=True) + val_preds_file = os.path.join(trial_results_dir, "val_preds.csv") + else: + val_preds_file = os.path.join(config["results_dir"], "manual_run_val_preds.csv") + + rows = [] + for sample_idx in range(len(val_cell_id_mapping)): + row = {"Cell ID": val_cell_id_mapping[sample_idx]} + for task_name in config["task_names"]: + row[f"{task_name} True"] = task_true_labels[task_name][sample_idx] + row[f"{task_name} Pred"] = task_pred_labels[task_name][sample_idx] + row[f"{task_name} Probabilities"] = ",".join( + map(str, task_pred_probs[task_name][sample_idx]) + ) + rows.append(row) + + df = pd.DataFrame(rows) + df.to_csv(val_preds_file, index=False) + print(f"Validation predictions saved to {val_preds_file}") + + +def train_model( + config, + device, + train_loader, + val_loader, + train_cell_id_mapping, + val_cell_id_mapping, + num_labels_list, +): + set_seed(config["seed"]) + initialize_wandb(config) + + model = create_model(config, num_labels_list, device) + total_steps = len(train_loader) * config["epochs"] + optimizer, scheduler = setup_optimizer_and_scheduler(model, config, total_steps) + + log_dir = os.path.join(config["tensorboard_log_dir"], "manual_run") + writer = SummaryWriter(log_dir=log_dir) + + epoch_progress = tqdm(range(config["epochs"]), desc="Training Progress") + for epoch in epoch_progress: + last_loss = train_epoch( + model, train_loader, optimizer, scheduler, device, config, writer, epoch + ) + epoch_progress.set_postfix({"last_loss": f"{last_loss:.4f}"}) + + val_loss, task_true_labels, task_pred_labels, task_pred_probs = validate_model( + model, val_loader, device, config + ) + task_metrics = calculate_task_specific_metrics(task_true_labels, task_pred_labels) + + log_metrics(task_metrics, val_loss, config, writer, config["epochs"]) + writer.close() + + save_validation_predictions( + val_cell_id_mapping, task_true_labels, task_pred_labels, task_pred_probs, config + ) + + if config.get("use_wandb", False): + import wandb + + wandb.finish() + + print(f"\nFinal Validation Loss: {val_loss:.4f}") + return val_loss, model # Return both the validation loss and the trained model + + +def objective( + trial, + train_loader, + val_loader, + train_cell_id_mapping, + val_cell_id_mapping, + num_labels_list, + config, + device, +): + set_seed(config["seed"]) # Set the seed before each trial + initialize_wandb(config) + + # Hyperparameters + config["learning_rate"] = trial.suggest_float( + "learning_rate", + config["hyperparameters"]["learning_rate"]["low"], + config["hyperparameters"]["learning_rate"]["high"], + log=config["hyperparameters"]["learning_rate"]["log"], + ) + config["warmup_ratio"] = trial.suggest_float( + "warmup_ratio", + config["hyperparameters"]["warmup_ratio"]["low"], + config["hyperparameters"]["warmup_ratio"]["high"], + ) + config["weight_decay"] = trial.suggest_float( + "weight_decay", + config["hyperparameters"]["weight_decay"]["low"], + config["hyperparameters"]["weight_decay"]["high"], + ) + config["dropout_rate"] = trial.suggest_float( + "dropout_rate", + config["hyperparameters"]["dropout_rate"]["low"], + config["hyperparameters"]["dropout_rate"]["high"], + ) + config["lr_scheduler_type"] = trial.suggest_categorical( + "lr_scheduler_type", config["hyperparameters"]["lr_scheduler_type"]["choices"] + ) + config["use_attention_pooling"] = trial.suggest_categorical( + "use_attention_pooling", [False] + ) + + if config["use_task_weights"]: + config["task_weights"] = [ + trial.suggest_float( + f"task_weight_{i}", + config["hyperparameters"]["task_weights"]["low"], + config["hyperparameters"]["task_weights"]["high"], + ) + for i in range(len(num_labels_list)) + ] + weight_sum = sum(config["task_weights"]) + config["task_weights"] = [ + weight / weight_sum for weight in config["task_weights"] + ] + else: + config["task_weights"] = None + + # Dynamic range for max_layers_to_freeze + freeze_range = get_layer_freeze_range(config["pretrained_path"]) + config["max_layers_to_freeze"] = trial.suggest_int( + "max_layers_to_freeze", + freeze_range["min"], + freeze_range["max"] + ) + + model = create_model(config, num_labels_list, device) + total_steps = len(train_loader) * config["epochs"] + optimizer, scheduler = setup_optimizer_and_scheduler(model, config, total_steps) + + log_dir = os.path.join(config["tensorboard_log_dir"], f"trial_{trial.number}") + writer = SummaryWriter(log_dir=log_dir) + + for epoch in range(config["epochs"]): + train_epoch( + model, train_loader, optimizer, scheduler, device, config, writer, epoch + ) + + val_loss, task_true_labels, task_pred_labels, task_pred_probs = validate_model( + model, val_loader, device, config + ) + task_metrics = calculate_task_specific_metrics(task_true_labels, task_pred_labels) + + log_metrics(task_metrics, val_loss, config, writer, config["epochs"]) + writer.close() + + save_validation_predictions( + val_cell_id_mapping, + task_true_labels, + task_pred_labels, + task_pred_probs, + config, + trial.number, + ) + + trial.set_user_attr("model_state_dict", model.state_dict()) + trial.set_user_attr("task_weights", config["task_weights"]) + + trial.report(val_loss, config["epochs"]) + + if trial.should_prune(): + raise optuna.TrialPruned() + + if config.get("use_wandb", False): + import wandb + + wandb.log( + { + "trial_number": trial.number, + "val_loss": val_loss, + **{ + f"{task_name}_f1": metrics["f1"] + for task_name, metrics in task_metrics.items() + }, + **{ + f"{task_name}_accuracy": metrics["accuracy"] + for task_name, metrics in task_metrics.items() + }, + **{ + k: v + for k, v in config.items() + if k + in [ + "learning_rate", + "warmup_ratio", + "weight_decay", + "dropout_rate", + "lr_scheduler_type", + "use_attention_pooling", + "max_layers_to_freeze", + ] + }, + } + ) + wandb.finish() + + return val_loss diff --git a/geneformer/mtl/train_utils.py b/geneformer/mtl/train_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..430994a37a53dcde99666a7b5a4d99532e9bc8ba --- /dev/null +++ b/geneformer/mtl/train_utils.py @@ -0,0 +1,161 @@ +import random + +from .data import get_data_loader, preload_and_process_data +from .imports import * +from .model import GeneformerMultiTask +from .train import objective, train_model +from .utils import save_model + + +def set_seed(seed): + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + + +def run_manual_tuning(config): + # Set seed for reproducibility + set_seed(config["seed"]) + + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + ( + train_dataset, + train_cell_id_mapping, + val_dataset, + val_cell_id_mapping, + num_labels_list, + ) = preload_and_process_data(config) + train_loader = get_data_loader(train_dataset, config["batch_size"]) + val_loader = get_data_loader(val_dataset, config["batch_size"]) + + # Print the manual hyperparameters being used + print("\nManual hyperparameters being used:") + for key, value in config["manual_hyperparameters"].items(): + print(f"{key}: {value}") + print() # Add an empty line for better readability + + # Use the manual hyperparameters + for key, value in config["manual_hyperparameters"].items(): + config[key] = value + + # Train the model + val_loss, trained_model = train_model( + config, + device, + train_loader, + val_loader, + train_cell_id_mapping, + val_cell_id_mapping, + num_labels_list, + ) + + print(f"\nValidation loss with manual hyperparameters: {val_loss}") + + # Save the trained model + model_save_directory = os.path.join( + config["model_save_path"], "GeneformerMultiTask" + ) + save_model(trained_model, model_save_directory) + + # Save the hyperparameters + hyperparams_to_save = { + **config["manual_hyperparameters"], + "dropout_rate": config["dropout_rate"], + "use_task_weights": config["use_task_weights"], + "task_weights": config["task_weights"], + "max_layers_to_freeze": config["max_layers_to_freeze"], + "use_attention_pooling": config["use_attention_pooling"], + } + hyperparams_path = os.path.join(model_save_directory, "hyperparameters.json") + with open(hyperparams_path, "w") as f: + json.dump(hyperparams_to_save, f) + print(f"Manual hyperparameters saved to {hyperparams_path}") + + return val_loss + + +def run_optuna_study(config): + # Set seed for reproducibility + set_seed(config["seed"]) + + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + ( + train_dataset, + train_cell_id_mapping, + val_dataset, + val_cell_id_mapping, + num_labels_list, + ) = preload_and_process_data(config) + train_loader = get_data_loader(train_dataset, config["batch_size"]) + val_loader = get_data_loader(val_dataset, config["batch_size"]) + + if config["use_manual_hyperparameters"]: + train_model( + config, + device, + train_loader, + val_loader, + train_cell_id_mapping, + val_cell_id_mapping, + num_labels_list, + ) + else: + objective_with_config_and_data = functools.partial( + objective, + train_loader=train_loader, + val_loader=val_loader, + train_cell_id_mapping=train_cell_id_mapping, + val_cell_id_mapping=val_cell_id_mapping, + num_labels_list=num_labels_list, + config=config, + device=device, + ) + + study = optuna.create_study( + direction="minimize", # Minimize validation loss + study_name=config["study_name"], + # storage=config["storage"], + load_if_exists=True, + ) + + study.optimize(objective_with_config_and_data, n_trials=config["n_trials"]) + + # After finding the best trial + best_params = study.best_trial.params + best_task_weights = study.best_trial.user_attrs["task_weights"] + print("Saving the best model and its hyperparameters...") + + # Saving model as before + best_model = GeneformerMultiTask( + config["pretrained_path"], + num_labels_list, + dropout_rate=best_params["dropout_rate"], + use_task_weights=config["use_task_weights"], + task_weights=best_task_weights, + ) + + # Get the best model state dictionary + best_model_state_dict = study.best_trial.user_attrs["model_state_dict"] + + # Remove the "module." prefix from the state dictionary keys if present + best_model_state_dict = { + k.replace("module.", ""): v for k, v in best_model_state_dict.items() + } + + # Load the modified state dictionary into the model, skipping unexpected keys + best_model.load_state_dict(best_model_state_dict, strict=False) + + model_save_directory = os.path.join( + config["model_save_path"], "GeneformerMultiTask" + ) + save_model(best_model, model_save_directory) + + # Additionally, save the best hyperparameters and task weights + hyperparams_path = os.path.join(model_save_directory, "hyperparameters.json") + + with open(hyperparams_path, "w") as f: + json.dump({**best_params, "task_weights": best_task_weights}, f) + print(f"Best hyperparameters and task weights saved to {hyperparams_path}") diff --git a/geneformer/mtl/utils.py b/geneformer/mtl/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5de5079ffdefb853a183038a6b3956de42f19978 --- /dev/null +++ b/geneformer/mtl/utils.py @@ -0,0 +1,129 @@ +import os +import shutil + +from sklearn.metrics import accuracy_score, f1_score +from sklearn.preprocessing import LabelEncoder +from transformers import AutoConfig, BertConfig, BertModel + +from .imports import * + + +def save_model(model, model_save_directory): + if not os.path.exists(model_save_directory): + os.makedirs(model_save_directory) + + # Get the state dict + if isinstance(model, nn.DataParallel): + model_state_dict = ( + model.module.state_dict() + ) # Use model.module to access the underlying model + else: + model_state_dict = model.state_dict() + + # Remove the "module." prefix from the keys if present + model_state_dict = { + k.replace("module.", ""): v for k, v in model_state_dict.items() + } + + model_save_path = os.path.join(model_save_directory, "pytorch_model.bin") + torch.save(model_state_dict, model_save_path) + + # Save the model configuration + if isinstance(model, nn.DataParallel): + model.module.config.to_json_file( + os.path.join(model_save_directory, "config.json") + ) + else: + model.config.to_json_file(os.path.join(model_save_directory, "config.json")) + + print(f"Model and configuration saved to {model_save_directory}") + + +def calculate_task_specific_metrics(task_true_labels, task_pred_labels): + task_metrics = {} + for task_name in task_true_labels.keys(): + true_labels = task_true_labels[task_name] + pred_labels = task_pred_labels[task_name] + f1 = f1_score(true_labels, pred_labels, average="macro") + accuracy = accuracy_score(true_labels, pred_labels) + task_metrics[task_name] = {"f1": f1, "accuracy": accuracy} + return task_metrics + + +def calculate_combined_f1(combined_labels, combined_preds): + # Initialize the LabelEncoder + le = LabelEncoder() + + # Fit and transform combined labels and predictions to numerical values + le.fit(combined_labels + combined_preds) + encoded_true_labels = le.transform(combined_labels) + encoded_pred_labels = le.transform(combined_preds) + + # Print out the mapping for sanity check + print("\nLabel Encoder Mapping:") + for index, class_label in enumerate(le.classes_): + print(f"'{class_label}': {index}") + + # Calculate accuracy + accuracy = accuracy_score(encoded_true_labels, encoded_pred_labels) + + # Calculate F1 Macro score + f1 = f1_score(encoded_true_labels, encoded_pred_labels, average="macro") + + return f1, accuracy + + +# def save_model_without_heads(original_model_save_directory): +# # Create a new directory for the model without heads +# new_model_save_directory = original_model_save_directory + "_No_Heads" +# if not os.path.exists(new_model_save_directory): +# os.makedirs(new_model_save_directory) + +# # Load the model state dictionary +# model_state_dict = torch.load( +# os.path.join(original_model_save_directory, "pytorch_model.bin") +# ) + +# # Initialize a new BERT model without the classification heads +# config = BertConfig.from_pretrained( +# os.path.join(original_model_save_directory, "config.json") +# ) +# model_without_heads = BertModel(config) + +# # Filter the state dict to exclude classification heads +# model_without_heads_state_dict = { +# k: v +# for k, v in model_state_dict.items() +# if not k.startswith("classification_heads") +# } + +# # Load the filtered state dict into the model +# model_without_heads.load_state_dict(model_without_heads_state_dict, strict=False) + +# # Save the model without heads +# model_save_path = os.path.join(new_model_save_directory, "pytorch_model.bin") +# torch.save(model_without_heads.state_dict(), model_save_path) + +# # Copy the configuration file +# shutil.copy( +# os.path.join(original_model_save_directory, "config.json"), +# new_model_save_directory, +# ) + +# print(f"Model without classification heads saved to {new_model_save_directory}") + + +def get_layer_freeze_range(pretrained_path): + """ + Dynamically determines the number of layers to freeze based on the model depth from its configuration. + Args: + pretrained_path (str): Path to the pretrained model directory or model identifier. + Returns: + dict: A dictionary with 'min' and 'max' keys indicating the range of layers to freeze. + """ + if pretrained_path: + config = AutoConfig.from_pretrained(pretrained_path) + total_layers = config.num_hidden_layers + return {"min": 0, "max": total_layers - 1} + else: + return {"min": 0, "max": 0} diff --git a/geneformer/mtl_classifier.py b/geneformer/mtl_classifier.py new file mode 100644 index 0000000000000000000000000000000000000000..68ee837a416e27d9e20156100e30718dec6778d0 --- /dev/null +++ b/geneformer/mtl_classifier.py @@ -0,0 +1,363 @@ +""" +Geneformer multi-task cell classifier. + +**Input data:** + +| Single-cell transcriptomes as Geneformer rank value encodings with cell state labels for each task in Geneformer .dataset format (generated from single-cell RNAseq data by tokenizer.py). Must contain "unique_cell_id" column for logging. + +**Usage:** + +.. code-block :: python + + >>> from geneformer import MTLClassifier + >>> mc = MTLClassifier(task_columns = ["task1", "task2"], + ... study_name = "mtl", + ... pretrained_path = "/path/pretrained/model", + ... train_path = "/path/train/set", + ... val_path = "/path/eval/set", + ... test_path = "/path/test/set", + ... model_save_path = "/results/directory/save_path", + ... trials_result_path = "/results/directory/results.txt", + ... results_dir = "/results/directory", + ... tensorboard_log_dir = "/results/tblogdir", + ... hyperparameters = hyperparameters) + >>> mc.run_optuna_study() + >>> mc.load_and_evaluate_test_model() + >>> mc.save_model_without_heads() +""" + +import logging +import os + +from .mtl import eval_utils, train_utils, utils + +logger = logging.getLogger(__name__) + + +class MTLClassifier: + valid_option_dict = { + "task_columns": {list}, + "train_path": {None, str}, + "val_path": {None, str}, + "test_path": {None, str}, + "pretrained_path": {None, str}, + "model_save_path": {None, str}, + "results_dir": {None, str}, + "batch_size": {None, int}, + "n_trials": {None, int}, + "study_name": {None, str}, + "max_layers_to_freeze": {None, dict}, + "epochs": {None, int}, + "tensorboard_log_dir": {None, str}, + "use_data_parallel": {None, bool}, + "use_attention_pooling": {None, bool}, + "use_task_weights": {None, bool}, + "hyperparameters": {None, dict}, + "manual_hyperparameters": {None, dict}, + "use_manual_hyperparameters": {None, bool}, + "use_wandb": {None, bool}, + "wandb_project": {None, str}, + "gradient_clipping": {None, bool}, + "max_grad_norm": {None, int, float}, + "seed": {None, int}, + "trials_result_path": {None, str}, + } + + def __init__( + self, + task_columns=None, + train_path=None, + val_path=None, + test_path=None, + pretrained_path=None, + model_save_path=None, + results_dir=None, + trials_result_path=None, + batch_size=4, + n_trials=15, + study_name="mtl", + max_layers_to_freeze=None, + epochs=1, + tensorboard_log_dir="/results/tblogdir", + use_data_parallel=False, + use_attention_pooling=True, + use_task_weights=True, + hyperparameters=None, # Default is None + manual_hyperparameters=None, # Default is None + use_manual_hyperparameters=False, # Default is False + use_wandb=False, + wandb_project=None, + gradient_clipping=False, + max_grad_norm=None, + seed=42, # Default seed value + ): + """ + Initialize Geneformer multi-task classifier. + + **Parameters:** + + task_columns : list + | List of tasks for cell state classification + | Input data columns are labeled with corresponding task names + study_name : None, str + | Study name for labeling output files + pretrained_path : None, str + | Path to pretrained model + train_path : None, str + | Path to training dataset with task columns and "unique_cell_id" column + val_path : None, str + | Path to validation dataset with task columns and "unique_cell_id" column + test_path : None, str + | Path to test dataset with task columns and "unique_cell_id" column + model_save_path : None, str + | Path to directory to save output model (either full model or model without heads) + trials_result_path : None, str + | Path to directory to save hyperparameter tuning trial results + results_dir : None, str + | Path to directory to save results + tensorboard_log_dir : None, str + | Path to directory for Tensorboard logging results + use_data_parallel : None, bool + | Whether to use data parallelization + use_attention_pooling : None, bool + | Whether to use attention pooling + use_task_weights : None, bool + | Whether to use task weights + batch_size : None, int + | Batch size to use + n_trials : None, int + | Number of trials for hyperparameter tuning + epochs : None, int + | Number of epochs for training + max_layers_to_freeze : None, dict + | Dictionary with keys "min" and "max" indicating the min and max layers to freeze from fine-tuning (int) + | 0: no layers will be frozen; 2: first two layers will be frozen; etc. + hyperparameters : None, dict + | Dictionary of categorical max and min for each hyperparameter for tuning + | For example: + | {"learning_rate": {"type":"float", "low":"1e-5", "high":"1e-3", "log":True}, "task_weights": {...}, ...} + manual_hyperparameters : None, dict + | Dictionary of manually set value for each hyperparameter + | For example: + | {"learning_rate": 0.001, "task_weights": [1, 1], ...} + use_manual_hyperparameters : None, bool + | Whether to use manually set hyperparameters + use_wandb : None, bool + | Whether to use Weights & Biases for logging + wandb_project : None, str + | Weights & Biases project name + gradient_clipping : None, bool + | Whether to use gradient clipping + max_grad_norm : None, int, float + | Maximum norm for gradient clipping + seed : None, int + | Random seed + """ + + self.task_columns = task_columns + self.train_path = train_path + self.val_path = val_path + self.test_path = test_path + self.pretrained_path = pretrained_path + self.model_save_path = model_save_path + self.results_dir = results_dir + self.trials_result_path = trials_result_path + self.batch_size = batch_size + self.n_trials = n_trials + self.study_name = study_name + + if max_layers_to_freeze is None: + # Dynamically determine the range of layers to freeze + layer_freeze_range = utils.get_layer_freeze_range(pretrained_path) + self.max_layers_to_freeze = {"min": 1, "max": layer_freeze_range["max"]} + else: + self.max_layers_to_freeze = max_layers_to_freeze + + self.epochs = epochs + self.tensorboard_log_dir = tensorboard_log_dir + self.use_data_parallel = use_data_parallel + self.use_attention_pooling = use_attention_pooling + self.use_task_weights = use_task_weights + self.hyperparameters = ( + hyperparameters + if hyperparameters is not None + else { + "learning_rate": { + "type": "float", + "low": 1e-5, + "high": 1e-3, + "log": True, + }, + "warmup_ratio": {"type": "float", "low": 0.005, "high": 0.01}, + "weight_decay": {"type": "float", "low": 0.01, "high": 0.1}, + "dropout_rate": {"type": "float", "low": 0.0, "high": 0.7}, + "lr_scheduler_type": {"type": "categorical", "choices": ["cosine"]}, + "task_weights": {"type": "float", "low": 0.1, "high": 2.0}, + } + ) + self.manual_hyperparameters = ( + manual_hyperparameters + if manual_hyperparameters is not None + else { + "learning_rate": 0.001, + "warmup_ratio": 0.01, + "weight_decay": 0.1, + "dropout_rate": 0.1, + "lr_scheduler_type": "cosine", + "use_attention_pooling": False, + "task_weights": [1, 1], + "max_layers_to_freeze": 2, + } + ) + self.use_manual_hyperparameters = use_manual_hyperparameters + self.use_wandb = use_wandb + self.wandb_project = wandb_project + self.gradient_clipping = gradient_clipping + self.max_grad_norm = max_grad_norm + self.seed = seed + + if self.use_manual_hyperparameters: + logger.warning( + "Hyperparameter tuning is highly recommended for optimal results." + ) + + self.validate_options() + + # set up output directories + if self.results_dir is not None: + self.trials_results_path = f"{self.results_dir}/results.txt".replace( + "//", "/" + ) + + for output_dir in [self.model_save_path, self.results_dir]: + if not os.path.exists(output_dir): + os.makedirs(output_dir) + + self.config = { + key: value + for key, value in self.__dict__.items() + if key in self.valid_option_dict + } + + def validate_options(self): + # confirm arguments are within valid options and compatible with each other + for attr_name, valid_options in self.valid_option_dict.items(): + attr_value = self.__dict__[attr_name] + if not isinstance(attr_value, (list, dict)): + if attr_value in valid_options: + continue + valid_type = False + for option in valid_options: + if (option in [int, float, list, dict, bool, str]) and isinstance( + attr_value, option + ): + valid_type = True + break + if valid_type: + continue + logger.error( + f"Invalid option for {attr_name}. " + f"Valid options for {attr_name}: {valid_options}" + ) + raise ValueError( + f"Invalid option for {attr_name}. Valid options for {attr_name}: {valid_options}" + ) + + def run_manual_tuning(self): + """ + Manual hyperparameter tuning and multi-task fine-tuning of pretrained model. + """ + required_variable_names = [ + "train_path", + "val_path", + "pretrained_path", + "model_save_path", + "results_dir", + ] + required_variables = [ + self.train_path, + self.val_path, + self.pretrained_path, + self.model_save_path, + self.results_dir, + ] + req_var_dict = dict(zip(required_variable_names, required_variables)) + self.validate_additional_options(req_var_dict) + + if not self.use_manual_hyperparameters: + raise ValueError( + "Manual hyperparameters are not enabled. Set use_manual_hyperparameters to True." + ) + + # Ensure manual_hyperparameters are set in the config + self.config["manual_hyperparameters"] = self.manual_hyperparameters + self.config["use_manual_hyperparameters"] = True + + train_utils.run_manual_tuning(self.config) + + def validate_additional_options(self, req_var_dict): + missing_variable = False + for variable_name, variable in req_var_dict.items(): + if variable is None: + logger.warning( + f"Please provide value to MTLClassifier for required variable {variable_name}" + ) + missing_variable = True + if missing_variable is True: + raise ValueError("Missing required variables for MTLClassifier") + + def run_optuna_study( + self, + ): + """ + Hyperparameter optimization and/or multi-task fine-tuning of pretrained model. + """ + + required_variable_names = [ + "train_path", + "val_path", + "pretrained_path", + "model_save_path", + "results_dir", + ] + required_variables = [ + self.train_path, + self.val_path, + self.pretrained_path, + self.model_save_path, + self.results_dir, + ] + req_var_dict = dict(zip(required_variable_names, required_variables)) + self.validate_additional_options(req_var_dict) + + train_utils.run_optuna_study(self.config) + + def load_and_evaluate_test_model( + self, + ): + """ + Loads previously fine-tuned multi-task model and evaluates on test data. + """ + + required_variable_names = ["test_path", "model_save_path", "results_dir"] + required_variables = [self.test_path, self.model_save_path, self.results_dir] + req_var_dict = dict(zip(required_variable_names, required_variables)) + self.validate_additional_options(req_var_dict) + + eval_utils.load_and_evaluate_test_model(self.config) + + # def save_model_without_heads( + # self, + # ): + # """ + # Save previously fine-tuned multi-task model without classification heads. + # """ + + # required_variable_names = ["model_save_path"] + # required_variables = [self.model_save_path] + # req_var_dict = dict(zip(required_variable_names, required_variables)) + # self.validate_additional_options(req_var_dict) + + # utils.save_model_without_heads( + # os.path.join(self.model_save_path, "GeneformerMultiTask") + # ) diff --git a/geneformer/perturber_utils.py b/geneformer/perturber_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e7091a2f9df2e7fcb944083a3029734bce7a9328 --- /dev/null +++ b/geneformer/perturber_utils.py @@ -0,0 +1,919 @@ +import itertools as it +import logging +import pickle +from collections import defaultdict +from pathlib import Path +from typing import List + +import numpy as np +import pandas as pd +import torch +from datasets import Dataset, load_from_disk +from peft import LoraConfig, get_peft_model +from transformers import ( + BertForMaskedLM, + BertForSequenceClassification, + BertForTokenClassification, + BitsAndBytesConfig, +) + +GENE_MEDIAN_FILE = Path(__file__).parent / "gene_median_dictionary.pkl" +TOKEN_DICTIONARY_FILE = Path(__file__).parent / "token_dictionary.pkl" +ENSEMBL_DICTIONARY_FILE = Path(__file__).parent / "gene_name_id_dict.pkl" + + +logger = logging.getLogger(__name__) + + +# load data and filter by defined criteria +def load_and_filter(filter_data, nproc, input_data_file): + data = load_from_disk(input_data_file) + if filter_data is not None: + data = filter_by_dict(data, filter_data, nproc) + return data + + +def filter_by_dict(data, filter_data, nproc): + for key, value in filter_data.items(): + + def filter_data_by_criteria(example): + return example[key] in value + + data = data.filter(filter_data_by_criteria, num_proc=nproc) + if len(data) == 0: + logger.error("No cells remain after filtering. Check filtering criteria.") + raise + return data + + +def filter_data_by_tokens(filtered_input_data, tokens, nproc): + def if_has_tokens(example): + return len(set(example["input_ids"]).intersection(tokens)) == len(tokens) + + filtered_input_data = filtered_input_data.filter(if_has_tokens, num_proc=nproc) + return filtered_input_data + + +def logging_filtered_data_len(filtered_input_data, filtered_tokens_categ): + if len(filtered_input_data) == 0: + logger.error(f"No cells in dataset contain {filtered_tokens_categ}.") + raise + else: + logger.info(f"# cells with {filtered_tokens_categ}: {len(filtered_input_data)}") + + +def filter_data_by_tokens_and_log( + filtered_input_data, tokens, nproc, filtered_tokens_categ +): + # filter for cells with anchor gene + filtered_input_data = filter_data_by_tokens(filtered_input_data, tokens, nproc) + # logging length of filtered data + logging_filtered_data_len(filtered_input_data, filtered_tokens_categ) + + return filtered_input_data + + +def filter_data_by_start_state(filtered_input_data, cell_states_to_model, nproc): + # confirm that start state is valid to prevent futile filtering + state_key = cell_states_to_model["state_key"] + state_values = filtered_input_data[state_key] + start_state = cell_states_to_model["start_state"] + if start_state not in state_values: + logger.error( + f"Start state {start_state} is not present " + f"in the dataset's {state_key} attribute." + ) + raise + + # filter for start state cells + def filter_for_origin(example): + return example[state_key] in [start_state] + + filtered_input_data = filtered_input_data.filter(filter_for_origin, num_proc=nproc) + return filtered_input_data + + +def slice_by_inds_to_perturb(filtered_input_data, cell_inds_to_perturb): + if cell_inds_to_perturb["start"] >= len(filtered_input_data): + logger.error( + "cell_inds_to_perturb['start'] is larger than the filtered dataset." + ) + raise + if cell_inds_to_perturb["end"] > len(filtered_input_data): + logger.warning( + "cell_inds_to_perturb['end'] is larger than the filtered dataset. \ + Setting to the end of the filtered dataset." + ) + cell_inds_to_perturb["end"] = len(filtered_input_data) + filtered_input_data = filtered_input_data.select( + [i for i in range(cell_inds_to_perturb["start"], cell_inds_to_perturb["end"])] + ) + return filtered_input_data + + +# load model to GPU +def load_model(model_type, num_classes, model_directory, mode, quantize=False): + if model_type == "MTLCellClassifier-Quantized": + model_type = "MTLCellClassifier" + quantize = True + + output_hidden_states = (mode == "eval") + + # Quantization logic + if quantize: + if model_type == "MTLCellClassifier": + quantize_config = BitsAndBytesConfig(load_in_8bit=True) + peft_config = None + else: + quantize_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + bnb_4bit_compute_dtype=torch.bfloat16, + ) + peft_config = LoraConfig( + lora_alpha=128, + lora_dropout=0.1, + r=64, + bias="none", + task_type="TokenClassification", + ) + else: + quantize_config = None + peft_config = None + + # Model class selection + model_classes = { + "Pretrained": BertForMaskedLM, + "GeneClassifier": BertForTokenClassification, + "CellClassifier": BertForSequenceClassification, + "MTLCellClassifier": BertForMaskedLM + } + + model_class = model_classes.get(model_type) + if not model_class: + raise ValueError(f"Unknown model type: {model_type}") + + # Model loading + model_args = { + "pretrained_model_name_or_path": model_directory, + "output_hidden_states": output_hidden_states, + "output_attentions": False, + } + + if model_type != "Pretrained": + model_args["num_labels"] = num_classes + + if quantize_config: + model_args["quantization_config"] = quantize_config + + # Load the model + model = model_class.from_pretrained(**model_args) + + if mode == "eval": + model.eval() + + # Handle device placement and PEFT + if not quantize: + # Only move non-quantized models + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + model = model.to(device) + elif peft_config: + # Apply PEFT for quantized models (except MTLCellClassifier) + model.enable_input_require_grads() + model = get_peft_model(model, peft_config) + + return model + +def quant_layers(model): + layer_nums = [] + for name, parameter in model.named_parameters(): + if "layer" in name: + layer_nums += [int(name.split("layer.")[1].split(".")[0])] + return int(max(layer_nums)) + 1 + + +def get_model_emb_dims(model): + return model.config.hidden_size + + +def get_model_input_size(model): + return model.config.max_position_embeddings + + +def flatten_list(megalist): + return [item for sublist in megalist for item in sublist] + + +def measure_length(example): + example["length"] = len(example["input_ids"]) + return example + + +def downsample_and_sort(data, max_ncells): + num_cells = len(data) + # if max number of cells is defined, then shuffle and subsample to this max number + if max_ncells is not None: + if num_cells > max_ncells: + data = data.shuffle(seed=42) + num_cells = max_ncells + data_subset = data.select([i for i in range(num_cells)]) + # sort dataset with largest cell first to encounter any memory errors earlier + data_sorted = data_subset.sort("length", reverse=True) + return data_sorted + + +def get_possible_states(cell_states_to_model): + possible_states = [] + for key in ["start_state", "goal_state"]: + possible_states += [cell_states_to_model[key]] + possible_states += cell_states_to_model.get("alt_states", []) + return possible_states + + +def forward_pass_single_cell(model, example_cell, layer_to_quant): + example_cell.set_format(type="torch") + input_data = example_cell["input_ids"] + with torch.no_grad(): + outputs = model(input_ids=input_data.to("cuda")) + emb = torch.squeeze(outputs.hidden_states[layer_to_quant]) + del outputs + return emb + + +def perturb_emb_by_index(emb, indices): + mask = torch.ones(emb.numel(), dtype=torch.bool) + mask[indices] = False + return emb[mask] + + +def delete_indices(example): + indices = example["perturb_index"] + if any(isinstance(el, list) for el in indices): + indices = flatten_list(indices) + for index in sorted(indices, reverse=True): + del example["input_ids"][index] + + example["length"] = len(example["input_ids"]) + return example + + +# for genes_to_perturb = "all" where only genes within cell are overexpressed +def overexpress_indices(example): + indices = example["perturb_index"] + if any(isinstance(el, list) for el in indices): + indices = flatten_list(indices) + insert_pos = 0 + for index in sorted(indices, reverse=False): + example["input_ids"].insert(insert_pos, example["input_ids"].pop(index)) + insert_pos += 1 + example["length"] = len(example["input_ids"]) + return example + + +# if CLS token present, move to 1st rather than 0th position +def overexpress_indices_special(example): + indices = example["perturb_index"] + if any(isinstance(el, list) for el in indices): + indices = flatten_list(indices) + insert_pos = 1 # Insert starting after CLS token + for index in sorted(indices, reverse=False): + example["input_ids"].insert(insert_pos, example["input_ids"].pop(index)) + insert_pos += 1 + example["length"] = len(example["input_ids"]) + return example + + +# for genes_to_perturb = list of genes to overexpress that are not necessarily expressed in cell +def overexpress_tokens(example, max_len, special_token): + # -100 indicates tokens to overexpress are not present in rank value encoding + if example["perturb_index"] != [-100]: + example = delete_indices(example) + if special_token: + [ + example["input_ids"].insert(1, token) + for token in example["tokens_to_perturb"][::-1] + ] + else: + [ + example["input_ids"].insert(0, token) + for token in example["tokens_to_perturb"][::-1] + ] + + # truncate to max input size, must also truncate original emb to be comparable + if len(example["input_ids"]) > max_len: + if special_token: + example["input_ids"] = example["input_ids"][0 : max_len - 1] + [ + example["input_ids"][-1] + ] + else: + example["input_ids"] = example["input_ids"][0:max_len] + example["length"] = len(example["input_ids"]) + return example + + +def calc_n_overflow(max_len, example_len, tokens_to_perturb, indices_to_perturb): + n_to_add = len(tokens_to_perturb) - len(indices_to_perturb) + n_overflow = example_len + n_to_add - max_len + return n_overflow + + +def truncate_by_n_overflow(example): + new_max_len = example["length"] - example["n_overflow"] + example["input_ids"] = example["input_ids"][0:new_max_len] + example["length"] = len(example["input_ids"]) + return example + + +def truncate_by_n_overflow_special(example): + if example["n_overflow"] > 0: + new_max_len = example["length"] - example["n_overflow"] + example["input_ids"] = example["input_ids"][0 : new_max_len - 1] + [ + example["input_ids"][-1] + ] + example["length"] = len(example["input_ids"]) + return example + + +def remove_indices_from_emb(emb, indices_to_remove, gene_dim): + # indices_to_remove is list of indices to remove + indices_to_keep = [ + i for i in range(emb.size()[gene_dim]) if i not in indices_to_remove + ] + num_dims = emb.dim() + emb_slice = [ + slice(None) if dim != gene_dim else indices_to_keep for dim in range(num_dims) + ] + sliced_emb = emb[emb_slice] + return sliced_emb + + +def remove_indices_from_emb_batch(emb_batch, list_of_indices_to_remove, gene_dim): + output_batch_list = [ + remove_indices_from_emb(emb_batch[i, :, :], idxes, gene_dim - 1) + for i, idxes in enumerate(list_of_indices_to_remove) + ] + # add padding given genes are sometimes added that are or are not in original cell + batch_max = max([emb.size()[gene_dim - 1] for emb in output_batch_list]) + output_batch_list_padded = [ + pad_xd_tensor(emb, 0.000, batch_max, gene_dim - 1) for emb in output_batch_list + ] + return torch.stack(output_batch_list_padded) + + +# removes perturbed indices +# need to handle the various cases where a set of genes is overexpressed +def remove_perturbed_indices_set( + emb, + perturb_type: str, + indices_to_perturb: List[List], + tokens_to_perturb: List[List], + original_lengths: List[int], + input_ids=None, +): + if perturb_type == "overexpress": + num_perturbed = len(tokens_to_perturb) + if num_perturbed == 1: + indices_to_perturb_orig = [ + idx if idx != [-100] else [None] for idx in indices_to_perturb + ] + if all(v is [None] for v in indices_to_perturb_orig): + return emb + else: + indices_to_perturb_orig = [] + + for idx_list in indices_to_perturb: + indices_to_perturb_orig.append( + [idx if idx != [-100] else [None] for idx in idx_list] + ) + + else: + indices_to_perturb_orig = indices_to_perturb + + emb = remove_indices_from_emb_batch(emb, indices_to_perturb_orig, gene_dim=1) + + return emb + + +def make_perturbation_batch( + example_cell, perturb_type, tokens_to_perturb, anchor_token, combo_lvl, num_proc +) -> tuple[Dataset, List[int]]: + if combo_lvl == 0 and tokens_to_perturb == "all": + if perturb_type in ["overexpress", "activate"]: + range_start = 1 + elif perturb_type in ["delete", "inhibit"]: + range_start = 0 + indices_to_perturb = [ + [i] for i in range(range_start, example_cell["length"][0]) + ] + # elif combo_lvl > 0 and anchor_token is None: + ## to implement + elif combo_lvl > 0 and (anchor_token is not None): + example_input_ids = example_cell["input_ids"][0] + anchor_index = example_input_ids.index(anchor_token[0]) + indices_to_perturb = [ + sorted([anchor_index, i]) if i != anchor_index else None + for i in range(example_cell["length"][0]) + ] + indices_to_perturb = [item for item in indices_to_perturb if item is not None] + else: + example_input_ids = example_cell["input_ids"][0] + indices_to_perturb = [ + [example_input_ids.index(token)] if token in example_input_ids else None + for token in tokens_to_perturb + ] + indices_to_perturb = [item for item in indices_to_perturb if item is not None] + + # create all permutations of combo_lvl of modifiers from tokens_to_perturb + if combo_lvl > 0 and (anchor_token is None): + if tokens_to_perturb != "all": + if len(tokens_to_perturb) == combo_lvl + 1: + indices_to_perturb = [ + list(x) for x in it.combinations(indices_to_perturb, combo_lvl + 1) + ] + else: + all_indices = [[i] for i in range(example_cell["length"][0])] + all_indices = [ + index for index in all_indices if index not in indices_to_perturb + ] + indices_to_perturb = [ + [[j for i in indices_to_perturb for j in i], x] for x in all_indices + ] + + length = len(indices_to_perturb) + perturbation_dataset = Dataset.from_dict( + { + "input_ids": example_cell["input_ids"] * length, + "perturb_index": indices_to_perturb, + } + ) + + if length < 400: + num_proc_i = 1 + else: + num_proc_i = num_proc + + if perturb_type == "delete": + perturbation_dataset = perturbation_dataset.map( + delete_indices, num_proc=num_proc_i + ) + elif perturb_type == "overexpress": + perturbation_dataset = perturbation_dataset.map( + overexpress_indices, num_proc=num_proc_i + ) + + perturbation_dataset = perturbation_dataset.map(measure_length, num_proc=num_proc_i) + + return perturbation_dataset, indices_to_perturb + + +def make_perturbation_batch_special( + example_cell, perturb_type, tokens_to_perturb, anchor_token, combo_lvl, num_proc +) -> tuple[Dataset, List[int]]: + if combo_lvl == 0 and tokens_to_perturb == "all": + if perturb_type in ["overexpress", "activate"]: + range_start = 1 + elif perturb_type in ["delete", "inhibit"]: + range_start = 0 + range_start += 1 # Starting after the CLS token + indices_to_perturb = [ + [i] + for i in range( + range_start, example_cell["length"][0] - 1 + ) # And excluding the EOS token + ] + + # elif combo_lvl > 0 and anchor_token is None: + ## to implement + elif combo_lvl > 0 and (anchor_token is not None): + example_input_ids = example_cell["input_ids"][0] + anchor_index = example_input_ids.index(anchor_token[0]) + indices_to_perturb = [ + sorted([anchor_index, i]) if i != anchor_index else None + for i in range( + 1, example_cell["length"][0] - 1 + ) # Exclude CLS and EOS tokens + ] + indices_to_perturb = [item for item in indices_to_perturb if item is not None] + else: + example_input_ids = example_cell["input_ids"][0] + indices_to_perturb = [ + [example_input_ids.index(token)] if token in example_input_ids else None + for token in tokens_to_perturb + ] + indices_to_perturb = [item for item in indices_to_perturb if item is not None] + + # create all permutations of combo_lvl of modifiers from tokens_to_perturb + if combo_lvl > 0 and (anchor_token is None): + if tokens_to_perturb != "all": + if len(tokens_to_perturb) == combo_lvl + 1: + indices_to_perturb = [ + list(x) for x in it.combinations(indices_to_perturb, combo_lvl + 1) + ] + else: + all_indices = [ + [i] for i in range(1, example_cell["length"][0] - 1) + ] # Exclude CLS and EOS tokens + all_indices = [ + index for index in all_indices if index not in indices_to_perturb + ] + indices_to_perturb = [ + [[j for i in indices_to_perturb for j in i], x] for x in all_indices + ] + + length = len(indices_to_perturb) + perturbation_dataset = Dataset.from_dict( + { + "input_ids": example_cell["input_ids"] * length, + "perturb_index": indices_to_perturb, + } + ) + + if length < 400: + num_proc_i = 1 + else: + num_proc_i = num_proc + + if perturb_type == "delete": + perturbation_dataset = perturbation_dataset.map( + delete_indices, num_proc=num_proc_i + ) + elif perturb_type == "overexpress": + perturbation_dataset = perturbation_dataset.map( + overexpress_indices_special, num_proc=num_proc_i + ) + + perturbation_dataset = perturbation_dataset.map(measure_length, num_proc=num_proc_i) + + return perturbation_dataset, indices_to_perturb + + +# original cell emb removing the activated/overexpressed/inhibited gene emb +# so that only non-perturbed gene embeddings are compared to each other +# in original or perturbed context +def make_comparison_batch(original_emb_batch, indices_to_perturb, perturb_group): + all_embs_list = [] + + # if making comparison batch for multiple perturbations in single cell + if perturb_group is False: + # squeeze if single cell + if original_emb_batch.ndim == 3 and original_emb_batch.size()[0] == 1: + original_emb_batch = torch.squeeze(original_emb_batch) + original_emb_list = [original_emb_batch] * len(indices_to_perturb) + # if making comparison batch for single perturbation in multiple cells + elif perturb_group is True: + original_emb_list = original_emb_batch + + for original_emb, indices in zip(original_emb_list, indices_to_perturb): + if indices == [-100]: + all_embs_list += [original_emb[:]] + continue + + emb_list = [] + start = 0 + if any(isinstance(el, list) for el in indices): + indices = flatten_list(indices) + + # removes indices that were perturbed from the original embedding + for i in sorted(indices): + emb_list += [original_emb[start:i]] + start = i + 1 + + emb_list += [original_emb[start:]] + all_embs_list += [torch.cat(emb_list)] + + len_set = set([emb.size()[0] for emb in all_embs_list]) + if len(len_set) > 1: + max_len = max(len_set) + all_embs_list = [pad_2d_tensor(emb, None, max_len, 0) for emb in all_embs_list] + return torch.stack(all_embs_list) + + +def pad_list(input_ids, pad_token_id, max_len): + input_ids = np.pad( + input_ids, + (0, max_len - len(input_ids)), + mode="constant", + constant_values=pad_token_id, + ) + return input_ids + + +def pad_xd_tensor(tensor, pad_token_id, max_len, dim): + padding_length = max_len - tensor.size()[dim] + # Construct a padding configuration where all padding values are 0, except for the padding dimension + # 2 * number of dimensions (padding before and after for every dimension) + pad_config = [0] * 2 * tensor.dim() + # Set the padding after the desired dimension to the calculated padding length + pad_config[-2 * dim - 1] = padding_length + return torch.nn.functional.pad( + tensor, pad=pad_config, mode="constant", value=pad_token_id + ) + + +def pad_tensor(tensor, pad_token_id, max_len): + tensor = torch.nn.functional.pad( + tensor, pad=(0, max_len - tensor.numel()), mode="constant", value=pad_token_id + ) + + return tensor + + +def pad_2d_tensor(tensor, pad_token_id, max_len, dim): + if dim == 0: + pad = (0, 0, 0, max_len - tensor.size()[dim]) + elif dim == 1: + pad = (0, max_len - tensor.size()[dim], 0, 0) + tensor = torch.nn.functional.pad( + tensor, pad=pad, mode="constant", value=pad_token_id + ) + return tensor + + +def pad_3d_tensor(tensor, pad_token_id, max_len, dim): + if dim == 0: + raise Exception("dim 0 usually does not need to be padded.") + if dim == 1: + pad = (0, 0, 0, max_len - tensor.size()[dim]) + elif dim == 2: + pad = (0, max_len - tensor.size()[dim], 0, 0) + tensor = torch.nn.functional.pad( + tensor, pad=pad, mode="constant", value=pad_token_id + ) + return tensor + + +def pad_or_truncate_encoding(encoding, pad_token_id, max_len): + if isinstance(encoding, torch.Tensor): + encoding_len = encoding.size()[0] + elif isinstance(encoding, list): + encoding_len = len(encoding) + if encoding_len > max_len: + encoding = encoding[0:max_len] + elif encoding_len < max_len: + if isinstance(encoding, torch.Tensor): + encoding = pad_tensor(encoding, pad_token_id, max_len) + elif isinstance(encoding, list): + encoding = pad_list(encoding, pad_token_id, max_len) + return encoding + + +# pad list of tensors and convert to tensor +def pad_tensor_list( + tensor_list, + dynamic_or_constant, + pad_token_id, + model_input_size, + dim=None, + padding_func=None, +): + # determine maximum tensor length + if dynamic_or_constant == "dynamic": + max_len = max([tensor.squeeze().numel() for tensor in tensor_list]) + elif isinstance(dynamic_or_constant, int): + max_len = dynamic_or_constant + else: + max_len = model_input_size + logger.warning( + "If padding style is constant, must provide integer value. " + f"Setting padding to max input size {model_input_size}." + ) + + # pad all tensors to maximum length + if dim is None: + tensor_list = [ + pad_tensor(tensor, pad_token_id, max_len) for tensor in tensor_list + ] + else: + tensor_list = [ + padding_func(tensor, pad_token_id, max_len, dim) for tensor in tensor_list + ] + # return stacked tensors + if padding_func != pad_3d_tensor: + return torch.stack(tensor_list) + else: + return torch.cat(tensor_list, 0) + + +def gen_attention_mask(minibatch_encoding, max_len=None): + if max_len is None: + max_len = max(minibatch_encoding["length"]) + original_lens = minibatch_encoding["length"] + attention_mask = [ + [1] * original_len + [0] * (max_len - original_len) + if original_len <= max_len + else [1] * max_len + for original_len in original_lens + ] + return torch.tensor(attention_mask, device="cuda") + + +# get cell embeddings excluding padding +def mean_nonpadding_embs(embs, original_lens, dim=1): + # create a mask tensor based on padding lengths + mask = torch.arange(embs.size(dim), device=embs.device) < original_lens.unsqueeze(1) + if embs.dim() == 3: + # fill the masked positions in embs with zeros + masked_embs = embs.masked_fill(~mask.unsqueeze(2), 0.0) + + # compute the mean across the non-padding dimensions + mean_embs = masked_embs.sum(dim) / original_lens.view(-1, 1).float() + + elif embs.dim() == 2: + masked_embs = embs.masked_fill(~mask, 0.0) + mean_embs = masked_embs.sum(dim) / original_lens.float() + return mean_embs + + +# get cell embeddings when there is no padding +def compute_nonpadded_cell_embedding(embs, cell_emb_style): + if cell_emb_style == "mean_pool": + return torch.mean(embs, dim=embs.ndim - 2) + + +# quantify shifts for a set of genes +def quant_cos_sims( + perturbation_emb, + original_emb, + cell_states_to_model, + state_embs_dict, + emb_mode="gene", +): + if emb_mode == "gene": + cos = torch.nn.CosineSimilarity(dim=2) + elif emb_mode == "cell": + cos = torch.nn.CosineSimilarity(dim=1) + + # if emb_mode == "gene", can only calculate gene cos sims + # against original cell + if cell_states_to_model is None or emb_mode == "gene": + cos_sims = cos(perturbation_emb, original_emb).to("cuda") + + elif cell_states_to_model is not None and emb_mode == "cell": + possible_states = get_possible_states(cell_states_to_model) + cos_sims = dict(zip(possible_states, [[] for _ in range(len(possible_states))])) + for state in possible_states: + cos_sims[state] = cos_sim_shift( + original_emb, + perturbation_emb, + state_embs_dict[state].to("cuda"), # required to move to cuda here + cos, + ) + + return cos_sims + + +# calculate cos sim shift of perturbation with respect to origin and alternative cell +def cos_sim_shift(original_emb, perturbed_emb, end_emb, cos): + origin_v_end = cos(original_emb, end_emb) + perturb_v_end = cos(perturbed_emb, end_emb) + + return perturb_v_end - origin_v_end + + +def concatenate_cos_sims(cos_sims): + if isinstance(cos_sims, list): + return torch.cat(cos_sims) + else: + for state in cos_sims.keys(): + cos_sims[state] = torch.cat(cos_sims[state]) + return cos_sims + + +def write_perturbation_dictionary(cos_sims_dict: defaultdict, output_path_prefix: str): + with open(f"{output_path_prefix}_raw.pickle", "wb") as fp: + pickle.dump(cos_sims_dict, fp) + + +def tensor_list_to_pd(tensor_list): + tensor = torch.cat(tensor_list).cpu().numpy() + df = pd.DataFrame(tensor) + return df + + +def validate_cell_states_to_model(cell_states_to_model): + if cell_states_to_model is not None: + if len(cell_states_to_model.items()) == 1: + logger.warning( + "The single value dictionary for cell_states_to_model will be " + "replaced with a dictionary with named keys for start, goal, and alternate states. " + "Please specify state_key, start_state, goal_state, and alt_states " + "in the cell_states_to_model dictionary for future use. " + "For example, cell_states_to_model={" + "'state_key': 'disease', " + "'start_state': 'dcm', " + "'goal_state': 'nf', " + "'alt_states': ['hcm', 'other1', 'other2']}" + ) + for key, value in cell_states_to_model.items(): + if (len(value) == 3) and isinstance(value, tuple): + if ( + isinstance(value[0], list) + and isinstance(value[1], list) + and isinstance(value[2], list) + ): + if len(value[0]) == 1 and len(value[1]) == 1: + all_values = value[0] + value[1] + value[2] + if len(all_values) == len(set(all_values)): + continue + # reformat to the new named key format + state_values = flatten_list(list(cell_states_to_model.values())) + + cell_states_to_model = { + "state_key": list(cell_states_to_model.keys())[0], + "start_state": state_values[0][0], + "goal_state": state_values[1][0], + "alt_states": state_values[2:][0], + } + elif set(cell_states_to_model.keys()).issuperset( + {"state_key", "start_state", "goal_state"} + ): + if ( + (cell_states_to_model["state_key"] is None) + or (cell_states_to_model["start_state"] is None) + or (cell_states_to_model["goal_state"] is None) + ): + logger.error( + "Please specify 'state_key', 'start_state', and 'goal_state' in cell_states_to_model." + ) + raise + + if ( + cell_states_to_model["start_state"] + == cell_states_to_model["goal_state"] + ): + logger.error("All states must be unique.") + raise + + if "alt_states" in set(cell_states_to_model.keys()): + if cell_states_to_model["alt_states"] is not None: + if not isinstance(cell_states_to_model["alt_states"], list): + logger.error( + "cell_states_to_model['alt_states'] must be a list (even if it is one element)." + ) + raise + if len(cell_states_to_model["alt_states"]) != len( + set(cell_states_to_model["alt_states"]) + ): + logger.error("All states must be unique.") + raise + else: + cell_states_to_model["alt_states"] = [] + + else: + logger.error( + "cell_states_to_model must only have the following four keys: " + "'state_key', 'start_state', 'goal_state', 'alt_states'." + "For example, cell_states_to_model={" + "'state_key': 'disease', " + "'start_state': 'dcm', " + "'goal_state': 'nf', " + "'alt_states': ['hcm', 'other1', 'other2']}" + ) + raise + + +class GeneIdHandler: + def __init__(self, raise_errors=False): + def invert_dict(dict_obj): + return {v: k for k, v in dict_obj.items()} + + self.raise_errors = raise_errors + + with open(TOKEN_DICTIONARY_FILE, "rb") as f: + self.gene_token_dict = pickle.load(f) + self.token_gene_dict = invert_dict(self.gene_token_dict) + + with open(ENSEMBL_DICTIONARY_FILE, "rb") as f: + self.id_gene_dict = pickle.load(f) + self.gene_id_dict = invert_dict(self.id_gene_dict) + + def ens_to_token(self, ens_id): + if not self.raise_errors: + return self.gene_token_dict.get(ens_id, ens_id) + else: + return self.gene_token_dict[ens_id] + + def token_to_ens(self, token): + if not self.raise_errors: + return self.token_gene_dict.get(token, token) + else: + return self.token_gene_dict[token] + + def ens_to_symbol(self, ens_id): + if not self.raise_errors: + return self.gene_id_dict.get(ens_id, ens_id) + else: + return self.gene_id_dict[ens_id] + + def symbol_to_ens(self, symbol): + if not self.raise_errors: + return self.id_gene_dict.get(symbol, symbol) + else: + return self.id_gene_dict[symbol] + + def token_to_symbol(self, token): + return self.ens_to_symbol(self.token_to_ens(token)) + + def symbol_to_token(self, symbol): + return self.ens_to_token(self.symbol_to_ens(symbol)) diff --git a/geneformer/pretrainer.py b/geneformer/pretrainer.py new file mode 100644 index 0000000000000000000000000000000000000000..b1af8b8b8d204b8bc6a3003037918465f4a54a92 --- /dev/null +++ b/geneformer/pretrainer.py @@ -0,0 +1,640 @@ +""" +Geneformer precollator and pretrainer. + +Huggingface data collator and trainer modified to accommodate single-cell transcriptomics data. +""" +import collections +import math +import pickle +import warnings +from enum import Enum +from typing import Dict, List, Optional, Union + +import numpy as np +import torch +from datasets import Dataset +from packaging import version +from torch.utils.data.sampler import RandomSampler +from transformers import ( + BatchEncoding, + DataCollatorForLanguageModeling, + SpecialTokensMixin, + Trainer, +) +from transformers.file_utils import is_datasets_available, is_sagemaker_dp_enabled +from transformers.trainer_pt_utils import ( + LengthGroupedSampler, +) +from transformers.utils import is_tf_available, is_torch_available, logging, to_py_obj +from transformers.utils.generic import _is_tensorflow, _is_torch + +logger = logging.get_logger(__name__) +EncodedInput = List[int] +VERY_LARGE_INTEGER = int( + 1e30 +) # This is used to set the max input length for a model with infinite size input +LARGE_INTEGER = int( + 1e20 +) # This is used when we need something big but slightly smaller than VERY_LARGE_INTEGER + +if is_sagemaker_dp_enabled(): + import smdistributed.dataparallel.torch.distributed as dist +else: + import torch.distributed as dist + +_is_torch_generator_available = False +if version.parse(torch.__version__) >= version.parse("1.6"): + _is_torch_generator_available = True + + +class ExplicitEnum(Enum): + """ + Enum with more explicit error message for missing values. + """ + + @classmethod + def _missing_(cls, value): + raise ValueError( + "%r is not a valid %s, please select one of %s" + % (value, cls.__name__, str(list(cls._value2member_map_.keys()))) + ) + + +class TruncationStrategy(ExplicitEnum): + """ + Possible values for the ``truncation`` argument in :meth:`PreTrainedTokenizerBase.__call__`. Useful for + tab-completion in an IDE. + """ + + ONLY_FIRST = "only_first" + ONLY_SECOND = "only_second" + LONGEST_FIRST = "longest_first" + DO_NOT_TRUNCATE = "do_not_truncate" + + +class PaddingStrategy(ExplicitEnum): + """ + Possible values for the ``padding`` argument in :meth:`PreTrainedTokenizerBase.__call__`. Useful for tab-completion + in an IDE. + """ + + LONGEST = "longest" + MAX_LENGTH = "max_length" + DO_NOT_PAD = "do_not_pad" + + +class TensorType(ExplicitEnum): + """ + Possible values for the ``return_tensors`` argument in :meth:`PreTrainedTokenizerBase.__call__`. Useful for + tab-completion in an IDE. + """ + + PYTORCH = "pt" + TENSORFLOW = "tf" + NUMPY = "np" + JAX = "jax" + + +class GeneformerPreCollator(SpecialTokensMixin): + def __init__(self, *args, **kwargs) -> None: + super().__init__(mask_token="", pad_token="") + + self.token_dictionary = kwargs.get("token_dictionary") + self.padding_side = "right" + self.model_input_names = ["input_ids"] + + def convert_ids_to_tokens(self, value): + return self.token_dictionary.get(value) + + def _get_padding_truncation_strategies( + self, + padding=False, + truncation=False, + max_length=None, + pad_to_multiple_of=None, + verbose=True, + **kwargs, + ): + """ + Find the correct padding/truncation strategy with backward compatibility for old arguments (truncation_strategy + and pad_to_max_length) and behaviors. + """ + old_truncation_strategy = kwargs.pop("truncation_strategy", "do_not_truncate") + old_pad_to_max_length = kwargs.pop("pad_to_max_length", False) + + # Backward compatibility for previous behavior, maybe we should deprecate it: + # If you only set max_length, it activates truncation for max_length + if max_length is not None and padding is False and truncation is False: + if verbose: + if not self.deprecation_warnings.get( + "Truncation-not-explicitly-activated", False + ): + logger.warning( + "Truncation was not explicitly activated but `max_length` is provided a specific value, " + "please use `truncation=True` to explicitly truncate examples to max length. " + "Defaulting to 'longest_first' truncation strategy. " + "If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy " + "more precisely by providing a specific strategy to `truncation`." + ) + self.deprecation_warnings["Truncation-not-explicitly-activated"] = True + truncation = "longest_first" + + # Get padding strategy + if padding is False and old_pad_to_max_length: + if verbose: + warnings.warn( + "The `pad_to_max_length` argument is deprecated and will be removed in a future version, " + "use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or " + "use `padding='max_length'` to pad to a max length. In this case, you can give a specific " + "length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the " + "maximal input size of the model (e.g. 512 for Bert).", + FutureWarning, + ) + if max_length is None: + padding_strategy = PaddingStrategy.LONGEST + else: + padding_strategy = PaddingStrategy.MAX_LENGTH + elif padding is not False: + if padding is True: + padding_strategy = ( + PaddingStrategy.LONGEST + ) # Default to pad to the longest sequence in the batch + elif not isinstance(padding, PaddingStrategy): + padding_strategy = PaddingStrategy(padding) + elif isinstance(padding, PaddingStrategy): + padding_strategy = padding + else: + padding_strategy = PaddingStrategy.DO_NOT_PAD + + # Get truncation strategy + if truncation is False and old_truncation_strategy != "do_not_truncate": + if verbose: + warnings.warn( + "The `truncation_strategy` argument is deprecated and will be removed in a future version, " + "use `truncation=True` to truncate examples to a max length. You can give a specific " + "length with `max_length` (e.g. `max_length=45`) or leave max_length to None to truncate to the " + "maximal input size of the model (e.g. 512 for Bert). " + " If you have pairs of inputs, you can give a specific truncation strategy selected among " + "`truncation='only_first'` (will only truncate the first sentence in the pairs) " + "`truncation='only_second'` (will only truncate the second sentence in the pairs) " + "or `truncation='longest_first'` (will iteratively remove tokens from the longest sentence in the pairs).", + FutureWarning, + ) + truncation_strategy = TruncationStrategy(old_truncation_strategy) + elif truncation is not False: + if truncation is True: + truncation_strategy = ( + TruncationStrategy.LONGEST_FIRST + ) # Default to truncate the longest sequences in pairs of inputs + elif not isinstance(truncation, TruncationStrategy): + truncation_strategy = TruncationStrategy(truncation) + elif isinstance(truncation, TruncationStrategy): + truncation_strategy = truncation + else: + truncation_strategy = TruncationStrategy.DO_NOT_TRUNCATE + + # Set max length if needed + if max_length is None: + if padding_strategy == PaddingStrategy.MAX_LENGTH: + if self.model_max_length > LARGE_INTEGER: + if verbose: + if not self.deprecation_warnings.get( + "Asking-to-pad-to-max_length", False + ): + logger.warning( + "Asking to pad to max_length but no maximum length is provided and the model has no predefined maximum length. " + "Default to no padding." + ) + self.deprecation_warnings["Asking-to-pad-to-max_length"] = True + padding_strategy = PaddingStrategy.DO_NOT_PAD + else: + max_length = self.model_max_length + + if truncation_strategy != TruncationStrategy.DO_NOT_TRUNCATE: + if self.model_max_length > LARGE_INTEGER: + if verbose: + if not self.deprecation_warnings.get( + "Asking-to-truncate-to-max_length", False + ): + logger.warning( + "Asking to truncate to max_length but no maximum length is provided and the model has no predefined maximum length. " + "Default to no truncation." + ) + self.deprecation_warnings[ + "Asking-to-truncate-to-max_length" + ] = True + truncation_strategy = TruncationStrategy.DO_NOT_TRUNCATE + else: + max_length = self.model_max_length + + # Test if we have a padding token + if padding_strategy != PaddingStrategy.DO_NOT_PAD and ( + not self.pad_token or self.pad_token_id < 0 + ): + raise ValueError( + "Asking to pad but the tokenizer does not have a padding token. " + "Please select a token to use as `pad_token` `(tokenizer.pad_token = tokenizer.eos_token e.g.)` " + "or add a new pad token via `tokenizer.add_special_tokens({'pad_token': '[PAD]'})`." + ) + + # Check that we will truncate to a multiple of pad_to_multiple_of if both are provided + if ( + truncation_strategy != TruncationStrategy.DO_NOT_TRUNCATE + and padding_strategy != PaddingStrategy.DO_NOT_PAD + and pad_to_multiple_of is not None + and max_length is not None + and (max_length % pad_to_multiple_of != 0) + ): + raise ValueError( + f"Truncation and padding are both activated but " + f"truncation length ({max_length}) is not a multiple of pad_to_multiple_of ({pad_to_multiple_of})." + ) + + return padding_strategy, truncation_strategy, max_length, kwargs + + def pad( + self, + encoded_inputs: Union[ + BatchEncoding, + List[BatchEncoding], + Dict[str, EncodedInput], + Dict[str, List[EncodedInput]], + List[Dict[str, EncodedInput]], + ], + padding: Union[bool, str, PaddingStrategy] = True, + max_length: Optional[int] = None, + pad_to_multiple_of: Optional[int] = None, + return_attention_mask: Optional[bool] = True, + return_tensors: Optional[Union[str, TensorType]] = None, + verbose: bool = True, + ) -> BatchEncoding: + """ + Pad a single encoded input or a batch of encoded inputs up to predefined length or to the max sequence length + in the batch. + + Padding side (left/right) padding token ids are defined at the tokenizer level (with ``self.padding_side``, + ``self.pad_token_id`` and ``self.pad_token_type_id``) + + .. note:: + + If the ``encoded_inputs`` passed are dictionary of numpy arrays, PyTorch tensors or TensorFlow tensors, the + result will use the same type unless you provide a different tensor type with ``return_tensors``. In the + case of PyTorch tensors, you will lose the specific device of your tensors however. + + Args: + encoded_inputs (:class:`~transformers.BatchEncoding`, list of :class:`~transformers.BatchEncoding`, :obj:`Dict[str, List[int]]`, :obj:`Dict[str, List[List[int]]` or :obj:`List[Dict[str, List[int]]]`): + Tokenized inputs. Can represent one input (:class:`~transformers.BatchEncoding` or :obj:`Dict[str, + List[int]]`) or a batch of tokenized inputs (list of :class:`~transformers.BatchEncoding`, `Dict[str, + List[List[int]]]` or `List[Dict[str, List[int]]]`) so you can use this method during preprocessing as + well as in a PyTorch Dataloader collate function. + + Instead of :obj:`List[int]` you can have tensors (numpy arrays, PyTorch tensors or TensorFlow tensors), + see the note above for the return type. + padding (:obj:`bool`, :obj:`str` or :class:`~transformers.tokenization_utils_base.PaddingStrategy`, `optional`, defaults to :obj:`True`): + Select a strategy to pad the returned sequences (according to the model's padding side and padding + index) among: + + * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a + single sequence if provided). + * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the + maximum acceptable input length for the model if that argument is not provided. + * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of + different lengths). + max_length (:obj:`int`, `optional`): + Maximum length of the returned list and optionally padding length (see above). + pad_to_multiple_of (:obj:`int`, `optional`): + If set will pad the sequence to a multiple of the provided value. + + This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability + >= 7.5 (Volta). + return_attention_mask (:obj:`bool`, `optional`): + Whether to return the attention mask. If left to the default, will return the attention mask according + to the specific tokenizer's default, defined by the :obj:`return_outputs` attribute. + + `What are attention masks? <../glossary.html#attention-mask>`__ + return_tensors (:obj:`str` or :class:`~transformers.tokenization_utils_base.TensorType`, `optional`): + If set, will return tensors instead of list of python integers. Acceptable values are: + + * :obj:`'tf'`: Return TensorFlow :obj:`tf.constant` objects. + * :obj:`'pt'`: Return PyTorch :obj:`torch.Tensor` objects. + * :obj:`'np'`: Return Numpy :obj:`np.ndarray` objects. + verbose (:obj:`bool`, `optional`, defaults to :obj:`True`): + Whether or not to print more information and warnings. + """ + # If we have a list of dicts, let's convert it in a dict of lists + # We do this to allow using this method as a collate_fn function in PyTorch Dataloader + if isinstance(encoded_inputs, (list, tuple)) and isinstance( + encoded_inputs[0], (dict, BatchEncoding) + ): + encoded_inputs = { + key: [example[key] for example in encoded_inputs] + for key in encoded_inputs[0].keys() + } + + # The model's main input name, usually `input_ids`, has be passed for padding + if self.model_input_names[0] not in encoded_inputs: + raise ValueError( + "You should supply an encoding or a list of encodings to this method" + f"that includes {self.model_input_names[0]}, but you provided {list(encoded_inputs.keys())}" + ) + + required_input = encoded_inputs[self.model_input_names[0]] + + if not required_input: + if return_attention_mask: + encoded_inputs["attention_mask"] = [] + return encoded_inputs + + # If we have PyTorch/TF/NumPy tensors/arrays as inputs, we cast them as python objects + # and rebuild them afterwards if no return_tensors is specified + # Note that we lose the specific device the tensor may be on for PyTorch + + first_element = required_input[0] + if isinstance(first_element, (list, tuple)): + # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element. + index = 0 + while len(required_input[index]) == 0: + index += 1 + if index < len(required_input): + first_element = required_input[index][0] + # At this state, if `first_element` is still a list/tuple, it's an empty one so there is nothing to do. + if not isinstance(first_element, (int, list, tuple)): + if is_tf_available() and _is_tensorflow(first_element): + return_tensors = "tf" if return_tensors is None else return_tensors + elif is_torch_available() and _is_torch(first_element): + return_tensors = "pt" if return_tensors is None else return_tensors + elif isinstance(first_element, np.ndarray): + return_tensors = "np" if return_tensors is None else return_tensors + else: + raise ValueError( + f"type of {first_element} unknown: {type(first_element)}. " + f"Should be one of a python, numpy, pytorch or tensorflow object." + ) + + for key, value in encoded_inputs.items(): + encoded_inputs[key] = to_py_obj(value) + + # Convert padding_strategy in PaddingStrategy + padding_strategy, _, max_length, _ = self._get_padding_truncation_strategies( + padding=padding, max_length=max_length, verbose=verbose + ) + + required_input = encoded_inputs[self.model_input_names[0]] + if required_input and not isinstance(required_input[0], (list, tuple)): + encoded_inputs = self._pad( + encoded_inputs, + max_length=max_length, + padding_strategy=padding_strategy, + pad_to_multiple_of=pad_to_multiple_of, + return_attention_mask=return_attention_mask, + ) + return BatchEncoding(encoded_inputs, tensor_type=return_tensors) + + batch_size = len(required_input) + assert all( + len(v) == batch_size for v in encoded_inputs.values() + ), "Some items in the output dictionary have a different batch size than others." + + if padding_strategy == PaddingStrategy.LONGEST: + max_length = max(len(inputs) for inputs in required_input) + padding_strategy = PaddingStrategy.MAX_LENGTH + + batch_outputs = {} + for i in range(batch_size): + inputs = dict((k, v[i]) for k, v in encoded_inputs.items()) + outputs = self._pad( + inputs, + max_length=max_length, + padding_strategy=padding_strategy, + pad_to_multiple_of=pad_to_multiple_of, + return_attention_mask=return_attention_mask, + ) + + for key, value in outputs.items(): + if key not in batch_outputs: + batch_outputs[key] = [] + batch_outputs[key].append(value) + + return BatchEncoding(batch_outputs, tensor_type=return_tensors) + + def _pad( + self, + encoded_inputs: Union[Dict[str, EncodedInput], BatchEncoding], + max_length: Optional[int] = None, + padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD, + pad_to_multiple_of: Optional[int] = None, + return_attention_mask: Optional[bool] = None, + ) -> dict: + """ + Pad encoded inputs (on left/right and up to predefined length or max length in the batch) + + Args: + encoded_inputs: Dictionary of tokenized inputs (`List[int]`) or batch of tokenized inputs (`List[List[int]]`). + max_length: maximum length of the returned list and optionally padding length (see below). + Will truncate by taking into account the special tokens. + padding_strategy: PaddingStrategy to use for padding. + + - PaddingStrategy.LONGEST Pad to the longest sequence in the batch + - PaddingStrategy.MAX_LENGTH: Pad to the max length (default) + - PaddingStrategy.DO_NOT_PAD: Do not pad + The tokenizer padding sides are defined in self.padding_side: + + - 'left': pads on the left of the sequences + - 'right': pads on the right of the sequences + pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value. + This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability + >= 7.5 (Volta). + return_attention_mask: (optional) Set to False to avoid returning attention mask (default: set to model specifics) + """ + # Load from model defaults + if return_attention_mask is None: + return_attention_mask = "attention_mask" in self.model_input_names + + required_input = encoded_inputs[self.model_input_names[0]] + + if padding_strategy == PaddingStrategy.LONGEST: + max_length = len(required_input) + + if ( + max_length is not None + and pad_to_multiple_of is not None + and (max_length % pad_to_multiple_of != 0) + ): + max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of + + needs_to_be_padded = ( + padding_strategy != PaddingStrategy.DO_NOT_PAD + and len(required_input) != max_length + ) + + if needs_to_be_padded: + difference = max_length - len(required_input) + if self.padding_side == "right": + if return_attention_mask: + encoded_inputs["attention_mask"] = [1] * len(required_input) + [ + 0 + ] * difference + if "token_type_ids" in encoded_inputs: + encoded_inputs["token_type_ids"] = ( + encoded_inputs["token_type_ids"] + + [self.pad_token_type_id] * difference + ) + if "special_tokens_mask" in encoded_inputs: + encoded_inputs["special_tokens_mask"] = ( + encoded_inputs["special_tokens_mask"] + [1] * difference + ) + encoded_inputs[self.model_input_names[0]] = ( + required_input + [self.pad_token_id] * difference + ) + elif self.padding_side == "left": + if return_attention_mask: + encoded_inputs["attention_mask"] = [0] * difference + [1] * len( + required_input + ) + if "token_type_ids" in encoded_inputs: + encoded_inputs["token_type_ids"] = [ + self.pad_token_type_id + ] * difference + encoded_inputs["token_type_ids"] + if "special_tokens_mask" in encoded_inputs: + encoded_inputs["special_tokens_mask"] = [ + 1 + ] * difference + encoded_inputs["special_tokens_mask"] + encoded_inputs[self.model_input_names[0]] = [ + self.pad_token_id + ] * difference + required_input + else: + raise ValueError("Invalid padding strategy:" + str(self.padding_side)) + elif return_attention_mask and "attention_mask" not in encoded_inputs: + encoded_inputs["attention_mask"] = [1] * len(required_input) + + return encoded_inputs + + def get_special_tokens_mask( + self, + token_ids_0: List[int], + token_ids_1: Optional[List[int]] = None, + already_has_special_tokens: bool = False, + ) -> List[int]: + """ + Retrieves sequence ids from a token list that has no special tokens added. This method is called when adding + special tokens using the tokenizer ``prepare_for_model`` or ``encode_plus`` methods. + Args: + token_ids_0 (:obj:`List[int]`): + List of ids of the first sequence. + token_ids_1 (:obj:`List[int]`, `optional`): + List of ids of the second sequence. + already_has_special_tokens (:obj:`bool`, `optional`, defaults to :obj:`False`): + Whether or not the token list is already formatted with special tokens for the model. + Returns: + A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token. + """ + assert already_has_special_tokens and token_ids_1 is None, ( + "You cannot use ``already_has_special_tokens=False`` with this tokenizer. " + "Please use a slow (full python) tokenizer to activate this argument." + "Or set `return_special_tokens_mask=True` when calling the encoding method " + "to get the special tokens mask in any tokenizer. " + ) + + all_special_ids = self.all_special_ids # cache the property + + special_tokens_mask = [ + 1 if token in all_special_ids else 0 for token in token_ids_0 + ] + + return special_tokens_mask + + def convert_tokens_to_ids( + self, tokens: Union[str, List[str]] + ) -> Union[int, List[int]]: + """ + Converts a token string (or a sequence of tokens) in a single integer id (or a sequence of ids), using the + vocabulary. + Args: + tokens (:obj:`str` or :obj:`List[str]`): One or several token(s) to convert to token id(s). + Returns: + :obj:`int` or :obj:`List[int]`: The token id or list of token ids. + """ + if tokens is None: + return None + + if isinstance(tokens, str): + return self._convert_token_to_id_with_added_voc(tokens) + + ids = [] + for token in tokens: + ids.append(self._convert_token_to_id_with_added_voc(token)) + return ids + + def _convert_token_to_id_with_added_voc(self, token): + if token is None: + return None + + return self.token_dictionary.get(token) + + def __len__(self): + return len(self.token_dictionary) + + +class GeneformerPretrainer(Trainer): + def __init__(self, *args, **kwargs): + data_collator = kwargs.get("data_collator", None) + token_dictionary = kwargs.pop("token_dictionary") + mlm = kwargs.pop("mlm", True) + mlm_probability = kwargs.pop("mlm_probability", 0.15) + + if data_collator is None: + precollator = GeneformerPreCollator(token_dictionary=token_dictionary) + + # # Data Collator Functions + data_collator = DataCollatorForLanguageModeling( + tokenizer=precollator, mlm=mlm, mlm_probability=mlm_probability + ) + kwargs["data_collator"] = data_collator + + # load previously saved length vector for dataset to speed up LengthGroupedSampler + # pre-obtained with [dataset[i]["length"] for i in range(len(dataset))] + example_lengths_file = kwargs.pop("example_lengths_file") + if example_lengths_file: + with open(example_lengths_file, "rb") as f: + self.example_lengths = pickle.load(f) + else: + raise Exception( + "example_lengths_file is required; e.g. https://huggingface.co/datasets/ctheodoris/Genecorpus-30M/tree/main/genecorpus_30M_2048_sorted_lengths.pkl" + ) + super().__init__(*args, **kwargs) + + # updated to not use distributed sampler since Trainer now distributes with accelerate + def _get_train_sampler(self) -> Optional[torch.utils.data.sampler.Sampler]: + if not isinstance(self.train_dataset, collections.abc.Sized): + return None + + generator = None + if self.args.world_size <= 1 and _is_torch_generator_available: + generator = torch.Generator() + generator.manual_seed( + int(torch.empty((), dtype=torch.int64).random_().item()) + ) + + # Build the sampler. + if self.args.group_by_length: + if is_datasets_available() and isinstance(self.train_dataset, Dataset): + lengths = self.example_lengths + else: + lengths = None + model_input_name = ( + self.tokenizer.model_input_names[0] + if self.tokenizer is not None + else None + ) + return LengthGroupedSampler( + dataset=self.train_dataset, + batch_size=self.args.train_batch_size, + lengths=lengths, + model_input_name=model_input_name, + generator=generator, + ) + + else: + if _is_torch_generator_available: + return RandomSampler(self.train_dataset, generator=generator) + return RandomSampler(self.train_dataset) diff --git a/geneformer/tokenizer.py b/geneformer/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..b460f028c9d85630b34722a290df6dd40f8908aa --- /dev/null +++ b/geneformer/tokenizer.py @@ -0,0 +1,685 @@ +""" +Geneformer tokenizer. + +**Input data:** + +| *Required format:* raw counts scRNAseq data without feature selection as .loom or anndata file. +| *Required row (gene) attribute:* "ensembl_id"; Ensembl ID for each gene. +| *Required col (cell) attribute:* "n_counts"; total read counts in that cell. + +| *Optional col (cell) attribute:* "filter_pass"; binary indicator of whether cell should be tokenized based on user-defined filtering criteria. +| *Optional col (cell) attributes:* any other cell metadata can be passed on to the tokenized dataset as a custom attribute dictionary as shown below. + +**Usage:** + +.. code-block :: python + + >>> from geneformer import TranscriptomeTokenizer + >>> tk = TranscriptomeTokenizer({"cell_type": "cell_type", "organ_major": "organ"}, nproc=4) + >>> tk.tokenize_data("data_directory", "output_directory", "output_prefix") + +**Description:** + +| Input data is a directory with .loom or .h5ad files containing raw counts from single cell RNAseq data, including all genes detected in the transcriptome without feature selection. The input file type is specified by the argument file_format in the tokenize_data function. + +| The discussion below references the .loom file format, but the analagous labels are required for .h5ad files, just that they will be column instead of row attributes and vice versa due to the transposed format of the two file types. + +| Genes should be labeled with Ensembl IDs (loom row attribute "ensembl_id"), which provide a unique identifer for conversion to tokens. Other forms of gene annotations (e.g. gene names) can be converted to Ensembl IDs via Ensembl Biomart. Cells should be labeled with the total read count in the cell (loom column attribute "n_counts") to be used for normalization. + +| No cell metadata is required, but custom cell attributes may be passed onto the tokenized dataset by providing a dictionary of custom attributes to be added, which is formatted as loom_col_attr_name : desired_dataset_col_attr_name. For example, if the original .loom dataset has column attributes "cell_type" and "organ_major" and one would like to retain these attributes as labels in the tokenized dataset with the new names "cell_type" and "organ", respectively, the following custom attribute dictionary should be provided: {"cell_type": "cell_type", "organ_major": "organ"}. + +| Additionally, if the original .loom file contains a cell column attribute called "filter_pass", this column will be used as a binary indicator of whether to include these cells in the tokenized data. All cells with "1" in this attribute will be tokenized, whereas the others will be excluded. One may use this column to indicate QC filtering or other criteria for selection for inclusion in the final tokenized dataset. + +| If one's data is in other formats besides .loom or .h5ad, one can use the relevant tools (such as Anndata tools) to convert the file to a .loom or .h5ad format prior to running the transcriptome tokenizer. + +| OF NOTE: Take care that the correct token dictionary and gene median file is used for the correct model. + +| OF NOTE: For 95M model series, special_token should be True and model_input_size should be 4096. For 30M model series, special_token should be False and model_input_size should be 2048. + +""" + +from __future__ import annotations + +import logging +import os +import pickle +import warnings +from collections import Counter +from pathlib import Path +from typing import Literal + +import loompy as lp +import numpy as np +import pandas as pd +import scanpy as sc +import scipy.sparse as sp +from datasets import Dataset +from tqdm import tqdm + +warnings.filterwarnings("ignore", message=".*The 'nopython' keyword.*") # noqa +import loompy as lp # noqa + +logger = logging.getLogger(__name__) + +from . import ENSEMBL_MAPPING_FILE, GENE_MEDIAN_FILE, TOKEN_DICTIONARY_FILE + +def rank_genes(gene_vector, gene_tokens): + """ + Rank gene expression vector. + """ + # sort by median-scaled gene values + sorted_indices = np.argsort(-gene_vector) + return gene_tokens[sorted_indices] + + +def tokenize_cell(gene_vector, gene_tokens): + """ + Convert normalized gene expression vector to tokenized rank value encoding. + """ + # create array of gene vector with token indices + # mask undetected genes + nonzero_mask = np.nonzero(gene_vector)[0] + # rank by median-scaled gene values + return rank_genes(gene_vector[nonzero_mask], gene_tokens[nonzero_mask]) + + +def sum_ensembl_ids( + data_directory, + collapse_gene_ids, + gene_mapping_dict, + gene_token_dict, + custom_attr_name_dict, + file_format="loom", + chunk_size=512, +): + if file_format == "loom": + """ + Map Ensembl IDs from gene mapping dictionary. If duplicate Ensembl IDs are found, sum counts together. + """ + with lp.connect(data_directory) as data: + assert ( + "ensembl_id" in data.ra.keys() + ), "'ensembl_id' column missing from data.ra.keys()" + + assert ( + "ensembl_id_collapsed" not in data.ra.keys() + ), "'ensembl_id_collapsed' column already exists in data.ra.keys()" + + assert ( + "n_counts" in data.ca.keys() + ), "'n_counts' column missing from data.ca.keys()" + + if custom_attr_name_dict is not None: + for label in custom_attr_name_dict: + assert label in data.ca.keys(), f"Attribute `{label}` not present in dataset features" + + # Get the ensembl ids that exist in data + ensembl_ids = data.ra.ensembl_id + # Check for duplicate Ensembl IDs if collapse_gene_ids is False. + # Comparing to gene_token_dict here, would not perform any mapping steps + if not collapse_gene_ids: + ensembl_id_check = [ + gene for gene in ensembl_ids if gene in gene_token_dict.keys() + ] + if len(ensembl_id_check) == len(set(ensembl_id_check)): + return data_directory + else: + raise ValueError("Error: data Ensembl IDs non-unique.") + + # Get the genes that exist in the mapping dictionary and the value of those genes + genes_in_map_dict = [gene for gene in ensembl_ids if gene in gene_mapping_dict.keys()] + vals_from_map_dict = [gene_mapping_dict.get(gene) for gene in genes_in_map_dict] + + # if the genes in the mapping dict and the value of those genes are of the same length, + # simply return the mapped values + if(len(set(genes_in_map_dict)) == len(set(vals_from_map_dict))): + mapped_vals = [gene_mapping_dict.get(gene.upper()) for gene in data.ra["ensembl_id"]] + data.ra["ensembl_id_collapsed"] = mapped_vals + return data_directory + # Genes need to be collapsed + else: + dedup_filename = data_directory.with_name( + data_directory.stem + "__dedup.loom" + ) + mapped_vals = [gene_mapping_dict.get(gene.upper()) for gene in data.ra["ensembl_id"]] + data.ra["ensembl_id_collapsed"] = mapped_vals + dup_genes = [ + idx + for idx, count in Counter(data.ra["ensembl_id_collapsed"]).items() + if count > 1 + ] + num_chunks = int(np.ceil(data.shape[1] / chunk_size)) + first_chunk = True + for _, _, view in tqdm( + data.scan(axis=1, batch_size=chunk_size), total=num_chunks + ): + + def process_chunk(view, duplic_genes): + data_count_view = pd.DataFrame( + view, index=data.ra["ensembl_id_collapsed"] + ) + unique_data_df = data_count_view.loc[ + ~data_count_view.index.isin(duplic_genes) + ] + dup_data_df = data_count_view.loc[ + data_count_view.index.isin( + [i for i in duplic_genes if "None" not in i] + ) + ] + summed_data = dup_data_df.groupby(dup_data_df.index).sum() + if not summed_data.index.is_unique: + raise ValueError( + "Error: Ensembl IDs in summed data frame non-unique." + ) + data_count_view = pd.concat( + [unique_data_df, summed_data], axis=0 + ) + if not data_count_view.index.is_unique: + raise ValueError( + "Error: Ensembl IDs in final data frame non-unique." + ) + return data_count_view + + processed_chunk = process_chunk(view[:, :], dup_genes) + processed_array = processed_chunk.to_numpy() + new_row_attrs = {"ensembl_id_collapsed": processed_chunk.index.to_numpy()} + + if "n_counts" not in view.ca.keys(): + total_count_view = np.sum(view[:, :], axis=0).astype(int) + view.ca["n_counts"] = total_count_view + + if first_chunk: # Create the Loom file with the first chunk + lp.create( + f"{dedup_filename}", + processed_array, + row_attrs=new_row_attrs, + col_attrs=view.ca, + ) + first_chunk = False + else: # Append subsequent chunks + with lp.connect(dedup_filename, mode="r+") as dsout: + dsout.add_columns(processed_array, col_attrs=view.ca) + return dedup_filename + + elif file_format == "h5ad": + """ + Map Ensembl IDs from gene mapping dictionary. If duplicate Ensembl IDs are found, sum counts together. + Returns adata object with deduplicated Ensembl IDs. + """ + + data = sc.read_h5ad(str(data_directory)) + + assert ( + "ensembl_id" in data.var.columns + ), "'ensembl_id' column missing from data.var" + + assert ( + "ensembl_id_collapsed" not in data.var.columns + ), "'ensembl_id_collapsed' column already exists in data.var" + assert ( + "n_counts" in data.obs.columns + ), "'n_counts' column missing from data.obs" + + if custom_attr_name_dict is not None: + for label in custom_attr_name_dict: + assert label in data.obs.columns, f"Attribute `{label}` not present in data.obs" + + + # Get the ensembl ids that exist in data + ensembl_ids = data.var.ensembl_id + # Check for duplicate Ensembl IDs if collapse_gene_ids is False. + # Comparing to gene_token_dict here, would not perform any mapping steps + if not collapse_gene_ids: + ensembl_id_check = [ + gene for gene in ensembl_ids if gene in gene_token_dict.keys() + ] + if len(ensembl_id_check) == len(set(ensembl_id_check)): + return data_directory + else: + raise ValueError("Error: data Ensembl IDs non-unique.") + + # Get the genes that exist in the mapping dictionary and the value of those genes + genes_in_map_dict = [gene for gene in ensembl_ids if gene in gene_mapping_dict.keys()] + vals_from_map_dict = [gene_mapping_dict.get(gene) for gene in genes_in_map_dict] + + # if the genes in the mapping dict and the value of those genes are of the same length, + # simply return the mapped values + if(len(set(genes_in_map_dict)) == len(set(vals_from_map_dict))): + data.var["ensembl_id_collapsed"] = data.var.ensembl_id.str.upper().map(gene_mapping_dict) + return data + # Genes need to be collapsed + else: + data.var["ensembl_id_collapsed"] = data.var.ensembl_id.str.upper().map(gene_mapping_dict) + data.var_names = data.var["ensembl_id_collapsed"] + data = data[:, ~data.var.index.isna()] + dup_genes = [ + idx for idx, count in Counter(data.var_names).items() if count > 1 + ] + + num_chunks = int(np.ceil(data.shape[0] / chunk_size)) + + processed_genes = [] + for i in tqdm(range(num_chunks)): + start_idx = i * chunk_size + end_idx = min((i + 1) * chunk_size, data.shape[0]) + data_chunk = data[start_idx:end_idx, :] + + processed_chunks = [] + for dup_gene in dup_genes: + data_dup_gene = data_chunk[:, data_chunk.var_names == dup_gene] + df = pd.DataFrame.sparse.from_spmatrix( + data_dup_gene.X, + index=data_dup_gene.obs_names, + columns=data_dup_gene.var_names, + ) + df_sum = pd.DataFrame(df.sum(axis=1)) + df_sum.columns = [dup_gene] + df_sum.index = data_dup_gene.obs.index + processed_chunks.append(df_sum) + + processed_chunks = pd.concat(processed_chunks, axis=1) + processed_genes.append(processed_chunks) + processed_genes = pd.concat(processed_genes, axis=0) + var_df = pd.DataFrame({"ensembl_id_collapsed": processed_genes.columns}) + var_df.index = processed_genes.columns + processed_genes = sc.AnnData(X=processed_genes, obs=data.obs, var=var_df) + + data_dedup = data[:, ~data.var.index.isin(dup_genes)] # Deduplicated data + data_dedup = sc.concat([data_dedup, processed_genes], axis=1) + data_dedup.obs = data.obs + return data_dedup + + +class TranscriptomeTokenizer: + def __init__( + self, + custom_attr_name_dict=None, + nproc=1, + chunk_size=512, + model_input_size=4096, + special_token=True, + collapse_gene_ids=True, + gene_median_file=GENE_MEDIAN_FILE, + token_dictionary_file=TOKEN_DICTIONARY_FILE, + gene_mapping_file=ENSEMBL_MAPPING_FILE, + ): + """ + Initialize tokenizer. + + **Parameters:** + + custom_attr_name_dict : None, dict + | Dictionary of custom attributes to be added to the dataset. + | Keys are the names of the attributes in the loom file. + | Values are the names of the attributes in the dataset. + nproc : int + | Number of processes to use for dataset mapping. + chunk_size : int = 512 + | Chunk size for anndata tokenizer. + model_input_size : int = 4096 + | Max input size of model to truncate input to. + | For the 30M model series, should be 2048. For the 95M model series, should be 4096. + special_token : bool = True + | Adds CLS token before and EOS token after rank value encoding. + | For the 30M model series, should be False. For the 95M model series, should be True. + collapse_gene_ids : bool = True + | Whether to collapse gene IDs based on gene mapping dictionary. + gene_median_file : Path + | Path to pickle file containing dictionary of non-zero median + | gene expression values across Genecorpus-30M. + token_dictionary_file : Path + | Path to pickle file containing token dictionary (Ensembl IDs:token). + gene_mapping_file : None, Path + | Path to pickle file containing dictionary for collapsing gene IDs. + + """ + # dictionary of custom attributes {output dataset column name: input .loom column name} + self.custom_attr_name_dict = custom_attr_name_dict + + # number of processes for dataset mapping + self.nproc = nproc + + # chunk size for anndata tokenizer + self.chunk_size = chunk_size + + # input size for tokenization + self.model_input_size = model_input_size + + # add CLS and EOS tokens + self.special_token = special_token + + # load dictionary of gene normalization factors + # (non-zero median value of expression across Genecorpus-30M) + with open(gene_median_file, "rb") as f: + self.gene_median_dict = pickle.load(f) + + # load token dictionary (Ensembl IDs:token) + with open(token_dictionary_file, "rb") as f: + self.gene_token_dict = pickle.load(f) + + # check for special token in gene_token_dict + if self.special_token: + if ("" not in self.gene_token_dict.keys()) and ( + "" not in self.gene_token_dict.keys() + ): + logger.error( + " and required in gene_token_dict when special_token = True." + ) + raise + + if not self.special_token: + if ("" in self.gene_token_dict.keys()) and ( + "" in self.gene_token_dict.keys() + ): + logger.warning( + " and are in gene_token_dict but special_token = False. Please note that for 95M model series, special_token should be True." + ) + + # if collapsing duplicate gene IDs + self.collapse_gene_ids = collapse_gene_ids + + # load gene mappings dictionary (Ensembl IDs:Ensembl ID) + if gene_mapping_file is not None: + with open(gene_mapping_file, "rb") as f: + self.gene_mapping_dict = pickle.load(f) + else: + self.gene_mapping_dict = {k: k for k, _ in self.gene_token_dict.items()} + + # gene keys for full vocabulary + self.gene_keys = list(self.gene_token_dict.keys()) + + # Filter gene mapping dict for items that exist in gene_token_dict + gene_keys_set = set(self.gene_token_dict.keys()) + self.gene_mapping_dict = { + k: v for k, v in self.gene_mapping_dict.items() if v in gene_keys_set + } + + # protein-coding and miRNA gene list dictionary for selecting .loom rows for tokenization + self.genelist_dict = dict(zip(self.gene_keys, [True] * len(self.gene_keys))) + + def tokenize_data( + self, + data_directory: Path | str, + output_directory: Path | str, + output_prefix: str, + file_format: Literal["loom", "h5ad"] = "loom", + use_generator: bool = False, + ): + """ + Tokenize .loom files in data_directory and save as tokenized .dataset in output_directory. + + **Parameters:** + + data_directory : Path + | Path to directory containing loom files or anndata files + output_directory : Path + | Path to directory where tokenized data will be saved as .dataset + output_prefix : str + | Prefix for output .dataset + file_format : str + | Format of input files. Can be "loom" or "h5ad". + use_generator : bool + | Whether to use generator or dict for tokenization. + + """ + tokenized_cells, cell_metadata = self.tokenize_files( + Path(data_directory), file_format + ) + tokenized_dataset = self.create_dataset( + tokenized_cells, + cell_metadata, + use_generator=use_generator, + ) + + output_path = (Path(output_directory) / output_prefix).with_suffix(".dataset") + tokenized_dataset.save_to_disk(str(output_path)) + + def tokenize_files( + self, data_directory, file_format: Literal["loom", "h5ad"] = "loom" + ): + tokenized_cells = [] + if self.custom_attr_name_dict is not None: + cell_attr = [attr_key for attr_key in self.custom_attr_name_dict.keys()] + cell_metadata = { + attr_key: [] for attr_key in self.custom_attr_name_dict.values() + } + + # loops through directories to tokenize .loom files + file_found = 0 + # loops through directories to tokenize .loom or .h5ad files + tokenize_file_fn = ( + self.tokenize_loom if file_format == "loom" else self.tokenize_anndata + ) + for file_path in data_directory.glob(f"*.{file_format}"): + file_found = 1 + print(f"Tokenizing {file_path}") + file_tokenized_cells, file_cell_metadata = tokenize_file_fn(file_path) + tokenized_cells += file_tokenized_cells + if self.custom_attr_name_dict is not None: + for k in cell_attr: + cell_metadata[self.custom_attr_name_dict[k]] += file_cell_metadata[ + k + ] + else: + cell_metadata = None + + if file_found == 0: + logger.error( + f"No .{file_format} files found in directory {data_directory}." + ) + raise + return tokenized_cells, cell_metadata + + def tokenize_anndata(self, adata_file_path, target_sum=10_000): + adata = sum_ensembl_ids( + adata_file_path, + self.collapse_gene_ids, + self.gene_mapping_dict, + self.gene_token_dict, + self.custom_attr_name_dict, + file_format="h5ad", + chunk_size=self.chunk_size, + ) + + if self.custom_attr_name_dict is not None: + file_cell_metadata = { + attr_key: [] for attr_key in self.custom_attr_name_dict.keys() + } + + coding_miRNA_loc = np.where( + [self.genelist_dict.get(i, False) for i in adata.var["ensembl_id_collapsed"]] + )[0] + norm_factor_vector = np.array( + [ + self.gene_median_dict[i] + for i in adata.var["ensembl_id_collapsed"][coding_miRNA_loc] + ] + ) + coding_miRNA_ids = adata.var["ensembl_id_collapsed"][coding_miRNA_loc] + coding_miRNA_tokens = np.array( + [self.gene_token_dict[i] for i in coding_miRNA_ids] + ) + + try: + _ = adata.obs["filter_pass"] + except KeyError: + var_exists = False + else: + var_exists = True + + if var_exists: + filter_pass_loc = np.where([i == 1 for i in adata.obs["filter_pass"]])[0] + elif not var_exists: + print( + f"{adata_file_path} has no column attribute 'filter_pass'; tokenizing all cells." + ) + filter_pass_loc = np.array([i for i in range(adata.shape[0])]) + + tokenized_cells = [] + + for i in range(0, len(filter_pass_loc), self.chunk_size): + idx = filter_pass_loc[i : i + self.chunk_size] + + n_counts = adata[idx].obs["n_counts"].values[:, None] + X_view0 = adata[idx, :].X + X_view = X_view0[:, coding_miRNA_loc] + X_norm = X_view / n_counts * target_sum / norm_factor_vector + X_norm = sp.csr_matrix(X_norm) + + tokenized_cells += [ + rank_genes(X_norm[i].data, coding_miRNA_tokens[X_norm[i].indices]) + for i in range(X_norm.shape[0]) + ] + + # add custom attributes for subview to dict + if self.custom_attr_name_dict is not None: + for k in file_cell_metadata.keys(): + file_cell_metadata[k] += adata[idx].obs[k].tolist() + else: + file_cell_metadata = None + + return tokenized_cells, file_cell_metadata + + def tokenize_loom(self, loom_file_path, target_sum=10_000): + if self.custom_attr_name_dict is not None: + file_cell_metadata = { + attr_key: [] for attr_key in self.custom_attr_name_dict.keys() + } + loom_file_path_original = loom_file_path + + dedup_filename = loom_file_path.with_name(loom_file_path.stem + "__dedup.loom") + loom_file_path = sum_ensembl_ids( + loom_file_path, + self.collapse_gene_ids, + self.gene_mapping_dict, + self.gene_token_dict, + self.custom_attr_name_dict, + file_format="loom", + chunk_size=self.chunk_size, + ) + + with lp.connect(str(loom_file_path)) as data: + # define coordinates of detected protein-coding or miRNA genes and vector of their normalization factors + coding_miRNA_loc = np.where( + [self.genelist_dict.get(i, False) for i in data.ra["ensembl_id_collapsed"]] + )[0] + norm_factor_vector = np.array( + [ + self.gene_median_dict[i] + for i in data.ra["ensembl_id_collapsed"][coding_miRNA_loc] + ] + ) + coding_miRNA_ids = data.ra["ensembl_id_collapsed"][coding_miRNA_loc] + coding_miRNA_tokens = np.array( + [self.gene_token_dict[i] for i in coding_miRNA_ids] + ) + + # define coordinates of cells passing filters for inclusion (e.g. QC) + try: + data.ca["filter_pass"] + except AttributeError: + var_exists = False + else: + var_exists = True + + if var_exists: + filter_pass_loc = np.where([i == 1 for i in data.ca["filter_pass"]])[0] + elif not var_exists: + print( + f"{loom_file_path} has no column attribute 'filter_pass'; tokenizing all cells." + ) + filter_pass_loc = np.array([i for i in range(data.shape[1])]) + + # scan through .loom files and tokenize cells + tokenized_cells = [] + for _ix, _selection, view in data.scan( + items=filter_pass_loc, axis=1, batch_size=self.chunk_size + ): + # select subview with protein-coding and miRNA genes + subview = view.view[coding_miRNA_loc, :] + + # normalize by total counts per cell and multiply by 10,000 to allocate bits to precision + # and normalize by gene normalization factors + subview_norm_array = ( + subview[:, :] + / subview.ca.n_counts + * target_sum + / norm_factor_vector[:, None] + ) + # tokenize subview gene vectors + tokenized_cells += [ + tokenize_cell(subview_norm_array[:, i], coding_miRNA_tokens) + for i in range(subview_norm_array.shape[1]) + ] + + # add custom attributes for subview to dict + if self.custom_attr_name_dict is not None: + for k in file_cell_metadata.keys(): + file_cell_metadata[k] += subview.ca[k].tolist() + else: + file_cell_metadata = None + + if str(dedup_filename) == str(loom_file_path): + os.remove(str(dedup_filename)) + + with lp.connect(str(loom_file_path_original)) as data: + if "ensembl_id_collapsed" in data.ra.keys(): + del data.ra["ensembl_id_collapsed"] + + + return tokenized_cells, file_cell_metadata + + def create_dataset( + self, + tokenized_cells, + cell_metadata, + use_generator=False, + keep_uncropped_input_ids=False, + ): + print("Creating dataset.") + # create dict for dataset creation + dataset_dict = {"input_ids": tokenized_cells} + if self.custom_attr_name_dict is not None: + dataset_dict.update(cell_metadata) + + # create dataset + if use_generator: + + def dict_generator(): + for i in range(len(tokenized_cells)): + yield {k: dataset_dict[k][i] for k in dataset_dict.keys()} + + output_dataset = Dataset.from_generator(dict_generator, num_proc=self.nproc) + else: + output_dataset = Dataset.from_dict(dataset_dict) + + def format_cell_features(example): + # Store original uncropped input_ids in separate feature + if keep_uncropped_input_ids: + example["input_ids_uncropped"] = example["input_ids"] + example["length_uncropped"] = len(example["input_ids"]) + + # Truncate/Crop input_ids to input size + if self.special_token: + example["input_ids"] = example["input_ids"][ + 0 : self.model_input_size - 2 + ] # truncate to leave space for CLS and EOS token + example["input_ids"] = np.insert( + example["input_ids"], 0, self.gene_token_dict.get("") + ) + example["input_ids"] = np.insert( + example["input_ids"], + len(example["input_ids"]), + self.gene_token_dict.get(""), + ) + else: + # Truncate/Crop input_ids to input size + example["input_ids"] = example["input_ids"][0 : self.model_input_size] + example["length"] = len(example["input_ids"]) + + return example + + output_dataset_truncated = output_dataset.map( + format_cell_features, num_proc=self.nproc + ) + return output_dataset_truncated diff --git a/generation_config.json b/generation_config.json new file mode 100644 index 0000000000000000000000000000000000000000..6f690c1f39b5b262e6b898b8891afd9d44978f11 --- /dev/null +++ b/generation_config.json @@ -0,0 +1,5 @@ +{ + "_from_model_config": true, + "pad_token_id": 0, + "transformers_version": "4.37.1" +} diff --git a/gf-12L-30M-i2048/config.json b/gf-12L-30M-i2048/config.json new file mode 100644 index 0000000000000000000000000000000000000000..52a12424cea85facdf0ca0c507908506daae7ea7 --- /dev/null +++ b/gf-12L-30M-i2048/config.json @@ -0,0 +1,23 @@ +{ + "architectures": [ + "BertForMaskedLM" + ], + "attention_probs_dropout_prob": 0.02, + "gradient_checkpointing": false, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 512, + "initializer_range": 0.02, + "intermediate_size": 1024, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 2048, + "model_type": "bert", + "num_attention_heads": 8, + "num_hidden_layers": 12, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "transformers_version": "4.6.0", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 25426 +} diff --git a/gf-12L-95M-i4096/config.json b/gf-12L-95M-i4096/config.json new file mode 100755 index 0000000000000000000000000000000000000000..86e20c35e6f257f0daeb00ebb92a0751d12d8fff --- /dev/null +++ b/gf-12L-95M-i4096/config.json @@ -0,0 +1,24 @@ +{ + "architectures": [ + "BertForMaskedLM" + ], + "attention_probs_dropout_prob": 0.02, + "classifier_dropout": null, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 512, + "initializer_range": 0.02, + "intermediate_size": 1024, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 4096, + "model_type": "bert", + "num_attention_heads": 8, + "num_hidden_layers": 12, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "torch_dtype": "float32", + "transformers_version": "4.37.1", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 20275 +} diff --git a/gf-12L-95M-i4096/generation_config.json b/gf-12L-95M-i4096/generation_config.json new file mode 100755 index 0000000000000000000000000000000000000000..6f690c1f39b5b262e6b898b8891afd9d44978f11 --- /dev/null +++ b/gf-12L-95M-i4096/generation_config.json @@ -0,0 +1,5 @@ +{ + "_from_model_config": true, + "pad_token_id": 0, + "transformers_version": "4.37.1" +} diff --git a/gf-12L-95M-i4096_CLcancer/config.json b/gf-12L-95M-i4096_CLcancer/config.json new file mode 100755 index 0000000000000000000000000000000000000000..a7793eb2ea27b28f1f4c5b9974d30c98b4afe8a6 --- /dev/null +++ b/gf-12L-95M-i4096_CLcancer/config.json @@ -0,0 +1,25 @@ +{ + "_name_or_path": "/gladstone/theodoris/lab/pretrained_models/encoder/240402_194213_geneformer_94M_L12_emb512_SL4096_E3_B4_LR0.0005_LScosine_WU5000_Oadamw_DS8/models", + "architectures": [ + "BertForMaskedLM" + ], + "attention_probs_dropout_prob": 0.02, + "classifier_dropout": null, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 512, + "initializer_range": 0.02, + "intermediate_size": 1024, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 4096, + "model_type": "bert", + "num_attention_heads": 8, + "num_hidden_layers": 12, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "torch_dtype": "float32", + "transformers_version": "4.37.1", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 20275 +} diff --git a/gf-12L-95M-i4096_CLcancer/generation_config.json b/gf-12L-95M-i4096_CLcancer/generation_config.json new file mode 100755 index 0000000000000000000000000000000000000000..6f690c1f39b5b262e6b898b8891afd9d44978f11 --- /dev/null +++ b/gf-12L-95M-i4096_CLcancer/generation_config.json @@ -0,0 +1,5 @@ +{ + "_from_model_config": true, + "pad_token_id": 0, + "transformers_version": "4.37.1" +} diff --git a/gf-20L-95M-i4096/config.json b/gf-20L-95M-i4096/config.json new file mode 100755 index 0000000000000000000000000000000000000000..db949ba1ae442ad3b9e52fd8b7922c6b936ef98c --- /dev/null +++ b/gf-20L-95M-i4096/config.json @@ -0,0 +1,24 @@ +{ + "architectures": [ + "BertForMaskedLM" + ], + "attention_probs_dropout_prob": 0.02, + "classifier_dropout": null, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 896, + "initializer_range": 0.02, + "intermediate_size": 1792, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 4096, + "model_type": "bert", + "num_attention_heads": 14, + "num_hidden_layers": 20, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "torch_dtype": "float32", + "transformers_version": "4.37.1", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 20275 +} diff --git a/gf-20L-95M-i4096/generation_config.json b/gf-20L-95M-i4096/generation_config.json new file mode 100755 index 0000000000000000000000000000000000000000..6f690c1f39b5b262e6b898b8891afd9d44978f11 --- /dev/null +++ b/gf-20L-95M-i4096/generation_config.json @@ -0,0 +1,5 @@ +{ + "_from_model_config": true, + "pad_token_id": 0, + "transformers_version": "4.37.1" +} diff --git a/gf-6L-30M-i2048/config.json b/gf-6L-30M-i2048/config.json new file mode 100644 index 0000000000000000000000000000000000000000..d131b7026d684013f988cc9e3dcae2e5a284bc0e --- /dev/null +++ b/gf-6L-30M-i2048/config.json @@ -0,0 +1,23 @@ +{ + "architectures": [ + "BertForMaskedLM" + ], + "attention_probs_dropout_prob": 0.02, + "gradient_checkpointing": false, + "hidden_act": "relu", + "hidden_dropout_prob": 0.02, + "hidden_size": 256, + "initializer_range": 0.02, + "intermediate_size": 512, + "layer_norm_eps": 1e-12, + "max_position_embeddings": 2048, + "model_type": "bert", + "num_attention_heads": 4, + "num_hidden_layers": 6, + "pad_token_id": 0, + "position_embedding_type": "absolute", + "transformers_version": "4.6.0", + "type_vocab_size": 2, + "use_cache": true, + "vocab_size": 25426 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..0cb09a2593f3a727090f7cf9f7eacd36edd8ddbd --- /dev/null +++ b/requirements.txt @@ -0,0 +1,25 @@ +anndata>=0.9 +datasets>=2.12 +hyperopt>=0.2 +loompy>=3.0 +matplotlib>=3.7 +numpy>=1.23 +optuna>=3.6 +optuna-integration>=3.6 +packaging>=23.0 +pandas>=2.0 +peft>=0.11.1 +pyarrow>=12.0 +pytz>=2023.0 +ray>=2.6 +scanpy>=1.9 +scikit_learn>=1.2 +scipy>=1.10 +seaborn>=0.12 +setuptools>=65.6 +statsmodels>=0.14 +tdigest>=0.5.2 +tensorboard>=2.15 +torch>=2.0.1 +tqdm>=4.65 +transformers>=4.40 diff --git a/setup.py b/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..6dde9eefad8c76e3d1e41ae187f2215bdbc93db5 --- /dev/null +++ b/setup.py @@ -0,0 +1,42 @@ +from setuptools import setup, find_packages + +setup( + name="geneformer", + version="0.1.0", + author="Christina Theodoris", + author_email="christina.theodoris@gladstone.ucsf.edu", + description="Geneformer is a transformer model pretrained \ + on a large-scale corpus of single \ + cell transcriptomes to enable context-aware \ + predictions in settings with limited data in \ + network biology.", + packages=find_packages(), + python_requires=">=3.10", + include_package_data=True, + install_requires=[ + "anndata", + "datasets", + "loompy", + "matplotlib", + "numpy", + "optuna", + "optuna-integration", + "packaging", + "pandas", + "peft", + "pyarrow", + "pytz", + "ray", + "scanpy", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "statsmodels", + "tdigest", + "tensorboard", + "torch", + "tqdm", + "transformers", + ], +)