gabrielmoreira Version Compatibility
Reference examples tested with: RBPNet (Jens & Gagneur 2024 github), RNAProt 0.5+, GraphProt2 (Sauer 2022 github), DeepCLIP 1.0+ (Gronning 2020), DeepRiPe (Krakau lab), pytorch 2.2+, tensorflow 2.15+, scikit-learn 1.4+, biopython 1.83+, transformers 4.40+ (for RNA foundation models).
Before using code patterns, verify installed versions match. If versions differ:
- Python:
pip show <package>thenhelp(module.function)to check signatures - Frameworks: check pytorch / tensorflow versions; reproducibility depends on framework version
If code throws ImportError, AttributeError, or TypeError, introspect the installed package and adapt the example to match the actual API rather than retrying.
CLIP-seq Deep Learning
"Predict RBP binding from RNA sequence using deep learning" -> Train or apply neural networks that learn the sequence (and optionally structure) preference of an RBP from CLIP-seq peaks or single-nucleotide crosslink sites. The output is per-base or per-site binding probability for any input sequence, enabling: (a) variant-effect prediction at heterozygous SNPs; (b) in silico binding-site discovery on transcripts not covered by CLIP; (c) systematic comparison across RBPs via shared model architectures; (d) interpretation via attribution / saliency to recover RBP-specific motifs and structural preferences. Modern models (RBPNet 2024) predict per-nucleotide crosslink count distributions rather than binary peak/non-peak, providing single-nt resolution outputs.
- Python (RBPNet sequence-to-CL signal):
import rbpnet; model = rbpnet.load_pretrained('RBP_name'); predictions = model.predict(sequence)produces per-base CL count distribution - Python (RNAProt RNN classifier):
RNAProt train -i peaks.bed -t background.bed -g genome.fa -o model/thenRNAProt predict -m model/ -i query_sequences.fa -o predictions.tsv - Python (GraphProt2 GCN with structure):
graphprot2 train -i peaks.bed -bg shuffled.bed -g genome.fa --structure -o model/ - Python (DeepCLIP for binding probability):
deepclip --train --train_data train.fa --validation_data val.fa --predict --predict_data test.fa --output_dir output/ - Python (DeepRiPe multi-modal CNN):
from deepripe import DeepRiPe; model.train(X_train, y_train); predictions = model.predict(X_test)
The benchmarks (RNAProt paper, 2021): RNAProt AUC 87-89%; DeepCLIP 84-87%; GraphProt 82-84%. RBPNet (2024) is the modern sequence-to-signal model that predicts per-nt CL distributions at single-nucleotide resolution rather than binary site classification.
Models Taxonomy
| Model | Architecture | Input | Output | Resolution | Strength | Fails when |
|---|---|---|---|---|---|---|
| RBPNet (Jens & Gagneur 2024) | Sequence-to-signal CNN | Sequence | Per-nt CL count distribution | Single-nt | Modern single-nt resolution; predicts CL distribution not binary | New (2024); fewer pretrained RBPs |
| RNAProt (Uhl 2021) | LSTM RNN | Sequence | Binary binding probability | Site/peak | Highest AUC in benchmark (87-89%); feature-rich (RNA-Foldscan structure) | Single-prediction; not per-base profile |
| GraphProt (Maticzka 2014) | Graph kernel + SVM | Sequence + structure | Binary | Site/peak | Original structure-aware; well-validated | Older; superseded by GraphProt2 |
| GraphProt2 (Sauer 2022) | Graph Convolutional Network (GCN) | Variable-length sequence + structure | Nucleotide-wise binding profile | Per-nt | Variable-length input; structure-aware | Slow to train; needs GPU |
| DeepCLIP (Gronning 2020) | CNN | Sequence | Binary | Site | Fast; good benchmarks | Sequence-only; no structure |
| DeepRiPe (Ghanbari 2020) | Multi-modal CNN | Sequence + structure + region | Binary | Site | Multi-input; good ENCODE benchmark | Sequence/structure/region must be pre-extracted |
| iDeep / iDeepE (Pan 2018) | CNN ensemble | Sequence | Binary | Site | Ensemble approach | Older; few pretrained models |
| Pysster (Budach 2018) | CNN-LSTM | Sequence | Binary | Site | Generic framework | Less RBP-specific |
| DeepBind (Alipanahi 2015) | CNN | Sequence | Binary | Site | First deep-learning RBP model | Outdated; superseded |
| BasenjiPredict (Yeo lab adapt) | Multi-task CNN | Sequence | Per-task profile | Per-nt | Joint learning across RBPs | Computational overhead |
| RNA foundation models (RNAErnie, RNA-FM 2024) | Transformer pretrained on RNA | Sequence | Embeddings (downstream task) | Embedding | Transfer learning across RBPs | Foundation model trained at depth; fine-tuning needed |
Methodology evolves; verify the latest publication on RBP deep learning (RBPNet 2024 is the current state-of-the-art per-nt resolution model). RNA foundation models (RNA-FM, RNAErnie) are emerging in 2024 as transfer-learning backbones; fine-tuning on CLIP data for specific RBPs is the next-generation approach.
Critical Choice: Binary Classification vs Sequence-to-Signal
Binary classification (RNAProt, DeepCLIP, DeepRiPe, GraphProt2): Train on labeled site vs background; predict probability of binding for an input sequence. Output: per-sequence score. Pro: simple framework; mature benchmarks. Con: discards single-nt CL distribution information; binary decision boundary.
Sequence-to-signal (RBPNet): Train on per-nt CL count distributions from PureCLIP or CTK CITS output; predict per-base CL count for input sequence. Output: per-nt profile. Pro: single-nt resolution; preserves CL count information; matches biology (CL is a sharp signal, not a region). Con: newer (2024); fewer pretrained models; harder to interpret with classical motif tools.
| Goal | Model |
|---|---|
| Predict RBP binding probability for an input sequence | RNAProt or DeepRiPe |
| Predict per-base CL distribution | RBPNet |
| Variant-effect at heterozygous SNP | RBPNet or DeepRiPe (per-base output) |
| Compare RBP preferences across ENCODE | Multi-task model (BasenjiPredict-style) |
| Transfer learning across RBPs | RNA foundation model + fine-tune |
| In silico screening of variants | RBPNet (per-base) for genome-wide |
| Motif interpretation via attribution | DeepRiPe or GraphProt2 (interpretable) |
| Custom training on new CLIP data | RNAProt (easiest pipeline) |
| Production-grade per-base prediction | RBPNet 2024 |
Variant-Effect Prediction Workflow
Apply a pretrained or custom-trained model to predict the change in binding upon a sequence variant.
import torch
from rbpnet import RBPNet # hypothetical API; verify per-package documentation
# Load pretrained model for specific RBP
model = RBPNet.load_pretrained('TARDBP_HEK293T')
# Reference and alternative sequences around a variant
ref_seq = 'CTGTACTGCAGTAGCATGCTAGCATGCTAGCAT' # 32 nt window centered on variant
alt_seq = 'CTGTACTGCAGTAGCATGCTAGCATGCTAGCAA' # Variant: T -> A at position 32
# Predict per-base CL distribution for both
ref_pred = model.predict(ref_seq) # shape: (32, 1) - per-base CL probability
alt_pred = model.predict(alt_seq)
# Variant effect: log2 fold change in summed binding signal
import numpy as np
effect = np.log2((alt_pred.sum() + 1e-9) / (ref_pred.sum() + 1e-9))
print(f'Variant effect (log2 FC): {effect:.4f}')
# Strong-effect variant: |log2 FC| > 1.0
# Mid-effect: 0.5 - 1.0
# Weak: < 0.5
For genome-wide variant scoring: apply this in batch to all GWAS variants overlapping the RBP's binding regions. The output is a per-variant log2 FC; downstream Mendelian randomization or fine-mapping integrates with phenotype-association statistics.
Training a Custom Model (RNAProt Example)
RNAProt is the most accessible training framework. It accepts peak BED + background BED + genome FASTA.
Goal: Train a chromosome-split RNN classifier from CLIP peaks to predict RBP binding probability on arbitrary input sequences, with held-out evaluation on a chromosome-distinct test set.
Approach: Generate a GC-matched 3' UTR background, split peaks and background by chromosome (train chr1-20, test chr21-22) to prevent gene-neighbor leakage, train RNAProt for 50 epochs at batch size 64, and evaluate held-out AUC against the ENCODE benchmark target of 0.85-0.89.
# Step 1: Prepare data
# Foreground: positive peaks from CLIPper / Skipper stringent set
# Background: GC-matched random regions from expressed transcripts
bedtools getfasta -fi genome.fa -bed peaks.stringent.bed -s -fo peaks.fa
bedtools shuffle -i peaks.stringent.bed -g chrom.sizes -incl expressed.bed -seed 42 > bg.bed
bedtools getfasta -fi genome.fa -bed bg.bed -s -fo background.fa
# Step 2: Train RNAProt
RNAProt train \
--in peaks.fa \
--neg background.fa \
--out model_dir \
--epochs 50 \
--batch-size 64 \
--learning-rate 0.001 \
--validation-split 0.2
# Step 3: Apply to query sequences
RNAProt predict \
--model model_dir \
--in query.fa \
--out predictions.tsv
# Output: per-sequence binding probability
RBPNet Sequence-to-Signal Workflow
# Hypothetical RBPNet API - verify against current package
import rbpnet
# Training: needs per-nt crosslink count for each example
# Inputs: sequence windows (256 nt) around peaks
# Targets: per-base CL count vector from PureCLIP or CTK CITS
# Prepare data
X_train, y_train = rbpnet.load_clip_data(
peaks_bed='peaks.bed',
crosslinks_bed='pureclip_sites.bed',
genome_fa='genome.fa',
window_size=256
)
# Train
model = rbpnet.RBPNet(
seq_length=256,
out_length=256,
conv_layers=4,
filters=128
)
model.train(X_train, y_train, epochs=50, batch_size=32, val_split=0.2)
# Predict per-base CL distribution
predictions = model.predict(novel_sequences)
Per-Tool Failure Modes
Training data imbalance
Trigger: Peak set 10k positive vs 100k negative background.
Mechanism: Class imbalance biases model toward negative class; specificity high but sensitivity low.
Symptom: AUC reported at 0.95 but precision-recall at peak threshold poor; few sites recovered.
Fix: Balanced sampling (1:1 positive:negative) or class weights. RNAProt does this automatically; DeepCLIP / DeepRiPe require manual balancing.
Background mismatch
Trigger: Random shuffled background not matched to peak transcript context (e.g., peaks from 3' UTRs, background from CDS).
Mechanism: Model learns transcript-region differences (AU-content of 3' UTR vs CDS), not RBP specificity.
Symptom: Top predicted sites all in 3' UTRs regardless of test sequence; motif analysis shows AU-rich without RBP motif.
Fix: Match background to same region as foreground (3' UTR peaks -> 3' UTR background). Use the GC-content matched shuffle.
Test on training data leak
Trigger: Splitting train/test by random shuffle.
Mechanism: Adjacent peaks in genome share evolutionary context; random split leaks training peaks near test peaks.
Symptom: Held-out AUC > 0.95 in benchmark but fails on truly novel sequences.
Fix: Split by chromosome (e.g., train chr1-20, test chr21-22). Or split by gene (no two peaks in same gene across splits).
GPU requirement underestimated
Trigger: RNAProt / RBPNet training on CPU only.
Mechanism: Modern RBP DL models have 1-10M parameters; training requires GPU (or 100x slower on CPU).
Symptom: Training time > 24 h on CPU; convergence unstable.
Fix: Use Google Colab GPU; AWS EC2 GPU instance; or restricted-architecture model for CPU.
Variant-effect prediction window size
Trigger: Variant-effect prediction with too narrow window around the variant.
Mechanism: RBP context extends 50-200 nt; window < 100 nt misses long-range context.
Symptom: Variant effect estimates noisy; same model gives different effects on different windows.
Fix: Use the model's native window size (256 nt for RBPNet); for shorter windows, average across multiple shifted predictions.
Pretrained models lack the target RBP
Trigger: Looking for pretrained DeepRiPe / RBPNet for an uncommon RBP.
Mechanism: Only ~150 ENCODE-tested RBPs have pretrained models; thousands of RBPs are not.
Symptom: No pretrained available for the protein of interest.
Fix: Train custom model on new CLIP data using RNAProt or DeepCLIP. Or use transfer learning from a related RBP (closest paralog).
Structure prediction integration
Trigger: GraphProt2 with --structure flag without RNA-Fold structure ensemble.
Mechanism: GraphProt2 needs structure ensemble (RNAfold output) as input; without it the GCN cannot leverage structure.
Symptom: GraphProt2 performance no better than sequence-only models.
Fix: Pre-compute RNAfold ensemble for each training sequence; pass to GraphProt2 input. Or use sequence-only DeepCLIP if structure is not needed.
Model interpretation via saliency
Trigger: Want to recover RBP motif from trained model.
Mechanism: Saliency / integrated gradients on trained model produces per-base importance scores; sum across many positive examples gives a motif.
Symptom: Saliency results noisy; no clean motif emerges.
Fix: Use TF-MoDISco (Schreiber 2020) for cleaner motif extraction from saliency maps. Or use DeepLIFT scores instead of vanilla saliency.
Decision Tree by Use Case
| Scenario | Model | Why |
|---|---|---|
| Variant-effect prediction (genome-wide GWAS variants) | RBPNet (per-base) | Single-nt resolution; predicts CL distribution |
| Binary "is this sequence bound" | RNAProt | Best AUC in benchmark (87-89%) |
| Structure-aware prediction | GraphProt2 | Structure ensemble integration |
| Custom training on new CLIP data | RNAProt (easiest CLI) | Fast training; CLI tool |
| Single RBP, no pretrained | Train custom RNAProt | Most accessible framework |
| Multi-task across RBPs | BasenjiPredict-style | Joint learning |
| Transfer learning from foundation model | RNA-FM + fine-tune | New approach; not yet in production |
| Production scoring of many sequences | DeepCLIP (fast inference) | Throughput |
| Motif interpretation | DeepRiPe + TF-MoDISco | Interpretable architectures |
| Comparing in silico to RBNS | RBPNet or DeepRiPe + RBNS Kd correlation | Calibration |
| Variant effect at heterozygous SNP | RBPNet | Per-base output |
Reconciliation: Model Predictions vs CLIP / RBNS
| Pattern | Likely cause | Action |
|---|---|---|
| Model predicts site; CLIP misses | Model false positive; or transient binding not captured by CLIP | Check RBNS prediction; in vitro Kd |
| Model predicts low; CLIP has strong peak | Model false negative; or non-canonical / context-dependent | Investigate training data; structure-dependent? |
| Model AUC 0.95 in test; fails on novel sequences | Train/test leakage; chromosome split needed | Re-train with proper split |
| Variant effect log2 FC inconsistent across windows | Window-size sensitivity | Use model native window; average across shifts |
| Pretrained for related RBP works on target | Cross-RBP transfer | Transfer learning may work for paralogs |
| GraphProt2 underperforms sequence-only | Structure ensemble not provided | Fix structure input |
| Saliency motif noisy | Vanilla gradient method | Use DeepLIFT or TF-MoDISco |
| Train/test split by random outperforms chromosome split | Leakage from gene-neighbor sequences | Trust chromosome-split AUC |
Operational rule for high-confidence variant-effect: (a) Use RBPNet per-base output; (b) compute log2 FC at variant position summed over 50 nt window; (c) cross-validate with another model (DeepRiPe); (d) cross-reference with overlapping eCLIP peak if available; (e) report |log2 FC| > 1 as strong effect.
Common Errors
| Error / symptom | Cause | Solution |
|---|---|---|
| AUC 0.5 on test | Train data leak or random shuffle | Verify chromosome split |
| Model trained on 1 epoch | Default optimizer state | Train 30-50 epochs with validation |
| GPU OOM | Batch size too large | Reduce batch size to 32 |
| Variant effect log2 FC very large (> 10) | Reference sequence not in training distribution | Verify input sequence reasonable |
| Pretrained model not found | RBP not in pretrained list | Train custom; or use closest paralog |
| Structure flag without input | GraphProt2 misuse | Pre-compute RNAfold structure |
| Saliency map flat | Model architecture too shallow | Use DeepRiPe / RBPNet (deeper) |
| Per-class accuracy uneven | Class imbalance | Use balanced sampling or class weights |
| Cross-RBP transfer fails | RBPs unrelated | Limit transfer to paralogs or use foundation model |
| Custom training crashes | RAM / GPU exhausted | Smaller batch; cache embeddings |
References
- Alipanahi B et al 2015 Nat Biotechnol 33:831 (DeepBind, first DL RBP model)
- Maticzka D et al 2014 Genome Biol 15:R17 (GraphProt with structure)
- Sauer M et al 2022 (GraphProt2 with GCN)
- Gronning AGB et al 2020 Nucleic Acids Res 48:7099 (DeepCLIP)
- Ghanbari M et al 2020 Bioinformatics 36:3489 (DeepRiPe multi-modal)
- Pan X et al 2018 Bioinformatics 34:i285 (iDeepE)
- Budach S et al 2018 Bioinformatics 34:3387 (Pysster)
- Uhl M et al 2021 GigaScience 10:giab054 (RNAProt RNN)
- Horlacher M, Wagner N, Moyon L et al 2023 Genome Biol 24:180 (RBPNet sequence-to-signal at single-nt)
- Shrikumar A et al 2018 arXiv (TF-MoDISco interpretation)
- Chen J et al 2024 (RNA-FM foundation model)
- Wang W et al 2024 (RNAErnie pretrained transformer)
Related Skills
- clip-seq/clip-motif-analysis - Motif analysis is the classical alternative
- clip-seq/crosslink-site-detection - Single-nt CL sites for sequence-to-signal models
- clip-seq/clip-peak-calling - Peak BEDs for binary classification training
- causal-genomics/mendelian-randomization - Variant-effect predictions feed MR
- causal-genomics/fine-mapping - Variant prioritization with model scores
- machine-learning/model-validation - Train/test split methodology
- machine-learning/prediction-explanation - Saliency / attribution methods
- machine-learning/biomarker-discovery - Generic ML framework