AIUPred

About | How to install | Command Line Usage | Nextflow | Programmatic Usage (Python API) | API Reference | Benchmarks | License | How to cite

What's New in AIUPred v3

Novel integrated energy embedding framework for the different flavours of disorder. Redesigned OOP based framework for easier use and implementation. This latest version has also been independently evaluated in the Critical Assessment of protein Intrinsic Disorder (CAID) blind benchmark, where it achieved top-tier performance across evaluated categories.

CAID3 Results

Category	AUC	Max F1
Disorder NOX	0.825	0.633
Disorder PDB	0.925	0.814
Binding	0.764	0.338
Binding IDR	0.590	0.557

About

Intrinsically disordered proteins (IDPs) have no single well-defined tertiary structure under native conditions. AIUPred is a tool that allows to identify disordered protein regions, their binding sites, and flexible linkers, created by Zsuzsanna Dosztányi and Gábor Erdős.

AIUPred provides both a standalone command-line interface (CLI) and an importable Python library for seamless integration into bioinformatics pipelines. The library can also be used as a feature extractor to generate high-quality structural embeddings for downstream machine learning tasks.

AIUPred is also available as a web server: https://aiupred.elte.hu/

For more information please refer to the publication: AIUPred: combining energy estimation with deep learning for the enhanced prediction of protein disorder

Requirements

AIUPred requires Python 3.8+ and relies on modern scientific computing libraries (torch>=2.0.0, numpy>=1.21.0, scipy>=1.7.0). These dependencies are automatically installed when you install the package via pip.

---

How to install

It is recommended to install AIUPred inside a virtual environment (e.g., Conda or venv).

Pip install (CLI + Python API)

Because AIUPred is a standard Python package, you can install it directly from GitHub using pip:

pip install git+https://github.com/doszilab/AIUPred.git

Alternatively, you can clone the repository and install it locally:

git clone git@github.com:doszilab/AIUPred.git
cd AIUPred
pip install .

Nextflow install and setup (workflow execution)

Use this when you want Nextflow to orchestrate runs (one process per FASTA) with a fixed environment. You need Nextflow (>= 22.10) plus either Micromamba/Conda or Docker.

GPU vs CPU inside the workflow

Unless you add -profile cpu, the aiupred process does not pass --force-cpu. AIUPred then uses a GPU when PyTorch sees CUDA (torch.cuda.is_available()); if not, it falls back to CPU (you may see a “No GPU found” log message). Add -profile cpu to always run on CPU (--force-cpu).

Pipeline options (parameters)

What you set	Effect
--input	FASTA path or glob (required unless you use -profile test)
--outdir	Where published *.aiupred.tsv files go (default: results)
--aiupred.predict_binding true	Adds -b (binding prediction)
--aiupred.predict_linker true	Adds -l (linker prediction)
--aiupred.redox true	Adds -r (redox mode)
--aiupred.gpu N	GPU index for -g (default 0; only relevant when not forcing CPU)
-profile cpu	Forces --force-cpu for AIUPred

If your Nextflow version does not accept dotted keys on the command line, pass the same flags via a YAML -params-file (nested under aiupred:), for example:

aiupred:
  predict_binding: true
  predict_linker: true

Option 1: Conda profile (-profile conda)

Smoke test (bundled FASTA):

nextflow run doszilab/AIUPred -r master -profile test,conda

Custom FASTA, GPU if available (omit -profile cpu):

nextflow run doszilab/AIUPred -r master -profile conda --input '/path/to/*.fasta' --outdir results

Same run, CPU only:

nextflow run doszilab/AIUPred -r master -profile conda,cpu --input '/path/to/*.fasta' --outdir results

Binding + linker on a custom FASTA:

nextflow run doszilab/AIUPred -r master -profile conda --input '/path/to/proteins.fasta' --outdir results --aiupred.predict_binding true --aiupred.predict_linker true

Option 2: Docker profile (-profile docker)

Uses the CUDA-capable container image from GHCR. PyTorch uses GPU when CUDA is visible inside the container; otherwise it falls back to CPU (same logic as above). On machines without GPU passthrough into Docker, expect CPU execution with a larger image pull.

Smoke test:

nextflow run doszilab/AIUPred -r master -profile test,docker

Custom FASTA:

nextflow run doszilab/AIUPred -r master -profile docker --input '/path/to/*.fasta' --outdir results

CPU only (smaller CPU-optimized image + --force-cpu via docker_cpu):

nextflow run doszilab/AIUPred -r master -profile docker_cpu --input '/path/to/*.fasta' --outdir results

Binding + linker:

nextflow run doszilab/AIUPred -r master -profile docker --input '/path/to/proteins.fasta' --outdir results --aiupred.predict_binding true --aiupred.predict_linker true

Pinning a release (optional)

nextflow run doszilab/AIUPred -r 3.1.1 -profile test,conda

---

Command Line Usage

The aiupred command below is installed by the pip install path (pip install ... or pip install .). Nextflow execution does not install aiupred globally on your host shell; it runs AIUPred inside the workflow task environment. Use the Nextflow section for pipeline-oriented runs.

To carry out a standard disorder analysis on a FASTA file:

aiupred -i test.fasta

To predict disorder, binding, and flexible linkers (-b and -l), and save the results to a file (-o):

aiupred -i test.fasta -o results.tsv -b -l

To predict redox-sensitive disorder using C->S mutant and original profiles:

aiupred -i test.fasta -r

Expected Output

# Position	Residue	RedoxPlusDisorder	RedoxMinusDisorder	Region
#sp|P04637|P53_HUMAN Cellular tumor antigen p53 OS=Homo sapiens OX=9606 GN=TP53 PE=1 SV=4
1	M	0.8014	0.8014	0
2	E	0.8527	0.8527	0
3	E	0.8157	0.8157	0
4	P	0.8313	0.8313	0
5	Q	0.7959	0.7959	0
6	S	0.7855	0.7855	0
7	D	0.8402	0.8402	0
8	P	0.8788	0.8788	0
...

Available CLI Options

options:
  -h, --help            show this help message and exit
  -i INPUT_FILE, --input_file INPUT_FILE
                        Input file in (multi) FASTA format (Required)
  -o OUTPUT_FILE, --output_file OUTPUT_FILE
                        Output file
  -v, --verbose         Increase output verbosity
  -b, --binding         Predict binding using AIUPred-binding
  -l, --linker          Predict flexible linkers
  -r, --redox           Predict redox-sensitive disorder profiles and binary regions
  -g GPU, --gpu GPU     Index of GPU to use, default=0
  --force-cpu           Force the network to only utilize the CPU. Calculation will be very slow.

---

Programmatic Usage (Python API)

AIUPred is designed to be highly memory-efficient. By initializing the AIUPred class, the heavy neural network models are loaded into your GPU (or CPU) exactly once, allowing you to process thousands of sequences rapidly.

Note: AIUPred now automatically handles memory chunking for exceptionally long sequences under the hood. You no longer need to call separate "low memory" functions!

from aiupred import AIUPred, multifasta_reader

# 1. Initialize the predictor (Models are loaded into memory here)
predictor = AIUPred()

sequence = 'THISISATESTSEQUENCE'

# 2. Predict Disorder
disorder_propensities = predictor.predict_disorder(sequence)

# 3. Predict Binding
binding_propensities = predictor.predict_binding(sequence)

# 4. Predict Flexible Linkers
# Tip: Passing the pre-calculated arrays skips redundant neural network inference!
linker_propensities = predictor.predict_linker(
    sequence, 
    disorder_pred=disorder_propensities, 
    binding_pred=binding_propensities
)

# 5. Predict Redox-Sensitive Disorder (C->S mutant vs original)
redox_plus_disorder, redox_minus_disorder = predictor.predict_redox_profiles(sequence)
redox_regions_binary = predictor.predict_redox_region_binary(
    sequence,
    redox_plus_disorder=redox_plus_disorder,
    redox_minus_disorder=redox_minus_disorder
)

# 6. Extract Feature Embeddings
# Returns a 2D numpy array of shape (L, 32)
features_2d = predictor.get_embedding(sequence, center_only=True)

# Returns a 3D numpy array of shape (L, 101, 32) containing the full context windows
features_3d = predictor.get_embedding(sequence, center_only=False)

Processing a Multi-FASTA File

from aiupred import AIUPred, multifasta_reader

predictor = AIUPred()
sequences = multifasta_reader('test.fasta')

for header, seq in sequences.items():
    print(f"Processing {header}...")
    disorder = predictor.predict_disorder(seq)
    binding = predictor.predict_binding(seq)
    linker = predictor.predict_linker(seq, disorder_pred=disorder, binding_pred=binding)

---

API Reference

class AIUPred(force_cpu=False, gpu_num=0)

The core predictor class. Initializes the neural networks and manages the computation device.

• force_cpu (bool): Force the models to run on CPU. (Default: False)
• gpu_num (int): The index of the CUDA device to use. (Default: 0)

predict_disorder(sequence: str, apply_smoothing: bool = True) -> numpy.ndarray

Predicts disorder propensities for a given amino acid sequence.

• sequence (str): The amino acid sequence.
• apply_smoothing (bool): Applies Savitzky-Golay filtering to the output if the sequence is >10 residues. (Default: True)

predict_binding(sequence: str, apply_smoothing: bool = True) -> numpy.ndarray

Predicts binding propensities for a given amino acid sequence.

• sequence (str): The amino acid sequence.
• apply_smoothing (bool): Applies Savitzky-Golay filtering to the output. (Default: True)

predict_linker(sequence: str, apply_smoothing: bool = True, disorder_pred: Optional[numpy.ndarray] = None, binding_pred: Optional[numpy.ndarray] = None) -> numpy.ndarray

Predicts flexible linker propensities by mathematically combining disorder and binding scores.

• sequence (str): The amino acid sequence.
• apply_smoothing (bool): Applies Savitzky-Golay filtering. (Default: True)
• disorder_pred (Optional[numpy.ndarray]): Pre-calculated disorder array to save computation time.
• binding_pred (Optional[numpy.ndarray]): Pre-calculated binding array to save computation time.

mutate_c_to_s(sequence: str) -> str

Returns the C->S mutated sequence used for redox-plus calculations.

• sequence (str): The amino acid sequence.

get_redox_regions(redox_plus_values: numpy.ndarray, redox_minus_values: numpy.ndarray) -> dict

Detects redox-sensitive region boundaries using differences between C->S mutant and original disorder profiles.

• redox_plus_values (numpy.ndarray): C->S mutant disorder propensities.
• redox_minus_values (numpy.ndarray): Original sequence disorder propensities.
• Returns: A dictionary of {region_start: region_end} boundaries (0-based, inclusive).

predict_redox_profiles(sequence: str) -> tuple[numpy.ndarray, numpy.ndarray]

Predicts redox plus/minus disorder profiles.

• sequence (str): The amino acid sequence.
• Returns: (redox_plus_disorder, redox_minus_disorder) where plus is C->S mutant and minus is original.

predict_redox_region_binary(sequence: str, redox_plus_disorder: Optional[numpy.ndarray] = None, redox_minus_disorder: Optional[numpy.ndarray] = None) -> numpy.ndarray

Predicts a binary redox region annotation per residue (1 in region, else 0).

• sequence (str): The amino acid sequence.
• redox_plus_disorder (Optional[numpy.ndarray]): Optional pre-calculated C->S mutant disorder profile.
• redox_minus_disorder (Optional[numpy.ndarray]): Optional pre-calculated original disorder profile.

get_embedding(sequence: str, center_only: bool = True, chunk_len: int = 1000) -> numpy.ndarray

Extracts high-dimensional feature embeddings from the sequence.

• sequence (str): The amino acid sequence.
• center_only (bool): If True, returns the center residue's 32-dimensional embedding with shape (L, 32). If False, returns the full sliding window context with shape (L, 101, 32). (Default: True)
• chunk_len (int): Sequence chunk length to prevent out-of-memory errors on large proteins. (Default: 1000)

Helper Functions

multifasta_reader(file_path: str) -> dict

Utility function to parse a FASTA file.

• Returns: A dictionary mapping >header strings to their corresponding sequence strings.

---

Benchmarks

	Type	Single sequence	Human proteome
GPU	1080 Ti 12G	3 sec	100 proteins/second
CPU	Xeon E3-1270 v5	1.7 sec	3.5 proteins/second

GPU memory usage:

VRAM (GB)	Residues
2	3000
6	8000
12	16000

---

License

This project is licensed under the MIT License. See the LICENSE file for details.

---

How to cite

AIUPred

@article{10.1093/nar/gkae385,
    author = {Erdős, Gábor and Dosztányi, Zsuzsanna},
    title = {AIUPred: combining energy estimation with deep learning for the enhanced prediction of protein disorder},
    journal = {Nucleic Acids Research},
    volume = {52},
    number = {W1},
    pages = {W176-W181},
    year = {2024},
    month = {05},
    abstract = {Intrinsically disordered proteins and protein regions (IDPs/IDRs) carry out important biological functions without relying on a single well-defined conformation. As these proteins are a challenge to study experimentally, computational methods play important roles in their characterization. One of the commonly used tools is the IUPred web server which provides prediction of disordered regions and their binding sites. IUPred is rooted in a simple biophysical model and uses a limited number of parameters largely derived on globular protein structures only. This enabled an incredibly fast and robust prediction method, however, its limitations have also become apparent in light of recent breakthrough methods using deep learning techniques. Here, we present AIUPred, a novel version of IUPred which incorporates deep learning techniques into the energy estimation framework. It achieves improved performance while keeping the robustness of the original method. Based on the evaluation of recent benchmark datasets, AIUPred scored amongst the top three single sequence based methods. With a new web server we offer fast and reliable visual analysis for users as well as options to analyze whole genomes in mere seconds with the downloadable package. AIUPred is available at https://aiupred.elte.hu.},
    issn = {0305-1048},
    doi = {10.1093/nar/gkae385},
    url = {https://doi.org/10.1093/nar/gkae385},
    eprint = {https://academic.oup.com/nar/article-pdf/52/W1/W176/58435879/gkae385.pdf},
}

AIUPred-binding

@article{ERDOS2025169071,
title = {AIUPred – Binding: Energy Embedding to Identify Disordered Binding Regions},
journal = {Journal of Molecular Biology},
volume = {437},
number = {15},
pages = {169071},
year = {2025},
note = {Computation Resources for Molecular Biology},
issn = {0022-2836},
doi = {https://doi.org/10.1016/j.jmb.2025.169071},
url = {https://www.sciencedirect.com/science/article/pii/S0022283625001378},
author = {Gábor Erdős and Norbert Deutsch and Zsuzsanna Dosztányi},
keywords = {Protein disorder, Functional disorder, Disorder binding prediction, Functional disorder prediction, Energy embedding},
abstract = {Intrinsically disordered regions (IDRs) play critical roles in various cellular processes, often mediating interactions through disordered binding regions that transition to ordered states. Experimental characterization of these functional regions is highly challenging, underscoring the need for fast and accurate computational tools. Despite their importance, predicting disordered binding regions remains a significant challenge due to limitations in existing datasets and methodologies. In this study, we introduce AIUPred-binding, a novel prediction tool leveraging a high dimensional mathematical representation of structural energies – we call energy embedding – and pathogenicity scores from AlphaMissense. By employing a transfer learning approach, AIUPred-binding demonstrates improved accuracy in identifying functional sites within IDRs. Our results highlight the tool’s ability to discern subtle features within disordered regions, addressing biases and other challenges associated with manually curated datasets. We present AIUPred-binding integrated into the AIUPred web framework as a versatile and efficient resource for understanding the functional roles of IDRs. AIUPred-binding is freely accessible at https://aiupred.elte.hu.}
}