diff --git a/.github/workflows/run-tests.yml b/.github/workflows/run-tests.yml index 8a0f812..9651a54 100644 --- a/.github/workflows/run-tests.yml +++ b/.github/workflows/run-tests.yml @@ -46,13 +46,12 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install tox coverage + pip install "tox<4.24" coverage - name: Run tests run: >- - pipx run --python '${{ steps.setup-python.outputs.python-path }}' tox - -- -rFEx --durations 10 --color yes --cov --cov-branch --cov-report=xml # pytest args + -- -rFEx --durations 10 --color yes --cov --cov-branch --cov-report=xml - name: Check for codecov token availability id: codecov-check diff --git a/docs/tutorials/2-variant-effect-prediction.ipynb b/docs/tutorials/2-variant-effect-prediction.ipynb index fb61bce..3777367 100644 --- a/docs/tutorials/2-variant-effect-prediction.ipynb +++ b/docs/tutorials/2-variant-effect-prediction.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -74,30 +74,63 @@ " genes and variants mapped based on these column not based on the genomic\n", " locus based on the annotaiton.\n", "\n", + " >>> decima vep -v \"data/sample.vcf\" -o \"vep_results.parquet\" --distance-\n", + " type tss --min-distance 50000 --max-distance 100000 # predict for\n", + " variants within 50kb of the TSS and 100kb of the TSS\n", + "\n", + " >>> decima vep -v \"data/sample.vcf\" -o \"vep_results.parquet\" --save-\n", + " replicates # save the replicates in the output parquet file\n", + "\n", + " >>> decima vep -v \"data/sample.vcf\" -o \"vep_results.parquet\" --genome\n", + " \"hg38\" # use hg38 genome build\n", + "\n", + " >>> decima vep -v \"data/sample.vcf\" -o \"vep_results.parquet\" --genome\n", + " \"path/to/fasta/hg38.fa\" # use custom genome build\n", + "\n", "Options:\n", - " -v, --variants PATH Path to the variant file .vcf file\n", - " -o, --output_pq PATH Path to the output parquet file.\n", - " --tasks TEXT Tasks to predict. If not provided, all tasks will\n", - " be predicted.\n", - " --chunksize INTEGER Number of variants to process in each chunk.\n", - " Loading variants in chunks is more memory\n", - " efficient.This chuck of variants will be process\n", - " and saved to output parquet file before contineus\n", - " to next chunk. Default: 10_000.\n", - " --model INTEGER Model to use for variant effect prediction either\n", - " replicate number or path to the model.\n", - " --device TEXT Device to use. Default: None which automatically\n", - " selects the best device.\n", - " --batch-size INTEGER Batch size for the model. Default: 1.\n", - " --num-workers INTEGER Number of workers for the loader. Default: 1.\n", - " --max-distance FLOAT Maximum distance from the TSS. Default: 524288.\n", - " --max-distance-type TEXT Type of maximum distance. Default: tss.\n", - " --include-cols TEXT Columns to include in the output in the original\n", - " tsv file to include in the output parquet file.\n", - " Default: None.\n", - " --gene-col TEXT Column name for gene names. Default: None.\n", - " --genome TEXT Genome build. Default: hg38.\n", - " --help Show this message and exit.\n", + " -v, --variants PATH Path to the variant .vcf file. VCF file needs to\n", + " be normalized. Try normalizing th vcf file in\n", + " case of an error. `bcftools norm -f ref.fasta\n", + " input.vcf.gz -o output.vcf.gz`\n", + " -o, --output_pq PATH Path to the output parquet file.\n", + " --tasks TEXT Tasks to predict. If not provided, all tasks will\n", + " be predicted.\n", + " --chunksize INTEGER Number of variants to process in each chunk.\n", + " Loading variants in chunks is more memory\n", + " efficient.This chuck of variants will be process\n", + " and saved to output parquet file before contineus\n", + " to next chunk. Default: 10_000.\n", + " --model TEXT `0`, `1`, `2`, `3`, `ensemble` or a path or a\n", + " comma-separated list of paths to safetensor files\n", + " to perform variant effect prediction. Default:\n", + " `ensemble`.\n", + " --metadata TEXT Path to the metadata anndata file or name of the\n", + " model. If not provided, the compabilite metadata\n", + " for the model will be used. Default: ensemble.\n", + " --device TEXT Device to use. Default: None which automatically\n", + " selects the best device.\n", + " --batch-size INTEGER Batch size for the model. Default: 8\n", + " --num-workers INTEGER Number of workers for the loader. Default: 4\n", + " --distance-type TEXT Type of distance. Default: tss.\n", + " --min-distance FLOAT Minimum distance from the end of the gene.\n", + " Default: 0.\n", + " --max-distance FLOAT Maximum distance from the TSS. Default: 524288.\n", + " --include-cols TEXT Columns to include in the output in the original\n", + " tsv file to include in the output parquet file.\n", + " Default: None.\n", + " --gene-col TEXT Column name for gene names. Default: None.\n", + " --genome TEXT Genome build. Default: hg38.\n", + " --save-replicates Save the replicates in the output parquet file.\n", + " Default: False. Only supported for ensemble\n", + " models.\n", + " --disable-reference-cache Disables the reference cache which significantly\n", + " speeds up the computation by caching the\n", + " reference expression predictios in the metadata.\n", + " --float-precision TEXT Floating-point precision to be used in\n", + " calculations. Avaliable options include:\n", + " '16-true', '16-mixed', 'bf16-true', 'bf16-mixed',\n", + " '32-true', '64-true', '32', '16', and 'bf16'.\n", + " --help Show this message and exit.\n", "\u001b[0m" ] } @@ -131,16 +164,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "decima - INFO - Using device: 0 and genome: hg38\n", + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n", + "decima - INFO - Performing predictions on VariantDataset(48 variants from ['chr1'] between 516455 and 110234512 bp from TSS)\n", + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/lightning_fabric/plugins/environments/slurm.py:204: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /gpfs/scratchfs01/site/u/lala8/conda/envs/decima/bin ...\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\u001b[2KPredicting \u001b[35m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m 96/96 \u001b[2m0:01:56 • 0:00:00\u001b[0m \u001b[2;4m0.71it/s\u001b[0m it/s\u001b[0m it/s\u001b[0m \n", + "\u001b[?25hdecima - WARNING - Warnings:\n", + "decima - WARNING - allele_mismatch_with_reference_genome: 10 alleles out of 48 predictions mismatched with the genome file /home/lala8/.local/share/genomes/hg38/hg38.fa. If this is not expected, please check if you are using the correct genome version.\n", + "\u001b[0m" + ] + } + ], "source": [ "! decima vep -v \"data/sample.vcf\" -o \"vep_vcf_results.parquet\"" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -148,17 +201,17 @@ "output_type": "stream", "text": [ "unknown: 0 / 48 \n", - "allele_mismatch_with_reference_genome: 26 / 48 \n" + "allele_mismatch_with_reference_genome: 10 / 48 \n" ] } ], "source": [ - "! cat vep_vcf_results.parquet.warnings.log" + "! cat vep_vcf_results.warnings.log" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -219,16 +272,16 @@ "
| \n", + " | cell_type | \n", + "tissue | \n", + "organ | \n", + "disease | \n", + "study | \n", + "dataset | \n", + "region | \n", + "subregion | \n", + "celltype_coarse | \n", + "n_cells | \n", + "total_counts | \n", + "n_genes | \n", + "size_factor | \n", + "train_pearson | \n", + "val_pearson | \n", + "test_pearson | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| agg_0 | \n", + "Amygdala excitatory | \n", + "Amygdala_Amygdala | \n", + "CNS | \n", + "healthy | \n", + "jhpce#tran2021 | \n", + "brain_atlas | \n", + "Amygdala | \n", + "Amygdala | \n", + "NaN | \n", + "331 | \n", + "1.592883e+07 | \n", + "17000 | \n", + "41431.465186 | \n", + "0.942459 | \n", + "0.841377 | \n", + "0.865640 | \n", + "
| agg_1 | \n", + "Amygdala excitatory | \n", + "Amygdala_Basolateral nuclear group (BLN) - lat... | \n", + "CNS | \n", + "healthy | \n", + "SCR_016152 | \n", + "brain_atlas | \n", + "Amygdala | \n", + "Basolateral nuclear group (BLN) - lateral nucl... | \n", + "NaN | \n", + "11369 | \n", + "2.952133e+08 | \n", + "18080 | \n", + "40765.341481 | \n", + "0.943098 | \n", + "0.838936 | \n", + "0.861092 | \n", + "
| agg_2 | \n", + "Amygdala excitatory | \n", + "Amygdala_Bed nucleus of stria terminalis and n... | \n", + "CNS | \n", + "healthy | \n", + "SCR_016152 | \n", + "brain_atlas | \n", + "Amygdala | \n", + "Bed nucleus of stria terminalis and nearby - BNST | \n", + "NaN | \n", + "139 | \n", + "2.593231e+06 | \n", + "15418 | \n", + "42556.387020 | \n", + "0.952170 | \n", + "0.854544 | \n", + "0.866654 | \n", + "
| agg_3 | \n", + "Amygdala excitatory | \n", + "Amygdala_Central nuclear group - CEN | \n", + "CNS | \n", + "healthy | \n", + "SCR_016152 | \n", + "brain_atlas | \n", + "Amygdala | \n", + "Central nuclear group - CEN | \n", + "NaN | \n", + "3892 | \n", + "9.946371e+07 | \n", + "17959 | \n", + "42884.641430 | \n", + "0.959744 | \n", + "0.863585 | \n", + "0.881554 | \n", + "
| agg_4 | \n", + "Amygdala excitatory | \n", + "Amygdala_Corticomedial nuclear group (CMN) - a... | \n", + "CNS | \n", + "healthy | \n", + "SCR_016152 | \n", + "brain_atlas | \n", + "Amygdala | \n", + "Corticomedial nuclear group (CMN) - anterior c... | \n", + "NaN | \n", + "2945 | \n", + "1.281619e+08 | \n", + "17885 | \n", + "41816.741933 | \n", + "0.951365 | \n", + "0.854304 | \n", + "0.868902 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| agg_9533 | \n", + "vascular associated smooth muscle cell | \n", + "upper lobe of right lung | \n", + "lung | \n", + "NA | \n", + "ENCODE | \n", + "scimilarity | \n", + "nan | \n", + "nan | \n", + "NaN | \n", + "21 | \n", + "3.483375e+04 | \n", + "8515 | \n", + "35404.911768 | \n", + "0.735213 | \n", + "0.665647 | \n", + "0.654491 | \n", + "
| agg_9535 | \n", + "vascular associated smooth muscle cell | \n", + "urinary bladder | \n", + "urinary | \n", + "healthy | \n", + "GSE129845 | \n", + "scimilarity | \n", + "nan | \n", + "nan | \n", + "NaN | \n", + "24 | \n", + "8.498500e+04 | \n", + "7337 | \n", + "26189.415789 | \n", + "0.809852 | \n", + "0.690022 | \n", + "0.656160 | \n", + "
| agg_9536 | \n", + "vascular associated smooth muscle cell | \n", + "uterus | \n", + "uterus | \n", + "NA | \n", + "ENCODE | \n", + "scimilarity | \n", + "nan | \n", + "nan | \n", + "NaN | \n", + "272 | \n", + "5.700762e+05 | \n", + "14769 | \n", + "44938.403867 | \n", + "0.915329 | \n", + "0.808941 | \n", + "0.839993 | \n", + "
| agg_9537 | \n", + "vascular associated smooth muscle cell | \n", + "uterus | \n", + "uterus | \n", + "healthy | \n", + "e5f58829-1a66-40b5-a624-9046778e74f5 | \n", + "scimilarity | \n", + "nan | \n", + "nan | \n", + "NaN | \n", + "472 | \n", + "1.089170e+07 | \n", + "14514 | \n", + "30145.422152 | \n", + "0.852339 | \n", + "0.717682 | \n", + "0.727469 | \n", + "
| agg_9538 | \n", + "vascular associated smooth muscle cell | \n", + "vasculature | \n", + "vasculature | \n", + "healthy | \n", + "e5f58829-1a66-40b5-a624-9046778e74f5 | \n", + "scimilarity | \n", + "nan | \n", + "nan | \n", + "NaN | \n", + "1853 | \n", + "5.992697e+07 | \n", + "16764 | \n", + "36464.273371 | \n", + "0.909855 | \n", + "0.780413 | \n", + "0.796351 | \n", + "
8856 rows × 16 columns
\n", + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n", + "\n" + ], "text/plain": [ - "Predicting: | | 0/? [00:00, ?it/s]" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n" ] }, "metadata": {}, "output_type": "display_data" }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warnings:\n", + "allele_mismatch_with_reference_genome: 13 alleles out of 82 predictions mismatched with the genome file /home/lala8/.local/share/genomes/hg38/hg38.fa. If this is not expected, please check if you are using the correct genome version.\n" + ] + }, { "data": { "text/html": [ @@ -2080,16 +2523,16 @@ "
/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n", + "\n" + ], "text/plain": [ - "Predicting: | | 0/? [00:00, ?it/s]" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warnings:\n", + "allele_mismatch_with_reference_genome: 13 alleles out of 82 predictions mismatched with the genome file /home/lala8/.local/share/genomes/hg38/hg38.fa. If this is not expected, please check if you are using the correct genome version.\n" + ] } ], "source": [ @@ -2441,7 +2895,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -2502,16 +2956,16 @@ "
/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n", + "\n" + ], "text/plain": [ - "Predicting: | | 0/? [00:00, ?it/s]" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warnings:\n", + "allele_mismatch_with_reference_genome: 10 alleles out of 48 predictions mismatched with the genome file /home/lala8/.local/share/genomes/hg38/hg38.fa. If this is not expected, please check if you are using the correct genome version.\n" + ] } ], "source": [ @@ -2863,7 +3328,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -2924,16 +3389,16 @@ "
/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n", + "\n" + ], "text/plain": [ - "Predicting: | | 0/? [00:00, ?it/s]" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -4690,12 +5144,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The `preds` are predicted expression for `alt - ref` alleles for each variant:" + "The `preds` are the difference between `alt - ref` allele predictions for each variant-gene pair, i.e. the predicted log fold change in gene expression." ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -4704,7 +5158,7 @@ "(82, 8856)" ] }, - "execution_count": 25, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -4715,28 +5169,28 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[-3.1028390e-03, -3.5525560e-03, -3.5931766e-03, ...,\n", - " -5.2702725e-03, -3.3913553e-03, -6.6891909e-03],\n", - " [ 1.1469424e-04, 1.7350912e-04, 8.1568956e-05, ...,\n", - " 1.3417006e-04, 1.1980534e-05, -2.7149916e-05],\n", - " [ 6.0230494e-05, -8.2150102e-05, -2.6747584e-05, ...,\n", - " -2.7078092e-03, -1.8020868e-03, -3.0442923e-03],\n", + "array([[-2.8905511e-02, -3.0458324e-02, -2.7693681e-02, ...,\n", + " -1.3502419e-02, 8.7248422e-03, 1.7261244e-03],\n", + " [-2.9755570e-04, -2.7861074e-04, -1.2444891e-04, ...,\n", + " -3.7071109e-04, 1.9611418e-04, -8.2259066e-05],\n", + " [ 5.6408532e-04, 1.1925958e-04, -4.3001957e-05, ...,\n", + " 2.8621778e-04, 7.6048309e-04, 2.2458541e-03],\n", " ...,\n", - " [ 5.8137625e-04, 6.4936280e-04, 4.9999356e-04, ...,\n", - " 8.4596872e-04, 1.6248971e-04, 5.3709745e-04],\n", - " [ 2.6370510e-03, 2.7481169e-03, 1.8703863e-03, ...,\n", - " 5.3109229e-04, -1.4962628e-04, -3.7675351e-04],\n", - " [-2.8469041e-03, -3.2258853e-03, -2.4763122e-03, ...,\n", - " -3.5528541e-03, -8.5747242e-04, -2.2805035e-03]], dtype=float32)" + " [-2.1314561e-02, -2.1281566e-02, -2.0599853e-02, ...,\n", + " -1.9413859e-02, -2.6478251e-02, -2.1747496e-02],\n", + " [ 2.5212765e-04, 4.7219824e-04, 3.2710657e-04, ...,\n", + " 3.1447969e-04, 4.4250442e-04, 5.5153947e-04],\n", + " [ 2.3546554e-03, 1.8186197e-03, 1.9949824e-03, ...,\n", + " -1.5318021e-03, 2.7205609e-03, -3.7190318e-04]], dtype=float32)" ] }, - "execution_count": 26, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -4747,16 +5201,17 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Counter({'allele_mismatch_with_reference_genome': 26, 'unknown': 0})" + "Counter({'allele_mismatch_with_reference_genome': tensor(13),\n", + " 'unknown': tensor(0)})" ] }, - "execution_count": 27, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -4774,7 +5229,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -4784,7 +5239,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -4793,7 +5248,7 @@ "torch.Size([2, 5, 524288])" ] }, - "execution_count": 29, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -4804,7 +5259,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -4838,7 +5293,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
8856 rows × 3 columns
\n", + "8856 rows × 16 columns
\n", "" ], "text/plain": [ - " STRADA ETV4 USP25\n", - "agg_0 3.060561 2.882100 3.469085\n", - "agg_1 3.117702 2.825738 3.596372\n", - "agg_2 3.156642 3.122381 3.718749\n", - "agg_3 3.214047 3.204670 3.629874\n", - "agg_4 3.103570 3.032028 3.512117\n", - "... ... ... ...\n", - "agg_9533 2.313220 2.173597 3.156157\n", - "agg_9535 0.952112 0.956720 1.250005\n", - "agg_9536 2.779494 2.705945 3.530610\n", - "agg_9537 1.342694 1.407407 1.867070\n", - "agg_9538 1.745080 1.633314 2.082985\n", + " cell_type \\\n", + "agg_0 Amygdala excitatory \n", + "agg_1 Amygdala excitatory \n", + "agg_2 Amygdala excitatory \n", + "agg_3 Amygdala excitatory \n", + "agg_4 Amygdala excitatory \n", + "... ... \n", + "agg_9533 vascular associated smooth muscle cell \n", + "agg_9535 vascular associated smooth muscle cell \n", + "agg_9536 vascular associated smooth muscle cell \n", + "agg_9537 vascular associated smooth muscle cell \n", + "agg_9538 vascular associated smooth muscle cell \n", "\n", - "[8856 rows x 3 columns]" + " tissue organ \\\n", + "agg_0 Amygdala_Amygdala CNS \n", + "agg_1 Amygdala_Basolateral nuclear group (BLN) - lat... CNS \n", + "agg_2 Amygdala_Bed nucleus of stria terminalis and n... CNS \n", + "agg_3 Amygdala_Central nuclear group - CEN CNS \n", + "agg_4 Amygdala_Corticomedial nuclear group (CMN) - a... CNS \n", + "... ... ... \n", + "agg_9533 upper lobe of right lung lung \n", + "agg_9535 urinary bladder urinary \n", + "agg_9536 uterus uterus \n", + "agg_9537 uterus uterus \n", + "agg_9538 vasculature vasculature \n", + "\n", + " disease study dataset \\\n", + "agg_0 healthy jhpce#tran2021 brain_atlas \n", + "agg_1 healthy SCR_016152 brain_atlas \n", + "agg_2 healthy SCR_016152 brain_atlas \n", + "agg_3 healthy SCR_016152 brain_atlas \n", + "agg_4 healthy SCR_016152 brain_atlas \n", + "... ... ... ... \n", + "agg_9533 NA ENCODE scimilarity \n", + "agg_9535 healthy GSE129845 scimilarity \n", + "agg_9536 NA ENCODE scimilarity \n", + "agg_9537 healthy e5f58829-1a66-40b5-a624-9046778e74f5 scimilarity \n", + "agg_9538 healthy e5f58829-1a66-40b5-a624-9046778e74f5 scimilarity \n", + "\n", + " region subregion \\\n", + "agg_0 Amygdala Amygdala \n", + "agg_1 Amygdala Basolateral nuclear group (BLN) - lateral nucl... \n", + "agg_2 Amygdala Bed nucleus of stria terminalis and nearby - BNST \n", + "agg_3 Amygdala Central nuclear group - CEN \n", + "agg_4 Amygdala Corticomedial nuclear group (CMN) - anterior c... \n", + "... ... ... \n", + "agg_9533 nan nan \n", + "agg_9535 nan nan \n", + "agg_9536 nan nan \n", + "agg_9537 nan nan \n", + "agg_9538 nan nan \n", + "\n", + " celltype_coarse n_cells total_counts n_genes size_factor \\\n", + "agg_0 NaN 331 1.592883e+07 17000 41431.465186 \n", + "agg_1 NaN 11369 2.952133e+08 18080 40765.341481 \n", + "agg_2 NaN 139 2.593231e+06 15418 42556.387020 \n", + "agg_3 NaN 3892 9.946371e+07 17959 42884.641430 \n", + "agg_4 NaN 2945 1.281619e+08 17885 41816.741933 \n", + "... ... ... ... ... ... \n", + "agg_9533 NaN 21 3.483375e+04 8515 35404.911768 \n", + "agg_9535 NaN 24 8.498500e+04 7337 26189.415789 \n", + "agg_9536 NaN 272 5.700762e+05 14769 44938.403867 \n", + "agg_9537 NaN 472 1.089170e+07 14514 30145.422152 \n", + "agg_9538 NaN 1853 5.992697e+07 16764 36464.273371 \n", + "\n", + " train_pearson val_pearson test_pearson \n", + "agg_0 0.942459 0.841377 0.865640 \n", + "agg_1 0.943098 0.838936 0.861092 \n", + "agg_2 0.952170 0.854544 0.866654 \n", + "agg_3 0.959744 0.863585 0.881554 \n", + "agg_4 0.951365 0.854304 0.868902 \n", + "... ... ... ... \n", + "agg_9533 0.735213 0.665647 0.654491 \n", + "agg_9535 0.809852 0.690022 0.656160 \n", + "agg_9536 0.915329 0.808941 0.839993 \n", + "agg_9537 0.852339 0.717682 0.727469 \n", + "agg_9538 0.909855 0.780413 0.796351 \n", + "\n", + "[8856 rows x 16 columns]" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "result = DecimaResult.load(\"example/predict_genes/predictions.h5ad\")\n", - "result.predicted_expression_matrix()" + "result.cell_metadata" + ] + }, + { + "cell_type": "markdown", + "id": "345ff486", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "### CLI API" + ] + }, + { + "cell_type": "markdown", + "id": "86e9f055", + "metadata": {}, + "source": [ + "If you want to perform gene expression prediction again, rather than using the precomputed scores, you can use the Decima command-line interface (CLI) to generate new predictions for any set of genes you specify. For example, you can run the `decima predict-genes` command with the `--genes` argument to provide a comma-separated list of gene names (such as \"STRADA,ETV4,USP25\") if no gene provided it will perform expression predictions for all genes, select the prediction model with the `--model` option (for instance, \"ensemble\" or a specific replicate like \"0\"), and use `--save-replicates` to save predictions for each replicate. The `-o` flag lets you specify the output file path for the predictions in `.h5ad` format. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6715257c", + "metadata": { + "execution": { + "iopub.execute_input": "2025-11-21T06:25:32.221652Z", + "iopub.status.busy": "2025-11-21T06:25:32.221116Z", + "iopub.status.idle": "2025-11-21T06:26:16.929651Z", + "shell.execute_reply": "2025-11-21T06:26:16.928993Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "decima - INFO - Using device: 0 and genome: hg38 for prediction.\n", + "decima - INFO - Loading model ensemble...\n", + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n", + "decima - INFO - Making predictions\n", + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/lightning_fabric/plugins/environments/slurm.py:204: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /gpfs/scratchfs01/site/u/lala8/conda/envs/decima/bin ...\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\u001b[2KPredicting \u001b[35m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m 3/3 \u001b[2m0:00:06 • 0:00:00\u001b[0m \u001b[2;4m0.51it/s\u001b[0m [2;4m0.51it/s\u001b[0m \n", + "\u001b[?25h/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/torchmetrics/utilities/prints.py:43: UserWarning: The ``compute`` method of metric WarningCounter was called before the ``update`` method which may lead to errors, as metric states have not yet been updated.\n", + "decima - INFO - Creating anndata\n", + "decima - INFO - Evaluating performance\n", + "decima - WARNING - No ground truth expression matrix found in the metadata. Skipping evaluation.\n", + "\u001b[0m" + ] + } + ], + "source": [ + "! decima predict-genes --genes \"STRADA,ETV4,USP25\" --model ensemble --save-replicates -o example/predict_genes/predictions.h5ad " + ] + }, + { + "cell_type": "markdown", + "id": "4d2c0356", + "metadata": {}, + "source": [ + "After running this command, you can load the resulting predictions in Python using the `DecimaResult` class and access the predicted expression matrix as:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e598b85c", + "metadata": { + "execution": { + "iopub.execute_input": "2025-11-21T06:26:16.931282Z", + "iopub.status.busy": "2025-11-21T06:26:16.931107Z", + "iopub.status.idle": "2025-11-21T06:26:16.979662Z", + "shell.execute_reply": "2025-11-21T06:26:16.979173Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "| \n", + " | STRADA | \n", + "ETV4 | \n", + "USP25 | \n", + "
|---|---|---|---|
| agg_0 | \n", + "3.060619 | \n", + "2.882531 | \n", + "3.468806 | \n", + "
| agg_1 | \n", + "3.117708 | \n", + "2.826338 | \n", + "3.596656 | \n", + "
| agg_2 | \n", + "3.156616 | \n", + "3.122882 | \n", + "3.718929 | \n", + "
| agg_3 | \n", + "3.213984 | \n", + "3.205003 | \n", + "3.629975 | \n", + "
| agg_4 | \n", + "3.103343 | \n", + "3.032427 | \n", + "3.511971 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| agg_9533 | \n", + "2.313626 | \n", + "2.173769 | \n", + "3.155950 | \n", + "
| agg_9535 | \n", + "0.952015 | \n", + "0.956526 | \n", + "1.249992 | \n", + "
| agg_9536 | \n", + "2.779407 | \n", + "2.705898 | \n", + "3.530358 | \n", + "
| agg_9537 | \n", + "1.342451 | \n", + "1.407246 | \n", + "1.866810 | \n", + "
| agg_9538 | \n", + "1.744864 | \n", + "1.633126 | \n", + "2.082733 | \n", + "
8856 rows × 3 columns
\n", + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n", + "\n" + ], "text/plain": [ - "Predicting: | | 0/? [00:00, ?it/s]" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n" ] }, "metadata": {}, "output_type": "display_data" }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", "text": [ - "/home/celikm5/miniforge3/envs/decima2/lib/python3.11/site-packages/torchmetrics/utilities/prints.py:43: UserWarning: The ``compute`` method of metric WarningCounter was called before the ``update`` method which may lead to errors, as metric states have not yet been updated.\n", + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/torchmetrics/utilities/prints.py:43: UserWarning: The ``compute`` method of metric WarningCounter was called before the ``update`` method which may lead to errors, as metric states have not yet been updated.\n", "No ground truth expression matrix found in the metadata. Skipping evaluation.\n" ] } @@ -2062,7 +2086,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "d147aaff", "metadata": { "execution": { @@ -2077,117 +2101,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[34m\u001b[1mwandb\u001b[0m: Downloading large artifact 'rep0:latest', 720.03MB. 1 files...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[34m\u001b[1mwandb\u001b[0m: 1 of 1 files downloaded. \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Done. 00:00:01.2 (580.7MB/s)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[34m\u001b[1mwandb\u001b[0m: Downloading large artifact 'metadata:latest', 3122.32MB. 1 files...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[34m\u001b[1mwandb\u001b[0m: 1 of 1 files downloaded. \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Done. 00:00:02.7 (1164.2MB/s)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), used: True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "TPU available: False, using: 0 TPU cores\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "HPU available: False, using: 0 HPUs\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "SLURM auto-requeueing enabled. Setting signal handlers.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/celikm5/miniforge3/envs/decima2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:433: PossibleUserWarning: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/lightning_fabric/plugins/environments/slurm.py:204: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib ...\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:434: PossibleUserWarning: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=19` in the `DataLoader` to improve performance.\n" ] }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "086c3698b2f64da9b6be5915347e0fb7", - "version_major": 2, - "version_minor": 0 - }, + "text/html": [ + "
/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n", + "\n" + ], "text/plain": [ - "Predicting: | | 0/? [00:00, ?it/s]" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/rich/live.py:260: UserWarning: \n", + "install \"ipywidgets\" for Jupyter support\n" ] }, "metadata": {}, "output_type": "display_data" }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "{'expression': array([[2.9330175, 2.8167777, 2.7431197, ..., 2.8092291, 1.580334 ,\n", - " 2.0142236],\n", - " [2.0205972, 1.9390993, 2.3948462, ..., 1.5032245, 0.51865 ,\n", - " 0.8084921],\n", - " [4.795624 , 4.9177237, 4.8060527, ..., 4.6602893, 2.7781048,\n", - " 3.1485069]], dtype=float32),\n", + "{'expression': array([[2.9320552, 2.8163733, 2.7427804, ..., 2.8086236, 1.580037 ,\n", + " 2.013807 ],\n", + " [2.0220397, 1.9408561, 2.396594 , ..., 1.5032645, 0.5187098,\n", + " 0.8085415],\n", + " [4.7951455, 4.9170322, 4.8060875, ..., 4.659208 , 2.77756 ,\n", + " 3.1479335]], dtype=float32),\n", " 'warnings': Counter({'unknown': tensor(0),\n", " 'allele_mismatch_with_reference_genome': tensor(0)})}\n" ] @@ -2196,7 +2153,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/celikm5/miniforge3/envs/decima2/lib/python3.11/site-packages/torchmetrics/utilities/prints.py:43: UserWarning: The ``compute`` method of metric WarningCounter was called before the ``update`` method which may lead to errors, as metric states have not yet been updated.\n" + "/gpfs/scratchfs01/site/u/lala8/conda/envs/decima/lib/python3.11/site-packages/torchmetrics/utilities/prints.py:43: UserWarning: The ``compute`` method of metric WarningCounter was called before the ``update`` method which may lead to errors, as metric states have not yet been updated.\n" ] } ], @@ -2242,7 +2199,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "2dfbdb1a", "metadata": { "execution": { @@ -2257,7 +2214,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "cat: ../tests/data/seqs.fasta: No such file or directory\r\n" + "cat: ../tests/data/seqs.fasta: No such file or directory\n" ] } ], @@ -2267,7 +2224,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "0d15ea9e", "metadata": { "execution": { @@ -2282,54 +2239,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), used: True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "TPU available: False, using: 0 TPU cores\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "HPU available: False, using: 0 HPUs\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "SLURM auto-requeueing enabled. Setting signal handlers.\n" - ] - }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b0c2854b5b1145a28d069646a54109b5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Predicting: | | 0/? [00:00, ?it/s]" - ] + "text/html": [ + "\n" + ], + "text/plain": [] }, "metadata": {}, "output_type": "display_data" @@ -2338,10 +2260,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "array([[0.22026505, 0.21946757, 0.23086782, ..., 1.0358492 , 1.2124686 ,\n", - " 1.441437 ],\n", - " [0.26515013, 0.13341773, 0.14887223, ..., 0.44430685, 0.26546437,\n", - " 0.3042384 ]], dtype=float32)\n" + "array([[0.22032936, 0.21946222, 0.23088504, ..., 1.0364846 , 1.2134477 ,\n", + " 1.442827 ],\n", + " [0.26523364, 0.13350041, 0.14896177, ..., 0.44437748, 0.26560792,\n", + " 0.30437425]], dtype=float32)\n" ] } ], @@ -2366,9 +2288,9 @@ ], "metadata": { "kernelspec": { - "display_name": "decima2", + "display_name": "Python (decima)", "language": "python", - "name": "python3" + "name": "decima" }, "language_info": { "codemirror_mode": { @@ -2380,7 +2302,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.14" + "version": "3.11.15" }, "widgets": { "application/vnd.jupyter.widget-state+json": { @@ -2924,13 +2846,13 @@ "description": "", "description_allow_html": false, "layout": "IPY_MODEL_15a6d137d2b646a696f272e5052ef607", - "max": 1.0, - "min": 0.0, + "max": 1, + "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_aa835afeee484927b37b60145e71a78d", "tabbable": null, "tooltip": null, - "value": 1.0 + "value": 1 } }, "865789d5e3c44252bbf06d1074c3b9f4": { @@ -3003,13 +2925,13 @@ "description": "", "description_allow_html": false, "layout": "IPY_MODEL_90b1a10420424e418ff34bf3dd4412cf", - "max": 1.0, - "min": 0.0, + "max": 1, + "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_f8201ba403ce4b2595d880cc13f891ad", "tabbable": null, "tooltip": null, - "value": 1.0 + "value": 1 } }, "8a3f3c76906944af8e4653d4cdc8e22e": { @@ -3105,13 +3027,13 @@ "description": "", "description_allow_html": false, "layout": "IPY_MODEL_ccfa2a1578f54a16b315cf45b553478c", - "max": 1.0, - "min": 0.0, + "max": 1, + "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_45f4d8cd02c74b73a35d15e31fc33078", "tabbable": null, "tooltip": null, - "value": 1.0 + "value": 1 } }, "90b1a10420424e418ff34bf3dd4412cf": { diff --git a/setup.cfg b/setup.cfg index 6d6101d..91739e9 100644 --- a/setup.cfg +++ b/setup.cfg @@ -52,11 +52,12 @@ install_requires = click more_itertools wandb + huggingface_hub numpy torch pyfaidx genomepy - grelu>=1.0.10,<=1.0.11 + grelu>=1.0.10 lightning torchmetrics bioframe @@ -116,15 +117,16 @@ console_scripts = addopts = --cov decima --cov-report term-missing --verbose + -m "not wandb and not hf" norecursedirs = dist build .tox testpaths = tests # Use pytest markers to select/deselect specific tests -# markers = -# slow: mark tests as slow (deselect with '-m "not slow"') -# system: mark end-to-end system tests +markers = + wandb: mark tests that require wandb authentication (skipped by default) + hf: mark tests that call the HuggingFace API [devpi:upload] # Options for the devpi: PyPI server and packaging tool diff --git a/src/decima/constants.py b/src/decima/constants.py index af70f35..d885a35 100644 --- a/src/decima/constants.py +++ b/src/decima/constants.py @@ -3,6 +3,10 @@ import json import os +HF_MODEL_REPO = "Genentech/decima-model" +HF_DATA_REPO = "Genentech/decima-data" +HF_METADATA_FILENAME = "metadata.h5ad" + # constants for all models DECIMA_CONTEXT_SIZE = 524_288 diff --git a/src/decima/hub/__init__.py b/src/decima/hub/__init__.py index e50c657..de9aabe 100644 --- a/src/decima/hub/__init__.py +++ b/src/decima/hub/__init__.py @@ -1,32 +1,26 @@ -import os -import json +from pathlib import Path from typing import Union, Optional, List import warnings -import wandb -from pathlib import Path -from tempfile import TemporaryDirectory import anndata -from grelu.resources import get_artifact, DEFAULT_WANDB_HOST -from decima.constants import DEFAULT_ENSEMBLE, ENSEMBLE_MODELS, MODEL_METADATA +from huggingface_hub import hf_hub_download +from decima.constants import ( + DEFAULT_ENSEMBLE, + ENSEMBLE_MODELS, + MODEL_METADATA, + HF_MODEL_REPO, + HF_DATA_REPO, + HF_METADATA_FILENAME, +) from decima.model.lightning import LightningModel, EnsembleLightningModel -def login_wandb(): - """Login to wandb either as anonymous or as a user.""" - host = os.environ.get("WANDB_HOST", DEFAULT_WANDB_HOST) - try: - wandb.login(host=host, anonymous="never", timeout=0) - except wandb.errors.UsageError: # login anonymously if not logged in already - wandb.login(host=host, relogin=True, anonymous="must", timeout=0) - - def load_decima_model(model: Union[str, int, List[str]] = DEFAULT_ENSEMBLE, device: Optional[str] = None): - """Load a pre-trained Decima model from wandb or local path. + """Load a pre-trained Decima model from HuggingFace or a local path. Args: model: Model identifier or path. Can be: - int: Replicate number (0-3) - - str: Model name on wandb + - str: Model name from MODEL_METADATA - str: Path to local model checkpoint - List: list of local model checkpoints device: Device to load the model on. If None, automatically selects the best available device. @@ -40,56 +34,46 @@ def load_decima_model(model: Union[str, int, List[str]] = DEFAULT_ENSEMBLE, devi if isinstance(model, LightningModel): return model - elif model in ENSEMBLE_MODELS: + if model in ENSEMBLE_MODELS: return EnsembleLightningModel( [load_decima_model(model_name, device) for model_name in MODEL_METADATA[model]], name=model, ) - elif isinstance(model, List): + if isinstance(model, list): if len(model) == 1: return load_decima_model(model[0], device) - else: - return EnsembleLightningModel([load_decima_model(path, device) for path in model], name=model) + return EnsembleLightningModel([load_decima_model(path, device) for path in model], name=model) + + if isinstance(model, str) and Path(model).exists(): + if model.endswith(".ckpt"): + return LightningModel.load_from_checkpoint(model, map_location=device) + return LightningModel.load_safetensor(model, device=device) - # Load directly from a path if model in MODEL_METADATA: - model_name = MODEL_METADATA[model]["name"] - if "model_path" in MODEL_METADATA[model]: # if model path exist in metadata load it from the path + if "model_path" in MODEL_METADATA[model] and Path(MODEL_METADATA[model]["model_path"]).exists(): return load_decima_model(MODEL_METADATA[model]["model_path"], device) - elif isinstance(model, str) and Path(model).exists(): - if model.endswith("ckpt"): - return LightningModel.load_from_checkpoint(model, map_location=device) - else: - return LightningModel.load_safetensor(model, device=device) - else: - raise ValueError( - f"Invalid model: {model} it needs to be either a string of model_names on wandb (" - f"{list(MODEL_METADATA.keys())}), path to a local model, or a list of paths." - ) - # load model from wandb - art = get_artifact( - model_name, - project="decima", - host=os.environ.get("WANDB_HOST", DEFAULT_WANDB_HOST), + name = MODEL_METADATA[model]["name"] + cached = hf_hub_download(repo_id=HF_MODEL_REPO, filename=f"{name}.safetensors") + return LightningModel.load_safetensor(cached, device=device) + + raise ValueError( + f"Invalid model: {model}. Must be a known model name {list(MODEL_METADATA.keys())}, " + "a local path, or a list of local paths." ) - with TemporaryDirectory() as d: - art.download(d) - return LightningModel.load_safetensor(Path(d) / f"{model_name}.safetensors", device=device) def load_decima_metadata(name_or_path: Optional[str] = None): - """Load the Decima metadata from wandb. + """Load the Decima metadata from HuggingFace or a local path. Args: - name_or_path: Path to local metadata file or name of the model to load metadata for using wandb. If None, default model's metadata will be downloaded from wandb. + name_or_path: Path to local metadata file or model name. If None, downloads from HuggingFace. Returns: An AnnData object containing the Decima metadata. """ - if name_or_path is not None: - if Path(name_or_path).exists(): - return anndata.read_h5ad(name_or_path) + if name_or_path is not None and Path(name_or_path).exists(): + return anndata.read_h5ad(name_or_path) name_or_path = name_or_path or DEFAULT_ENSEMBLE @@ -98,22 +82,17 @@ def load_decima_metadata(name_or_path: Optional[str] = None): if name_or_path in MODEL_METADATA: metadata = MODEL_METADATA[name_or_path] - - if "metadata_path" in metadata: - if Path(metadata["metadata_path"]).exists(): - return anndata.read_h5ad(metadata["metadata_path"]) - else: + if "metadata_path" in metadata: + if Path(metadata["metadata_path"]).exists(): + return anndata.read_h5ad(metadata["metadata_path"]) warnings.warn( - f"Metadata `{metadata['metadata_path']}` provided in environment variables, " - f"but not found in `{metadata['metadata_path']}` " - f"Trying to download `metadata` from wandb." + f"Metadata path `{metadata['metadata_path']}` not found. Downloading from HuggingFace." ) + else: + raise ValueError( + f"Invalid metadata: {name_or_path}. Must be a known model name {list(MODEL_METADATA.keys())} " + "or a local path." + ) - art = get_artifact( - metadata["metadata"], - project="decima", - host=os.environ.get("WANDB_HOST", DEFAULT_WANDB_HOST), - ) - with TemporaryDirectory() as d: - art.download(d) - return anndata.read_h5ad(Path(d) / f"{metadata['metadata']}.h5ad") + cached = hf_hub_download(repo_id=HF_DATA_REPO, filename=HF_METADATA_FILENAME, repo_type="dataset") + return anndata.read_h5ad(cached) diff --git a/src/decima/hub/download.py b/src/decima/hub/download.py index 6788e74..e3d9a54 100644 --- a/src/decima/hub/download.py +++ b/src/decima/hub/download.py @@ -1,12 +1,17 @@ -import os +import logging from pathlib import Path from typing import Union -import logging import genomepy -from grelu.resources import get_artifact, DEFAULT_WANDB_HOST -from decima.constants import DEFAULT_ENSEMBLE, ENSEMBLE_MODELS, MODEL_METADATA -from decima.hub import login_wandb, load_decima_model, load_decima_metadata - +from huggingface_hub import hf_hub_download +from decima.constants import ( + DEFAULT_ENSEMBLE, + ENSEMBLE_MODELS, + MODEL_METADATA, + HF_MODEL_REPO, + HF_DATA_REPO, + HF_METADATA_FILENAME, +) +from decima.hub import load_decima_model, load_decima_metadata logger = logging.getLogger("decima") @@ -18,86 +23,75 @@ def cache_hg38(): def cache_decima_weights(): - """Download pre-trained Decima model weights from wandb.""" + """Download pre-trained Decima model weights from HuggingFace.""" logger.info("Downloading Decima model weights...") for rep in MODEL_METADATA[DEFAULT_ENSEMBLE]: load_decima_model(rep) def cache_decima_metadata(): - """Download pre-trained Decima model data from wandb.""" + """Download pre-trained Decima metadata from HuggingFace.""" logger.info("Downloading Decima metadata...") load_decima_metadata() def cache_decima_data(): """Download all required data for Decima.""" - login_wandb() cache_hg38() cache_decima_weights() cache_decima_metadata() def download_decima_weights(model: Union[str, int] = DEFAULT_ENSEMBLE, download_dir: str = "."): - """Download pre-trained Decima model weights from wandb. + """Download pre-trained Decima model weights from HuggingFace to a local directory. Args: - model_name: Model name or replicate number. - download_dir: Directory to download the model weights. + model: Model name or replicate number. + download_dir: Directory to save the model weights. Returns: Path to the downloaded model weights. """ if model in ENSEMBLE_MODELS: - return [download_decima_weights(model, download_dir) for model in MODEL_METADATA[model]] + return [download_decima_weights(m, download_dir) for m in MODEL_METADATA[model]] - model_name = MODEL_METADATA[model]["name"] + name = MODEL_METADATA[model]["name"] download_dir = Path(download_dir) download_dir.mkdir(parents=True, exist_ok=True) - logger.info(f"Downloading Decima model weights for {model} to {download_dir / f'{model_name}.safetensors'}") - - art = get_artifact(model_name, project="decima", host=os.environ.get("WANDB_HOST", DEFAULT_WANDB_HOST)) - art.download(str(download_dir)) - return download_dir / f"{model_name}.safetensors" + logger.info(f"Downloading Decima model weights for {model} to {download_dir / f'{name}.safetensors'}") + return Path(hf_hub_download(repo_id=HF_MODEL_REPO, filename=f"{name}.safetensors", local_dir=str(download_dir))) -def download_decima_metadata(metadata: str = DEFAULT_ENSEMBLE, download_dir: str = "."): - """Download pre-trained Decima model data from wandb. +def download_decima_metadata(download_dir: str = "."): + """Download pre-trained Decima metadata from HuggingFace to a local directory. Args: - download_dir: Directory to download the metadata. - metadata: Name of the model to download metadata for using wandb. + download_dir: Directory to save the metadata. Returns: Path to the downloaded metadata. """ - metadata = metadata or DEFAULT_ENSEMBLE - if metadata in ENSEMBLE_MODELS: - metadata = MODEL_METADATA[metadata][0] - - metadata_name = MODEL_METADATA[metadata]["metadata"] - art = get_artifact(metadata_name, project="decima", host=os.environ.get("WANDB_HOST", DEFAULT_WANDB_HOST)) download_dir = Path(download_dir) download_dir.mkdir(parents=True, exist_ok=True) - logger.info(f"Downloading Decima metadata to {download_dir / f'{metadata_name}.h5ad'}.") - - art.download(str(download_dir)) - return download_dir / f"{metadata_name}.h5ad" + logger.info(f"Downloading Decima metadata to {download_dir / HF_METADATA_FILENAME}") + return Path(hf_hub_download( + repo_id=HF_DATA_REPO, filename=HF_METADATA_FILENAME, repo_type="dataset", local_dir=str(download_dir) + )) def download_decima(model: str = DEFAULT_ENSEMBLE, download_dir: str = "."): """Download all required data for Decima. Args: - download_dir: Directory to download the model weights and metadata. + model: Model name or replicate number. + download_dir: Directory to save the model weights and metadata. Returns: - Path to the downloaded directory containing the model weights and metadata. + Path to the download directory. """ download_dir = Path(download_dir) download_dir.mkdir(parents=True, exist_ok=True) logger.info(f"Downloading Decima model weights and metadata to {download_dir}:") - download_decima_weights(model, download_dir) - download_decima_metadata(model, download_dir) + download_decima_metadata(download_dir) return download_dir diff --git a/src/decima/hub/wandb.py b/src/decima/hub/wandb.py new file mode 100644 index 0000000..9c0196a --- /dev/null +++ b/src/decima/hub/wandb.py @@ -0,0 +1,142 @@ +"""Wandb-based model loading for internal/private model access.""" + +import os +from pathlib import Path +from tempfile import TemporaryDirectory +from typing import Union, Optional, List +import warnings +import wandb +import anndata +from decima.constants import DEFAULT_ENSEMBLE, ENSEMBLE_MODELS, MODEL_METADATA +from decima.model.lightning import LightningModel, EnsembleLightningModel + +WANDB_ENTITY = "grelu" +WANDB_PROJECT = "decima" +DEFAULT_WANDB_HOST = "https://wandb.ai" + + +def _get_host(host: Optional[str] = None) -> str: + return host or os.environ.get("WANDB_HOST", DEFAULT_WANDB_HOST) + + +def login_wandb(host: Optional[str] = None): + """Login to wandb either as anonymous or as a user.""" + h = _get_host(host) + try: + wandb.login(host=h, anonymous="never", timeout=0) + except wandb.errors.UsageError: + wandb.login(host=h, relogin=True, anonymous="must", timeout=0) + + +def _get_artifact(name: str, host: Optional[str] = None): + api = wandb.Api(overrides={"host": _get_host(host)}) + return api.artifact(f"{WANDB_ENTITY}/{WANDB_PROJECT}/{name}:latest") + + +def load_decima_model( + model: Union[str, int, List[str]] = DEFAULT_ENSEMBLE, + device: Optional[str] = None, + host: Optional[str] = None, +): + """Load a pre-trained Decima model from wandb or a local path.""" + if isinstance(model, LightningModel): + return model + + if model in ENSEMBLE_MODELS: + return EnsembleLightningModel( + [load_decima_model(m, device, host) for m in MODEL_METADATA[model]], + name=model, + ) + + if isinstance(model, list): + if len(model) == 1: + return load_decima_model(model[0], device, host) + return EnsembleLightningModel([load_decima_model(p, device, host) for p in model], name=model) + + if isinstance(model, str) and Path(model).exists(): + if model.endswith(".ckpt"): + return LightningModel.load_from_checkpoint(model, map_location=device) + return LightningModel.load_safetensor(model, device=device) + + if model in MODEL_METADATA: + if "model_path" in MODEL_METADATA[model]: + return load_decima_model(MODEL_METADATA[model]["model_path"], device, host) + name = MODEL_METADATA[model]["name"] + art = _get_artifact(name, host) + with TemporaryDirectory() as d: + art.download(d) + return LightningModel.load_safetensor(Path(d) / f"{name}.safetensors", device=device) + + raise ValueError( + f"Invalid model: {model}. Must be a known model name {list(MODEL_METADATA.keys())}, " + "a local path, or a list of local paths." + ) + + +def load_decima_metadata(name_or_path: Optional[str] = None, host: Optional[str] = None): + """Load the Decima metadata from wandb or a local path.""" + if name_or_path is not None and Path(name_or_path).exists(): + return anndata.read_h5ad(name_or_path) + + name_or_path = name_or_path or DEFAULT_ENSEMBLE + + if name_or_path in ENSEMBLE_MODELS: + name_or_path = MODEL_METADATA[name_or_path][0] + + if name_or_path in MODEL_METADATA: + metadata = MODEL_METADATA[name_or_path] + if "metadata_path" in metadata: + if Path(metadata["metadata_path"]).exists(): + return anndata.read_h5ad(metadata["metadata_path"]) + warnings.warn( + f"Metadata path `{metadata['metadata_path']}` not found. Downloading from wandb." + ) + art = _get_artifact(metadata["metadata"], host) + with TemporaryDirectory() as d: + art.download(d) + return anndata.read_h5ad(Path(d) / f"{metadata['metadata']}.h5ad") + + raise ValueError(f"Unknown model: {name_or_path}") + + +def download_decima_weights( + model: Union[str, int] = DEFAULT_ENSEMBLE, + download_dir: str = ".", + host: Optional[str] = None, +): + """Download pre-trained Decima model weights from wandb.""" + if model in ENSEMBLE_MODELS: + return [download_decima_weights(m, download_dir, host) for m in MODEL_METADATA[model]] + + name = MODEL_METADATA[model]["name"] + download_dir = Path(download_dir) + download_dir.mkdir(parents=True, exist_ok=True) + art = _get_artifact(name, host) + art.download(str(download_dir)) + return download_dir / f"{name}.safetensors" + + +def download_decima_metadata( + metadata: str = DEFAULT_ENSEMBLE, + download_dir: str = ".", + host: Optional[str] = None, +): + """Download pre-trained Decima metadata from wandb.""" + metadata = metadata or DEFAULT_ENSEMBLE + if metadata in ENSEMBLE_MODELS: + metadata = MODEL_METADATA[metadata][0] + + metadata_name = MODEL_METADATA[metadata]["metadata"] + download_dir = Path(download_dir) + download_dir.mkdir(parents=True, exist_ok=True) + art = _get_artifact(metadata_name, host) + art.download(str(download_dir)) + return download_dir / f"{metadata_name}.h5ad" + + +def cache_decima_data(host: Optional[str] = None): + """Download all required Decima assets from wandb.""" + login_wandb(host) + for rep in MODEL_METADATA[DEFAULT_ENSEMBLE]: + load_decima_model(rep, host=host) + load_decima_metadata(host=host) diff --git a/tests/conftest.py b/tests/conftest.py index 82d5336..97ad5e5 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -6,7 +6,6 @@ import pytest from decima.constants import DECIMA_CONTEXT_SIZE -from decima.hub import login_wandb from decima.hub.download import cache_hg38 @@ -38,7 +37,6 @@ def pytest_collection_modifyitems(config, items): item.add_marker(skip_long_running) -login_wandb() cache_hg38() diff --git a/tests/test_hub.py b/tests/test_hub.py index 0bcda93..0063c6c 100644 --- a/tests/test_hub.py +++ b/tests/test_hub.py @@ -2,9 +2,16 @@ import anndata from decima.model.lightning import LightningModel from decima.hub import load_decima_model, load_decima_metadata +from decima.constants import HF_MODEL_REPO, HF_DATA_REPO, HF_METADATA_FILENAME -@pytest.mark.long_running +def test_hf_constants(): + assert HF_MODEL_REPO == "Genentech/decima-model" + assert HF_DATA_REPO == "Genentech/decima-data" + assert HF_METADATA_FILENAME == "metadata.h5ad" + + +@pytest.mark.hf def test_load_decima_model(): model_0 = load_decima_model() assert model_0 is not None @@ -14,6 +21,7 @@ def test_load_decima_model(): assert model_2 is not None +@pytest.mark.hf def test_load_decima_metadata(): metadata = load_decima_metadata() assert isinstance(metadata, anndata.AnnData)