clipnet 0.2.1__tar.gz

clipnet-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Youlin He
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

clipnet-0.2.1/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: clipnet
+Version: 0.2.1
+Summary: CLIPNET is an ensembled convolutional neural network for predicting transcription initiation from DNA sequence at single nucleotide resolution.
+Author-email: Adam He <adamyhe@gmail.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/adamyhe/clipnet
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: gputil
+Requires-Dist: h5py
+Requires-Dist: joblib>=1.3
+Requires-Dist: matplotlib
+Requires-Dist: numpy<2.0.0,>=1.26.3
+Requires-Dist: pandas
+Requires-Dist: pyfastx>=1.1
+Requires-Dist: scipy
+Requires-Dist: seqlogo
+Requires-Dist: shap==0.44.1
+Requires-Dist: tensorflow[and-cuda]<2.15.0,>=2.14.0
+Requires-Dist: silence_tensorflow
+Requires-Dist: tqdm>=4.64.1
+Dynamic: license-file

clipnet-0.2.1/README.md

@@ -0,0 +1,166 @@
+# CLIPNET
+
+[![PyPI](https://img.shields.io/pypi/v/clipnet)](https://pypi.org/project/clipnet/)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/clipnet?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/clipnet)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10408623.svg)](https://doi.org/10.5281/zenodo.10408623)
+
+CLIPNET (Convolutionally Learned, Initiation-Predicting NETwork) is an ensembled convolutional neural network that predicts transcription initiation from DNA sequence at single nucleotide resolution. We describe CLIPNET in our [preprint](https://www.biorxiv.org/content/10.1101/2024.03.13.583868) on bioRxiv. This repository contains code for working with CLIPNET, namely for generating predictions and feature interpretations and performing *in silico* mutagenesis scans. To reproduce the figures in our paper, please see the [clipnet_paper GitHub repo](https://github.com/Danko-Lab/clipnet_paper/).
+
+## PyTorch reimplementation and port
+
+Code to port the TensorFlow models to PyTorch is available as part of [PersonalBPNet](https://github.com/adamyhe/PersonalBPNet/), which also includes a from-scratch reimplementation of CLIPNET in PyTorch with a context length of 2114 bp. The below instructions are for working with CLIPNET in TensorFlow.
+
+## CODE REFACTORING NOTICE
+
+I have significantly altered the structure of this code base since its original release with the preprint. The new CLIPNET package should be significantly easier to use (`pip` installable, with clearer CLI and API). To access the code as it was prior to this refactoring, please check out the (unmaintained) [`deprecated`](https://github.com/Danko-Lab/clipnet/tree/deprecated) branch.
+
+## Installation
+
+To install CLIPNET, we recommend creating an isolated environment. For example, with conda/mamba:
+
+```bash
+mamba create -n clipnet -c conda-forge python~=3.9
+mamba activate clipnet
+```
+
+Then install with pip:
+
+```bash
+# From PyPI
+pip install clipnet
+# Or from source:
+pip install git+https://github.com/Danko-Lab/clipnet.git
+```
+
+You may need to configure your CUDA/cudatoolkit/cudnn paths to get GPU support working. See the [tensorflow documentation](https://www.tensorflow.org/install/gpu) for more information.
+
+## Download models
+
+Pretrained CLIPNET models are available on [Zenodo](https://zenodo.org/doi/10.5281/zenodo.10408622).
+
+```bash
+mkdir -p clipnet_models/
+for fold in {1..9};
+do wget https://zenodo.org/records/10408623/files/fold_${fold}.h5 -P clipnet_models/;
+done
+```
+
+Alternatively, they can be accessed via [HuggingFace](https://huggingface.co/adamyhe/clipnet).
+
+## Usage
+
+### Input data
+
+CLIPNET was trained on a [population-scale PRO-cap dataset](http://dx.doi.org/10.1038/s41467-020-19829-z) derived from human lymphoblastoid cell lines, matched with individualized genome sequences (1kGP). CLIPNET accepts 1000 bp sequences as input and imputes PRO-cap coverage (RPM) in the center 500 bp.
+
+CLIPNET can either work on haploid reference sequences (e.g. hg38) or on individualized sequences (e.g. 1kGP). When constructing individualized sequences, we made two major simplifications: (1) We considered only SNPs and (2) we used unphased SNP genotypes.
+
+We encode sequences using a "two-hot" encoding. That is, we encoded each individual nucleotide at a given position using a one-hot encoding scheme, then represented the unphased diploid sequence as the sum of the two one-hot encoded nucleotides at each position. The sequence "AYCR" (= A(C/T)C(A/G)), for example, would be encoded as: `[[2, 0, 0, 0], [0, 1, 0, 1], [0, 2, 0, 0], [1, 0, 1, 0]]`.
+
+### Colab examples
+
+Google Colab examples for analyzing and applying CLIPNET are available through the following links:
+
+- [Basic tutorial](https://colab.research.google.com/drive/1ojhoKC5IjHjjxltZdAktSkuNFU0Wvjce?usp=sharing) illustrating how to generate predictions and attributions with the models.
+- Variant effect prediction and interpretation (TODO)
+- MPRA optimization/design (TODO)
+
+### Command line interface
+
+CLIPNET can be accessed via a CLI:
+
+```bash
+clipnet -h
+```
+
+#### Predictions
+
+The `predict` command can be used to generate predictions:
+
+```bash
+clipnet predict -f data/test.fa -o data/test_predictions.npz -m clipnet_models/ -v
+```
+
+The `-m` flag should be used to specify either a path to the directory containing the CLIPNET models (in which case the averaged predictions across all model replicates will be returned) or a specific model path (in which case only the predictions of that model will be returned).
+
+To input individualized sequences, heterozygous positions should be represented using the IUPAC ambiguity codes R (A/G), Y (C/T), S (C/G), W (A/T), K (G/T), M (A/C).
+
+The output npz file will contain two arrays. The first output (`"arr_0"`, "profile") is a length 1000 vector (500 plus strand concatenated with 500 minus strand) representing the predicted base-resolution profile/shape of initiation. The second output (`"arr_0"`, "quantity") represents the total PRO-cap quantity on both strands.
+
+To generate actual predicted tracks, the profile prediction should be rescaled by the quantity prediction. For example:
+
+```python
+import numpy as np
+
+f = np.load("data/test_predictions.npz") 
+profile = f["arr_0"]
+quantity = f["arr_1"]
+profile_scaled = (profile / np.sum(profile, axis=1)[:, None]) * quantity
+```
+
+#### Attributions
+
+CLIPNET uses [DeepSHAP](https://shap.readthedocs.io/en/latest/generated/shap.DeepExplainer.html) to generate attributions. To generate DeepSHAP scores, use the `attribute` command. This script takes a fasta file containing 1000 bp records and outputs DeepSHAP attributions and optionally one-hot encoded sequences. Please note that both attribution and ohe are saved as length last for compatibility with [tfmodisco-lite](https://github.com/jmschrei/tfmodisco-lite/).
+
+Two different attribution modes that can be set with `-a/--attribution_type`: `profile` and `quantity`. The `profile` mode calculates interpretations for the profile node of the model (using the profile metric proposed in BPNet), while the `quantity` mode calculates interpretations for the quantity node of the model.
+
+```bash
+clipnet attribute \
+    -f data/test.fa.gz \
+    -o data/test_quantity_shap.npz \
+    -m clipnet_models/ \
+    -a quantity \
+    -v
+
+# -c maybe needed to avoid precision errors.
+```
+
+Note that while CLIPNET accepts two-hot encoded sequences to accomodate heterozygous positions, attributions are much more interpretable when using a haploid/fully homozygous genome, so we recommend avoiding heterozygous positions for attributions. Also note that these are actual contribution scores, as opposed to hypothetical contribution scores. Specifically, non-reference nucleotides are set to zero. To return attribution scores for all nucleotides, use the `-y` flag.
+
+#### Discovering epistatic motifs
+
+`clipnet` supports epistasis analyses using [Deep Feature Interaction Maps (DFIM)](https://github.com/kundajelab/dfim). Please note that this is a custom reimplementation of DFIM using DeepSHAP as the attribution backend, as the original DFIM package is unmaintained and difficult to install. DFIM scores can be calculated for a given fasta file using the `epistasis` command:
+
+```bash
+clipnet epistasis \
+    -f data/test.fa \
+    -o data/test_dfim_profile.npz \
+    -m clipnet_models/ \
+    -s 250 -e 750 \
+    -a profile \
+    -v
+```
+
+Please note DFIM scores don't properly account for things like global epistasis/nonlinearity, which can cause misleading interpretations. For a more robust (but time-consuming) method for estimating interaction effects, see [SQUID](https://github.com/evanseitz/squid-nn).
+
+#### Genomic *in silico* mutagenesis scans
+
+To generate genomic *in silico* mutagenesis scans, use the `ism_shuffle` script. This script takes a fasta file containing 1000 bp records and outputs an npz file containing the ISM shuffle results (`corr_ism_shuffle` and `logfc_ism_shuffle`) for each record. For example:
+
+```bash
+clipnet ism_shuffle -f data/test.fa -o data/test_ism.npz -m clipnet_models/ -v
+```
+
+### API usage
+
+CLIPNET models can be directly loaded as follows. Individual models can simply be loaded using tensorflow:
+
+```python
+import tensorflow as tf
+
+nn = tf.keras.models.load_model("clipnet_models/fold_1.h5", compile=False)
+```
+
+The model ensemble is constructed by averaging track and quantity outputs across all 9 model folds. To make this easy, we've provided a simple API in the `clipnet.clipnet.CLIPNET` class for doing this. Moreover, to make reading fasta files into the correct format easier, we've provided the helper function `clipnet.utils.get_twohot_fasta_sequences`. For example:
+
+```python
+import sys
+from clipnet.clipnet import CLIPNET
+from clipnet.utils import get_twohot_fasta_sequences
+
+nn = CLIPNET()
+ensemble = nn.construct_ensemble("clipnet_models/")
+seqs = get_twohot_fasta_sequences("data/test.fa")
+
+predictions = ensemble.predict(seqs)
+```

clipnet-0.2.1/clipnet/__init__.py

@@ -0,0 +1,9 @@
+# __init__.py
+# Adam He <adamyhe@gmail.com>
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("clipnet")
+except PackageNotFoundError:
+    __version__ = "unknown"

clipnet-0.2.1/clipnet/_calculate_activator_interaction.py

@@ -0,0 +1,159 @@
+## NOT IMPLEMENTED
+
+"""
+Calculate contribution scores using shap.DeepExplainer.
+"""
+
+import argparse
+import gc
+
+import numpy as np
+import shap
+import tensorflow as tf
+
+import .utils
+
+# This will fix an error message for running tf.__version__==2.5
+shap.explainers._deep.deep_tf.op_handlers["AddV2"] = (
+    shap.explainers._deep.deep_tf.passthrough
+)
+tf.compat.v1.disable_v2_behavior()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("core_promoter_seq", type=str, help="")
+    parser.add_argument("motif", type=str, help="Where to write DeepSHAP scores.")
+    parser.add_argument(
+        "--model_dir",
+        type=str,
+        default="ensemble_models",
+        help="Directory to load models from",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        default="quantity",
+        help="Calculate interaction strength using quantity or DFIM",
+    )
+    parser.add_argument("--gpu", action="store_true", help="Enable GPU.")
+    parser.add_argument(
+        "--use_specific_gpu",
+        type=int,
+        default=0,
+        help="Index of GPU to use (starting from 0). Does nothing if --gpu is not set.",
+    )
+    parser.add_argument(
+        "--n_subset",
+        type=int,
+        default=100,
+        help="Maximum number of sequences to use as background. \
+            Default is 100 to ensure reasonably fast compute on large datasets.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=617,
+        help="Random seed for selecting background sequences.",
+    )
+    args = parser.parse_args()
+    np.random.seed(args.seed)
+
+    assert args.mode in [
+        "quantity",
+        "dfim",
+    ], "mode must be either quantity or dfim."
+
+    # Load sequences ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    concat_ref = "".join(shuffled_ref)
+    embedded_promoter = (
+        ushuffle.shuffle(
+            concat_ref, int(np.floor((1000 - len(core_promoter_seq)) / 2)), 2
+        )
+        + core_promoter_seq
+        + ushuffle.shuffle(
+            concat_ref, int(np.ceil((1000 - len(core_promoter_seq)) / 2)), 2
+        )
+    )
+    seqs_to_explain = np.array([utils.OneHotDNA(seq).onehot for seq in sequences])
+
+    # Perform dinucleotide shuffle on n_subset random sequences
+    if len(sequences) < args.n_subset:
+        args.n_subset = len(sequences)
+    reference = [
+        sequences[i]
+        for i in np.random.choice(
+            np.array(range(len(sequences))), size=args.n_subset, replace=False
+        )
+    ]
+    shuffled_reference = [
+        utils.kshuffle(rec.seq, random_seed=args.seed)[0] for rec in reference
+    ]
+
+    # One-hot encode shuffled sequences
+    onehot_reference = np.array(
+        [utils.OneHotDNA(seq).onehot for seq in shuffled_reference]
+    )
+
+    # Load model and create explainer ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if args.gpu:
+        gpus = tf.config.experimental.list_physical_devices("GPU")
+        for gpu in gpus:
+            tf.config.experimental.set_memory_growth(gpu, True)
+        tf.config.set_visible_devices(gpus[args.use_specific_gpu], "GPU")
+    else:
+        tf.config.set_visible_devices([], "GPU")
+
+    if args.model_fp is None:
+        models = [
+            tf.keras.models.load_model(f"{args.model_dir}/fold_{i}.h5", compile=False)
+            for i in range(1, 10)
+        ]
+    else:
+        models = [tf.keras.models.load_model(args.model_fp, compile=False)]
+    if args.mode == "quantity":
+        contrib = [model.output[1] for model in models]
+    else:
+        contrib = [
+            tf.reduce_mean(
+                tf.stop_gradient(tf.nn.softmax(model.output[0], axis=-1))
+                * model.output[0],
+                axis=-1,
+                keepdims=True,
+            )
+            for model in models
+        ]
+    explainers = [
+        shap.DeepExplainer((model.input, contrib), onehot_reference)
+        for (model, contrib) in zip(models, contrib)
+    ]
+
+    # Calculate scores ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    raw_explanations = {i: [] for i in range(len(explainers))}
+    batch_size = 256
+    for i in range(len(explainers)):
+        for j in range(0, len(seqs_to_explain), batch_size):
+            shap_values = explainers[i].shap_values(seqs_to_explain[j : j + batch_size])
+            raw_explanations[i].append(shap_values)
+            gc.collect()
+
+    concat_explanations = []
+    for k in raw_explanations.keys():
+        concat_explanations.append(
+            np.concatenate([exp for exp in raw_explanations[k]], axis=1).sum(axis=0)
+        )
+
+    mean_explanations = np.array(concat_explanations).mean(axis=0)
+    scaled_explanations = mean_explanations * seqs_to_explain
+
+    # Save scores ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    np.savez_compressed(args.score_fp, scaled_explanations.swapaxes(1, 2))
+    np.savez_compressed(args.seq_fp, (seqs_to_explain / 2).astype(int).swapaxes(1, 2))
+
+
+if __name__ == "__main__":
+    main()

clipnet-0.2.1/clipnet/_calculate_dataset_params.py

@@ -0,0 +1,123 @@
+## NOT IMPLEMENTED. PART OF THE FITTING SCRIPTS
+
+"""
+Calculates dataset parameters needed by clipnet. Supply a path to the processed data
+and an output directory. This script will write json files to the output directory
+for use in model training.
+"""
+
+import argparse
+import json
+import os
+
+import numpy as np
+
+
+def write_dataset_params(i, datadir, outdir):
+    outdir = f"{outdir}/f{i}/"
+    os.makedirs(outdir, exist_ok=True)
+
+    test_folds = [i]
+    val_folds = [i % 9 + 1]
+    train_folds = [j for j in range(1, 10) if j not in test_folds + val_folds]
+    print(train_folds, val_folds, test_folds)
+
+    dataset_params = {
+        "train_seq": [
+            os.path.join(datadir, f"concat_sequence_{fold}.npz") for fold in train_folds
+        ],
+        "train_procap": [
+            os.path.join(datadir, f"concat_procap_{fold}.npz") for fold in train_folds
+        ],
+        "val_seq": [
+            os.path.join(datadir, f"concat_sequence_{fold}.npz") for fold in val_folds
+        ],
+        "val_procap": [
+            os.path.join(datadir, f"concat_procap_{fold}.npz") for fold in val_folds
+        ],
+        "test_seq": [
+            os.path.join(datadir, f"concat_sequence_{fold}.npz") for fold in test_folds
+        ],
+        "test_procap": [
+            os.path.join(datadir, f"concat_procap_{fold}.npz") for fold in test_folds
+        ],
+    }
+
+    dataset_params["n_train_folds"] = len(train_folds)
+    dataset_params["n_val_folds"] = len(val_folds)
+    dataset_params["n_test_folds"] = len(test_folds)
+
+    # Calculate n_samples_per_chunk
+    dataset_params["n_samples_per_train_fold"] = [
+        np.load(f)["arr_0"].shape[0] for f in dataset_params["train_procap"]
+    ]
+    dataset_params["n_samples_per_val_fold"] = [
+        np.load(f)["arr_0"].shape[0] for f in dataset_params["val_procap"]
+    ]
+    dataset_params["n_samples_per_test_fold"] = [
+        np.load(f)["arr_0"].shape[0] for f in dataset_params["test_procap"]
+    ]
+
+    dataset_params["window_length"] = np.load(dataset_params["train_seq"][0])["arr_0"][
+        0
+    ].shape[0]
+
+    dataset_params["pad"] = int(dataset_params["window_length"] / 4)
+    dataset_params["output_length"] = int(
+        2 * (dataset_params["window_length"] - 2 * dataset_params["pad"])
+    )
+
+    dataset_params["weight"] = 1 / 500
+
+    output_fp = os.path.join(outdir, "dataset_params.json")
+
+    with open(output_fp, "w") as handle:
+        json.dump(dataset_params, handle, indent=4, sort_keys=True)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("datadir", type=str, help="directory containing data")
+    parser.add_argument(
+        "outdir",
+        type=str,
+        help="directory to save dataset params to (where models will be saved)",
+    )
+    parser.add_argument(
+        "--threads",
+        type=int,
+        default=9,
+        help="number of threads to use. Only used if not --fold is not selected.",
+    )
+    parser.add_argument(
+        "--fold",
+        type=int,
+        default=None,
+        help="fold to calculate dataset params for (will only run one).",
+    )
+    args = parser.parse_args()
+    if args.threads <= 0:
+        raise ValueError("--threads must be a positive integer")
+    if args.fold is not None:
+        write_dataset_params(args.fold, args.datadir, args.outdir)
+    else:
+        if args.threads == 1:
+            for i in range(1, 10):
+                write_dataset_params(i, args.datadir, args.outdir)
+        elif args.threads > 1:
+            import itertools
+            import multiprocessing as mp
+
+            with mp.Pool(9) as p:
+                p.starmap(
+                    write_dataset_params,
+                    zip(
+                        range(1, 10),
+                        itertools.repeat(args.datadir),
+                        itertools.repeat(args.outdir),
+                    ),
+                )
+
+
+if __name__ == "__main__":
+    main()

clipnet-0.2.1/clipnet/_calculate_ism_shuffle.py

@@ -0,0 +1,157 @@
+## NOT IMPLEMENTED
+
+"""
+Calculate ISM shuffle scores.
+"""
+
+import argparse
+import logging
+import os
+
+import numpy as np
+import pyfastx
+import tqdm
+from scipy.spatial.distance import cdist
+
+import utils
+
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "4"
+logging.getLogger("tensorflow").setLevel(logging.FATAL)
+import clipnet
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("fasta_fp", type=str, help="Fasta file path.")
+    parser.add_argument(
+        "score_fp", type=str, help="Where to write ISM shuffle results."
+    )
+    parser.add_argument(
+        "--model_dir",
+        type=str,
+        default="ensemble_models/",
+        help="directory to load models from.",
+    )
+    parser.add_argument(
+        "--gpu",
+        type=int,
+        default=None,
+        help="Index of GPU to use (starting from 0). If not invoked, uses CPU.",
+    )
+    parser.add_argument(
+        "--n_shuffles",
+        type=int,
+        default=5,
+        help="Number of shuffles/mutations to perform for each position.",
+    )
+    parser.add_argument(
+        "--mut_size", type=int, default=10, help="Size of mutations to use."
+    )
+    parser.add_argument(
+        "--edge_padding",
+        type=int,
+        default=50,
+        help="Number of positions from edge that we'll skip mutating on.",
+    )
+    parser.add_argument(
+        "--corr_pseudocount",
+        type=float,
+        default=1e-6,
+        help="Pseudocount for correlation calculation.",
+    )
+    parser.add_argument(
+        "--log_quantity_pseudocount",
+        type=float,
+        default=1e-3,
+        help="Pseudocount for log quantity calculation.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=617,
+        help="Random seed for generating mutations.",
+    )
+    parser.add_argument(
+        "--silence",
+        action="store_true",
+        help="Disables progress bars and other non-essential print statements.",
+    )
+    args = parser.parse_args()
+    np.random.seed(args.seed)
+
+    # Load models ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    nn = (
+        clipnet.CLIPNET(n_gpus=1, use_specific_gpu=args.gpu)
+        if args.gpu is not None
+        else clipnet.CLIPNET(n_gpus=0)
+    )
+    ensemble = nn.construct_ensemble(args.model_dir, silence=args.silence)
+
+    # Load sequences ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    sequences = pyfastx.Fasta(args.fasta_fp)
+    seqs_twohot = utils.get_twohot_fasta_sequences(args.fasta_fp, silence=args.silence)
+
+    # Calculate ISM shuffle scores ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    wt_pred = ensemble.predict(seqs_twohot, batch_size=256, verbose=0)
+    corr_scores = []
+    log_quantity_scores = []
+    for i in tqdm.tqdm(
+        range(len(sequences)),
+        desc="Calculating ISM shuffle scores",
+        disable=args.silence,
+    ):
+        corr_score = []
+        log_quantity_score = []
+        rec = sequences[i]
+        positions = range(args.edge_padding, len(rec.seq) - args.edge_padding)
+        for shuffle in range(args.n_shuffles):
+            mutated_seqs = []
+            for pos in positions:
+                mut = utils.kshuffle(rec.seq, random_seed=args.seed)[0][: args.mut_size]
+                mutated_seq = (
+                    rec.seq[0 : pos - int(len(mut) / 2)]
+                    + mut
+                    + rec.seq[pos + int(len(mut) / 2) :]
+                )
+                mutated_seqs.append(mutated_seq)
+            mut_pred = ensemble.predict(
+                np.array([utils.TwoHotDNA(seq).twohot for seq in mutated_seqs]),
+                batch_size=256,
+                verbose=0,
+            )
+            mut_corr = (
+                1
+                - cdist(
+                    np.array(
+                        [wt_pred[0][i, :]] * len(positions)
+                        + np.random.normal(
+                            0, args.corr_pseudocount, mut_pred[0].shape[1]
+                        )
+                    ),
+                    mut_pred[0]
+                    + np.random.normal(0, args.corr_pseudocount, mut_pred[0].shape[1]),
+                    metric="correlation",
+                )[0, :]
+            )
+            mut_log_quantity = np.log10(
+                mut_pred[1] + args.log_quantity_pseudocount
+            ) - np.log10(wt_pred[1][i] + args.log_quantity_pseudocount)
+            corr_score.append(mut_corr)
+            log_quantity_score.append(mut_log_quantity)
+        corr_scores.append(np.array(corr_score).mean(axis=0))
+        log_quantity_scores.append(np.array(log_quantity_score).mean(axis=0))
+
+    # Save scores ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    np.savez_compressed(
+        args.score_fp,
+        corr_ism_shuffle=np.array(corr_scores),
+        log_quantity_ism_shuffle=np.array(log_quantity_scores),
+    )
+
+
+if __name__ == "__main__":
+    main()