Clip deep learning

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> then help(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/ then RNAProt 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