# Finding Motifs in DNA Sequences with Python By the end of this guide you will be able to load DNA sequences from a FASTA file, search them for exact and degenerate motifs, score candidate sites with a position weight matrix, scan both strands, judge whether a hit count is better than chance, and scale the search to large datasets. Everything runs in standard Python with Biopython and NumPy, which are the tools that most published Python-based sequence analysis pipelines are built on. Python has become a default language for this kind of work across bioinformatics, from small helper scripts to large parallel pipelines that process millions of genomic features at once [1]. You need Python 3.8 or newer, the Biopython and NumPy packages, a FASTA file of DNA sequences to search, and a motif to search for. The motif can be a plain string such as TATAAT, a degenerate consensus using IUPAC ambiguity codes, or a position weight matrix you have exported from a motif database. ## What a Motif Is and How Python Represents It A motif is a short, recurring pattern in DNA that is enriched because of some biological function, most often binding by a [transcription factor](/knowledge/molecular-biology/transcription-factor). Three representations cover almost every practical case. An exact motif is a fixed string, for example GGGCGG, the core of an SP1-like GC box. A degenerate motif allows more than one base at some positions. The standard encoding is the IUPAC nucleic acid code, where each letter stands for a subset of the four bases. A string written in IUPAC codes is formally a degenerate pattern over the alphabet A, C, G, T, and this representation is one of the major models used for transcription factor binding sites in upstream gene regions [2]. A position weight matrix, usually shortened to PWM, goes one step further. Instead of allowing or forbidding bases at each position, it assigns each base a score at each position, typically the log base 2 of the frequency of that base in known binding sites divided by its background frequency. A perfect match to a six-position consensus under an equal background therefore scores 2 bits per position, or 12 bits total, because 1 divided by 0.25 equals 4 and log2 of 4 is 2. | IUPAC code | Meaning | Regex equivalent | |--|--|--| | A, C, G, T | Single base | The base itself | | R | A or G (puRine) | [AG] | | Y | C or T (pYrimidine) | [CT] | | S | G or C (Strong) | [GC] | | W | A or T (Weak) | [AT] | | K | G or T (Keto) | [GT] | | M | A or C (aMino) | [AC] | | B | C, G or T (not A) | [CGT] | | D | A, G or T (not C) | [AGT] | | H | A, C or T (not G) | [ACT] | | V | A, C or G (not T) | [ACG] | | N | Any base | [ACGT] | Keep this table next to your keyboard. Most motif files you will download, including transcription factor binding site definitions, use exactly these letters, and the regex column is what your Python code will actually execute [2]. ## Setting Up the Environment Install the two packages you need from the command line. ```bash python -m pip install biopython numpy ``` Verify the install before writing any analysis code. ```bash python -c "import Bio, numpy; print(Bio.__version__, numpy.__version__)" ``` Expected output looks like this, with your own version numbers. ``` 1.83 1.26.4 ``` Biopython is the workhorse library for Python for bioinformatics. It is a large distribution of modules covering sequence input and output, alignments, and database interfaces, and third-party modules such as the SCOP and ASTRAL interface are designed to work as part of that same distribution [3]. For raw sequence handling and format conversion, companion libraries such as EggLib, a C++ and Python package for sequence [data management](/blog/guides/data-management-basics-principles-processes-and-best-practices), show the same pattern you will use here, a Python front end over fast compiled code [4]. ## Step-by-Step Workflow for Finding Motifs The following steps form a complete, reproducible pipeline. Every block of code is self-contained and prints something you can check against the expected output. ### Step 1. Load your sequences from FASTA Save your sequences in a file called promoters.fasta in FASTA format, one header line starting with a greater than sign followed by the sequence. Then parse it with Biopython's SeqIO module. ```python from Bio import SeqIO records = [] for record in SeqIO.parse("promoters.fasta", "fasta"): records.append((record.id, str(record.seq).upper())) print(record.id, len(record.seq)) ``` Expected output for a file with three promoter sequences. ``` geneA_promoter 1000 geneB_promoter 1000 geneC_promoter 1000 ``` Call upper() immediately. Many genome FASTA files are soft-masked, meaning repeat regions are lowercase and genic regions are uppercase. If you skip this step, an exact string search will silently miss every motif occurrence inside a lowercase repeat. This single line prevents the most common silent failure in motif searching. ### Step 2. Search for an exact motif Python strings have find() built in, but find() returns only the first hit. Motif searches need overlapping matches, because binding sites in real genomes often overlap. Write a small function that walks the sequence. ```python def find_exact(sequence, motif): positions = [] start = 0 while True: index = sequence.find(motif, start) if index == -1: break positions.append(index) start = index + 1 return positions seq = records[1] hits = find_exact(seq, "GGGCGG") print(hits[:5]) print("total:", len(hits)) ``` Expected output on a GC-rich promoter might look like this. ``` [142, 143, 512, 519, 880] total: 11 ``` The start = index + 1 line is what makes overlapping hits possible. If you instead jump start = index + len(motif), you will miss overlapping sites. Notice that positions are zero-based, meaning the first base of the sequence is position 0. This matters when you report coordinates to collaborators, because GFF and GTF annotation files count bases starting from 1 while Python, BED files, and Biopython count from 0. Off-by-one errors between these coordinate systems are a leading cause of wrong motif locations in published tables. ### Step 3. Search for a degenerate motif with a regex Translate IUPAC codes into regular expression character classes, then let the re module do the scanning. This is the standard way degenerate motifs are modeled computationally [2]. ```python import re IUPAC = { "R": "[AG]", "Y": "[CT]", "S": "[GC]", "W": "[AT]", "K": "[GT]", "M": "[AC]", "B": "[CGT]", "D": "[AGT]", "H": "[ACT]", "V": "[ACG]", "N": "[ACGT]", } def motif_to_regex(motif): pattern = "".join(IUPAC.get(base, base) for base in motif.upper()) return re.compile(pattern) def find_degenerate(sequence, motif): regex = motif_to_regex(motif) return [(m.start(), m.group()) for m in regex.finditer(sequence)] hits = find_degenerate(seq, "GGGCGGN") print(hits[:5]) ``` Expected output, where each tuple holds the zero-based start and the matched seven base window. ``` [(142, 'GGGCGGA'), (143, 'GGGCGGC'), (512, 'GGGCGGT')] ``` Two parameters matter here. First, the motif string itself, which you should always uppercase so that soft-masked input cannot break the lookup. Second, re.finditer versus re.search. finditer returns every non-overlapping match by default, but because each character class consumes exactly one base, consecutive matches at positions 142 and 143 in the example are both reported, which is the overlap behavior you want for motif scanning. One practical tip is to precompile the regex once per motif and reuse it across thousands of sequences. Compiling inside the inner loop of a large scan wastes a noticeable amount of time. For a real study of transcription factor binding sites, degenerate pattern search is only the starting point. Finding the optimal degenerate pattern consistent with positive and negative sequence sets is NP-complete in general, which is why dedicated tools use heuristics. The SUPERPOSITION algorithm enumerates candidate degenerate patterns with a pruning technique and compared favorably with the popular motif finders YMF, MEME and AlignACE on several sets of co-regulated yeast genes [2]. Use your own script for scanning known motifs, and reach for dedicated discovery tools when you need to discover motifs from scratch. ### Step 4. Build and score a position weight matrix A PWM captures the fact that some positions in a binding site are highly constrained while others are flexible. Build one from a small alignment of known sites. ```python import numpy as np alignment = [ "TATAAT", "TATAAT", "TCTAAT", "TATTTT", "AATAAT", ] bases = "ACGT" counts = np.zeros((4, len(alignment))) for row in alignment: for pos, base in enumerate(row.upper()): counts[bases.index(base), pos] += 1 pseudocount = 1.0 frequencies = (counts + pseudocount) / (counts.sum(axis=0) + 4 * pseudocount) background = 0.25 weights = np.log2(frequencies / background) print(np.round(weights[:, 0], 2)) ``` Expected output for the first column, where A appears once and T appears four times. ``` [ 0. -1. -1. 1.32] ``` Each parameter in this block changes your results, so know what it does. The pseudocount is a constant added to every count. Without it, a base that never appears at a position gets frequency zero and a log of negative infinity, which breaks downstream arithmetic. A pseudocount of 1.0 is a common mild choice. Larger pseudocounts flatten the matrix and make scores more conservative. The denominator counts.sum(axis=0) + 4 * pseudocount keeps the four frequencies at each column summing to 1. The background probability, here 0.25, is the frequency you would expect for each base by chance. If your sequences are GC rich, using 0.25 overstates how surprising a GC-rich motif is. When you have a real background, for example 0.35 G plus 0.35 C, pass per-base background frequencies instead of a single number and divide each column by the matching background probability. ### Step 5. Scan both strands and report hits ![Flowchart of a reverse complement scan, a raw minus strand index, conversion by length minus index minus motif length, and a reported plus strand hit.](/article-images/illustrations/find-motifs-in-dna-sequence-python-minus-strand-coordinates.webp) Transcription factor sites occur on both strands, and a site on the minus strand looks like the reverse complement in plus-strand coordinates. Scan both. ```python from Bio.Seq import Seq def score(window, weights, bases="ACGT"): total = 0.0 for pos, base in enumerate(window.upper()): total += weights[bases.index(base), pos] return total def scan(sequence, weights, threshold): L = weights.shape[1] rc = str(Seq(sequence).reverse_complement()) hits = [] for strand, target in (("+", sequence), ("-", rc)): for i in range(len(target) - L + 1): s = score(target[i:i + L], weights) if s >= threshold: if strand == "+": report_pos = i else: report_pos = len(sequence) - i - L hits.append((strand, report_pos, target[i:i + L], round(s, 2))) return hits hits = scan(seq, weights, threshold=6.0) print(hits[:5]) print("total:", len(hits)) ``` Expected output. ``` [('+', 214, 'TATAAT', 9.5), ('-', 603, 'TATAAT', 9.5), ('+', 871, 'TATTTT', 7.4)] total: 3 ``` The threshold is the parameter that controls your sensitivity and precision tradeoff. A low threshold such as 4.0 returns many weak sites and many false positives. A high threshold such as 8.0 returns only near-consensus matches. A defensible starting point is to pick a threshold that keeps a chosen fraction of random sequences above it, or to report the score alongside every hit so readers can apply their own cutoff. Watch the coordinate conversion in the minus-strand branch. Index i on the reverse complement corresponds to plus-strand position len(sequence) - i - L. If you report the raw reverse-complement index as if it were a plus-strand coordinate, every minus-strand hit in your output table will point to the wrong locus. This is one of the most frequent errors when analysts first scan both strands. ### Step 6. Ask whether your hit count beats chance ![Calculation of expected TATANT motif hits in a 10,000 base sequence: degeneracy 4, probability 4 over 4096, about 9.8 expected hits.](/article-images/illustrations/find-motifs-in-dna-sequence-python-expected-hits-tatant.webp) Before interpreting a motif, estimate how many hits random sequence of the same length would contain. For a degenerate motif of length L, the chance that any one position matches is the motif's degeneracy, the product of the number of allowed bases at each position, divided by 4 to the power L. ```python from math import prod def degeneracy(motif): sizes = {"A":1,"C":1,"G":1,"T":1, "R":2,"Y":2,"S":2,"W":2,"K":2,"M":2, "B":3,"D":3,"H":3,"V":3,"N":4} return prod(sizes[b] for b in motif.upper()) def expected_hits(seq_length, motif): L = len(motif) p = degeneracy(motif) / 4 ** L return (seq_length - L + 1) * p print(expected_hits(10000, "TATANT")) ``` Expected output. ``` 9.761474609375 ``` The worked calculation is easy to follow. TATANT has degeneracy 1 times 1 times 1 times 1 times 4 times 1, which is 4. The match probability is 4 over 4096, about 0.00098. A 10,000 base sequence has 9,995 possible start positions, so the expected number of hits is about 9.8. If you observe 30 or 40 hits in that sequence, the excess is unlikely to be chance. To attach a formal p-value, use the binomial tail, which models the number of hits as trials at that same per-position probability. ```python from scipy.stats import binom p = binom.sf(29, 9995, 4/4096) print(p) ``` For 30 or more observed hits against an expectation of about 9.8, this probability comes out on the order of one hundred-thousandth, small enough to treat the enrichment as real for a first-pass screen. Run the command yourself rather than trusting the printed number here, because the exact value depends on your SciPy version and rounding. Two caveats belong next to this calculation. Genomes are not random, so background composition varies by organism and even by region. And a significant excess of a short motif in a long sequence is common for simple repeats, so enrichment alone does not prove biological function. ### Step 7. Get the right input sequences from genome annotations Most motif searches run on promoters or other upstream regions, which means you first need to extract those regions from a genome. If you have a GFF3 or GTF annotation file and a genome FASTA, you can parse the annotation, find each gene's coordinates, and slice the upstream window from the genome record yourself. ```python def upstream_window_from_gff_line(line, genome_seq, upstream=500): fields = line.rstrip("\n").split("\t") if fields[5] != "gene": return None start, end = int(fields[6]), int(fields[7]) # GFF is 1-based inclusive strand = fields[8] if strand == "+": lo = max(start - 1 - upstream, 0) # convert to 0-based hi = start - 1 else: lo = end hi = min(end + upstream, len(genome_seq)) window = genome_seq[lo:hi] if strand == "-": window = str(Seq(window).reverse_complement()) return window ``` The comments flag the two traps. GFF and GTF coordinates are 1-based and inclusive, while Python slicing is 0-based and exclusive at the end, so a GFF start of 1001 becomes Python index 1000. And for genes on the minus strand, the upstream region lies after the gene body in plus-strand coordinates, so you slice downstream and then reverse complement so the promoter reads in the gene's own orientation. When you need this routinely across a whole genome, use a tool built for the job rather than hand-rolling it. GAD is a Python tool that extracts features such as intergenic regions and upstream and downstream gene regions from GFF3 and GTF files and writes them out in BED, GTF, GFF3 and FASTA formats that other programs accept directly [7]. At larger scales, libraries such as metaseq load multiple genomic data formats into standard Python data structures for flexible manipulation and visualization [8], and PyGMQL runs region-based queries over thousands of heterogeneous datasets on the Apache Spark engine from a native Python interface [9]. The lesson is consistent across these projects, that Python excels as the glue layer over fast lower-level implementations. ### Step 8. Scale up when sequences get large The naive loop in Step 5 is fast enough for hundreds of promoter sequences but not for a whole genome. Two standard accelerations apply. First, vectorize. Instead of scoring one window at a time in Python, convert the sequence to an integer array once and use NumPy to add the right weight column for every start position in a single operation. This typically turns minutes of pure Python into seconds. Second, parallelize across cores. MPI, the Message Passing Interface, is the standard way to coordinate work across the cores of one machine or the nodes of a cluster, and the mpi4py module brings it into Python. Standard mpi4py cannot pass objects larger than 2 to the 31 bytes between processes, which real genome-scale arrays exceed. BigMPI4py wraps mpi4py to support objects beyond that boundary, automatically chooses an optimal distribution strategy, and uses vectorized methods for higher parallel efficiency [1]. In a real application, its authors used it to accelerate a search for germline-specific [DNA methylation](/blog/guides/dna-methylation) motifs across 59 whole-genome [bisulfite sequencing](/knowledge/molecular-biology/bisulfite-sequencing) samples from 27 human tissues in the ENCODE project, evaluating 55 million CpG sites with a 22-fold speedup on 25 cores [1]. The design pattern there, distribute sequence chunks to workers, score locally, merge results, applies directly to motif scanning. Third, consider compressed representations for very large batch analyses. ProdMX uses compressed sparse matrices to cut the memory and time cost of functional domain matrix operations in high-throughput protein analysis, and installs through PyPI or Conda [10]. The same sparse-matrix thinking helps when you score millions of candidate windows against many motifs at once, because most windows match almost no motif. ### Step 9. Sanity-check the results Never publish a motif table without at least three checks. Recover a known site. Take a gene whose binding site has been experimentally characterized, search your output for it, and confirm the coordinate matches the literature position once you account for the one-based versus zero-based difference. Count strands symmetrically. For a motif with no strand preference, hits on plus and minus strands should be roughly balanced. A large imbalance usually means a coordinate bug or a truncated sequence. Compare against an independent implementation. Run the same sequence and motif through a second tool. RepeatsPlus is a program for finding motifs and repeats in data sequences that reports all motifs mathematically, then filters them by sequence length, number of occurrences, motif masking, and ambiguous letters in the input, and it is implemented in Python and C [6]. If your script and RepeatsPlus agree on the count for a filtered query, your coordinates and matching logic are probably right. ## Practical Tips for Finding Motifs in DNA Sequences with Python Compile regexes once. Build every motif_to_regex object at the start of your script and pass the compiled pattern around. Compilation is not free and the savings multiply over thousands of sequences. Separate discovery from scanning. Scanning a known motif is a solved, fast problem. Discovering an unknown motif from a set of co-regulated genes is computationally hard, and the general degenerate pattern problem is NP-complete, so use established discovery algorithms with pruning strategies rather than a brute-force script [2]. Match the representation to the question. Exact strings answer whether a precise site exists. Degenerate regexes answer whether a consensus family exists. PWMs answer how strongly a window resembles a set of known sites. Hidden Markov models answer where the sequence switches between compositional regimes, which is a segmentation question rather than a pattern question. The Sarment package provides Python modules for exactly that, with efficient implementations of hidden Markov model computation and maximal predictive partitioning, and its object-oriented design makes segmentation results easy to manipulate downstream [5]. Use rank-based methods when you have binding measurements but no validated matrix. Top-Down Crawl aligns k-mer level binding data in a rank-dependent way without requiring a PWM, works with inputs from protein binding microarrays, SELEX-seq and SMiLE-seq experiments, and installs locally as a Python package from PyPI under the name TopDownCrawl [11]. Keep scores with every hit. A table of coordinates without scores cannot be re-filtered later. Always write out the strand, the zero-based start, the matched sequence, and the score. Version your inputs. Record the genome assembly version and annotation release with your results. A motif coordinate that is correct for one assembly is silently wrong for another. Within larger analysis frameworks, motifs often serve as filters inside multi-step workflows. In the pySCENIC workflow for single-cell gene regulatory network analysis, coexpression modules inferred by GRNBoost2 are pruned using cis-regulatory motif enrichment before regulon activity is quantified, and the Python reimplementation brought a roughly tenfold speed increase over the original [12]. That pattern, motif enrichment as one stage of a reproducible pipeline, is a good template for your own projects. ## Common Mistakes and Limitations Forgetting the reverse strand. The single most common mistake. Any biologically meaningful scan covers both orientations, and any published scan that claims only plus-strand results should raise suspicion. Mixing coordinate systems. Python, Biopython and BED are zero-based. GFF, GTF and most human-facing formats are one-based. Write the conversion in one helper function, test it against a known feature, and never convert coordinates inline in the middle of a script. Ignoring case. Soft-masked FASTA files carry lowercase repeats. A case-sensitive search without upper() misses those hits without any warning. Call upper() on input and, if repeats should not count as motifs, mask or exclude them explicitly, which is exactly the kind of repeat filtering that dedicated tools such as RepeatsPlus provide as first-class options [6]. Dropping the pseudocount. A PWM built without pseudocounts produces negative infinite scores whenever a window contains a base absent from your training alignment. One missing base can poison an entire scan. Add a pseudocount and check that all weights are finite before scanning. Using an equal background for GC-rich genomes. Under an equal background assumption, every GC-rich hit looks more significant than it is. Estimate background base frequencies from your actual sequences and use them in the log-odds formula. Treating motif occurrence as proof of regulation. A PWM hit is a hypothesis. Binding depends on chromatin context, cofactors and cell type. Score thresholds rank candidates, they do not confirm function. Confusing search complexity with discovery complexity. Finding all occurrences of a fixed pattern is trivial. Finding the best degenerate pattern that separates positive from negative sequence sets is NP-complete in general, which is why heuristic tools such as SUPERPOSITION exist and why exhaustive searches stall on realistic motif lengths [2]. Overlooking ambiguous letters in input. Sequences containing N or other ambiguity codes can produce matches or misses that depend on how your regex treats those characters. Decide explicitly whether N should match a wildcard position and state that choice in your methods. Not reporting thresholds. A scan without its score threshold cannot be reproduced. Report the threshold, the pseudocount, the background model, and the motif version alongside every result. ## How to Verify Your Results Are Correct Verification has three levels. At the code level, write a test with a synthetic sequence you designed, for example a 20 base random sequence with TATAAT inserted at position 7, and assert that your function returns exactly one hit at position 7 on the plus strand and a predictable position on the minus strand. At the pipeline level, compare total hit counts for the same motif against an independent tool such as RepeatsPlus on the same filtered input [6]. At the biology level, check that motifs you recover land where the literature says they should, for example that bacterial promoter minus 10 box hits sit roughly 10 to 17 bases upstream of predicted transcription starts rather than scattered uniformly. A quick numerical check of your PWM also catches many errors. The maximum score of any single column under an equal background is 2 bits, so a perfect length 6 match cannot exceed 12 bits. If your matrix produces column scores above 2 bits, your background or pseudocount arithmetic is off. ## Frequently Asked Questions ### What counts as a motif in DNA? A motif is a short recurring DNA pattern, typically 6 to 20 bases, that appears more often than chance because of a functional role such as transcription factor binding. It can be written as an exact string, a degenerate IUPAC consensus, or a position weight matrix. ### Do I need Biopython to find motifs in a DNA sequence with Python? No, a plain string search works for simple cases, but Biopython gives you reliable FASTA parsing, reverse complements, and format conversion in a few lines. For any work beyond a single sequence, installing Biopython saves time and prevents parsing errors. ### How do I search for motifs with mismatches? Either use a degenerate regex with IUPAC codes, allow a fixed number of mismatches by comparing each window to the motif and counting differences, or score every window against a PWM and apply a threshold. The PWM approach is the most flexible because it weights each position rather than treating all mismatches equally. ### What is a PWM and when should I use one instead of a regex? A position weight matrix assigns each base a log-odds score at each position, so it distinguishes strongly conserved positions from flexible ones. Use a regex for crisp consensus rules and a PWM when you have a set of known binding sites and want to rank candidate sites by similarity to that set. ### How do I handle the reverse strand in a motif search? Scan the sequence and its reverse complement separately, then convert reverse-complement coordinates back to plus-strand coordinates with the formula len(sequence) minus index minus motif length before reporting. Report the strand for every hit. ### How do I know if a motif hit count is statistically significant? Compute the expected number of hits from the motif's degeneracy divided by 4 to the power of its length, times the number of possible start positions, then test the observed count against that expectation with a binomial tail probability. Enrichment beyond expectation supports the motif being nonrandom. ### Can Python handle whole-genome motif scans? Yes, with vectorized NumPy scoring and parallel execution. Libraries such as BigMPI4py extend mpi4py to objects larger than 2 to the 31 bytes and have supported genome-scale analyses with strong speedups on multicore systems [1]. For queries across thousands of region datasets, PyGMQL provides scalable extraction and analysis from Python [9]. ### When should I use a dedicated motif discovery tool instead of writing my own script? Use your own Python code to scan motifs you already know. Use dedicated discovery tools when the motif is unknown, because optimal degenerate pattern discovery is NP-complete and established tools use pruned heuristics that outperform naive enumeration [2]. Specialized packages also handle niche questions directly, such as rank-based alignment of k-mer binding data in Top-Down Crawl [11] or hidden Markov model segmentation in Sarment [5]. ## Sources 1. [BigMPI4py: Python Module for Parallelization of Big Data Objects Discloses Germ Layer Specific DNA Demethylation Motifs.](https://pubmed.ncbi.nlm.nih.gov/33301409/) 2. [Finding optimal degenerate patterns in DNA sequences.](https://pubmed.ncbi.nlm.nih.gov/14534191/) 3. [A high level interface to SCOP and ASTRAL implemented in python.](https://pubmed.ncbi.nlm.nih.gov/16403221/) 4. [EggLib: processing, analysis and simulation tools for population genetics and genomics.](https://pubmed.ncbi.nlm.nih.gov/22494792/) 5. [Sarment: Python modules for HMM analysis and partitioning of sequences.](https://pubmed.ncbi.nlm.nih.gov/15947017/) 6. [RepeatsPlus - program for finding motifs and repeats in data sequences.](https://pubmed.ncbi.nlm.nih.gov/33896395/) 7. [GAD: A Python Script for Dividing Genome Annotation Files into Feature-Based Files.](https://pubmed.ncbi.nlm.nih.gov/32524530/) 8. [metaseq: a Python package for integrative genome-wide analysis reveals relationships between chromatin insulators and associated nuclear mRNA.](https://pubmed.ncbi.nlm.nih.gov/25063299/) 9. [PyGMQL: scalable data extraction and analysis for heterogeneous genomic datasets.](https://pubmed.ncbi.nlm.nih.gov/31703553/) 10. [ProdMX: Rapid query and analysis of protein functional domain based on compressed sparse matrices.](https://pubmed.ncbi.nlm.nih.gov/33335686/) 11. [Top-Down Crawl: a method for the ultra-rapid and motif-free alignment of sequences with associated binding metrics.](https://pubmed.ncbi.nlm.nih.gov/36179084/) 12. [A scalable SCENIC workflow for single-cell gene regulatory network analysis.](https://pubmed.ncbi.nlm.nih.gov/32561888/)