User guide

Manual

A compact guide to using Deep-Interact Studio, from preparing a CSV to comparing trained models.

Choose a task
Load data
Map columns
Configure the model
Train
Check results
Run inference

What this webtool does

Deep-Interact Studio builds sequence-based interaction classifiers for biological pair prediction. It turns molecules and sequences into embeddings, trains a classifier, reports validation metrics, and lets you reuse completed models for inference. The app supports three tasks:

hub

PPI

Protein-Protein Interaction

Predict whether two protein sequences interact.

medication

DTPI

Drug-Target Protein Interaction

Predict whether a compound binds a protein target.

genetics

RPI

RNA-Protein Interaction

Predict whether an RNA sequence binds a protein.

1 Prepare data

Use a CSV with two input columns and one binary label column. The label is 1 for interaction and 0 for no interaction. Column names do not need to match exactly because each model-building page lets you map your columns after upload.

Task	Use for	Expected data
PPI	Predict whether two protein sequences interact.	`ProteinA`, `ProteinB`, `lable`
DTPI	Predict whether a compound binds a protein target.	`SMILES`, `Protein`, `lable`
RPI	Predict whether an RNA sequence binds a protein.	`RNA`, `Protein`, `lable`

Practical checks before training

Keep labels as 0 and 1.
Remove duplicate pairs where possible.
Use balanced positives and negatives for the first experiment.
Protein inputs are validated against the current page limit of 512 residues.
Start with a small sample if the CSV is large.

dataset Open Benchmark Datasets

2 Train a model

Open the page for your task and follow the same basic sequence.

hub Open PPI medication Open DTPI genetics Open RPI

Upload a CSV or load the example data.
Map the sequence, molecule, and label columns.
Choose how many pairs to use and the train/test split.
Select the embedding model where the page offers options.
Build a classifier from the available layers.
Set training parameters such as epochs, batch size, and learning rate.
Submit the job and save the Run ID and access token.

Recommended starting settings

Setting	Good first choice
Dataset sample	100-500 pairs for a first test
Train/test split	80/20
Class balance	50% positive, 50% negative
Protein embedding	ESM2 35M when available
Classifier	Two Linear layers with dropout
Epochs	30-50 with early stopping
Learning rate	0.001

3 Track results

After submission, use the Run ID to follow the job and inspect model quality.

Job Status lists submitted training and inference jobs.
Check Model Results shows training curves, metrics, dataset summary, downloads, and failures.
Main metrics to compare are AUROC, Average Precision, MCC, F1, and the confusion matrix.

list_alt Open Job Status monitor_heart Open Check Model Results

How to read the main metrics

Metric	What it tells you
AUROC	How well positives rank above negatives across thresholds
Average Precision	Better than AUROC when positives are rare
MCC	Balanced single-score metric for imbalanced data
F1	Balance between precision and recall at one threshold
Accuracy	Easy to understand, but misleading when classes are imbalanced

4 Run inference

Use a completed training Run ID to predict new pairs. You can enter a single pair manually or upload a batch CSV. If labels are included in a batch file, the app also reports inference metrics.

play_arrow Open Run Inference analytics Open Inference Results

5 Compare runs

Use comparison pages when you train multiple models or run multiple inference batches.

Compare Models compares completed training runs from the same task type.
Compare Inferences compares completed inference runs from the same task type.

compare Open Compare Models difference Open Compare Inferences

FAQ & Troubleshooting

What are the job submission limits?

Training jobs are accepted only when they stay within these limits:

Limit	Current value
Upload size per file	100 MB
Total upload request size	100 MB
Selected training pairs	Up to 100,000 pairs
Model size	Up to 5,000,000 trainable parameters
Protein sequence length on builder pages	512 residues
Training wall-clock time	4 hours, then the job is stopped
Training submissions	10 training jobs per IP per 3 hours
Total active training queue	20 queued or running training jobs platform-wide

If your job is rejected, reduce the selected positive/negative pair counts, simplify the architecture, trim long protein sequences, or wait for queued/running jobs to finish.

What does the training queue limit mean?

The queue limit is platform-wide. It counts all training jobs with status queued or running, not only your own jobs. When the active training queue reaches 20 jobs, new training submissions are temporarily blocked until at least one job completes, fails, or is cleaned up.

This protects a free shared research deployment from building a very long backlog. Your per-IP quota still applies separately: one IP can submit up to 10 training jobs in a rolling 3-hour window, provided the platform queue is not already full.

What are the inference limits?

Inference jobs have separate limits from training:

Limit	Current value
Single-pair input fields	512 characters each
Batch inference CSV	Up to 60,000 pairs
Inference submissions	20 inference requests per minute
Batch inference quota	15 batch jobs per IP per 5 hours
Single-pair inference quota	30 single-pair jobs per IP per 5 hours

For large inference files, keep only the required columns and remove duplicate rows before upload.

How many pairs should I use?

For a first run, use 100-500 balanced pairs to check that the workflow, column mapping, and model settings are correct. For stronger models, increase the pair count while watching runtime and class balance.

Very small datasets can overfit. Very large datasets can time out or exceed memory limits, especially with larger embedding models or large classifier architectures.

What should I save after submitting a job?

Save the Run ID and the access token immediately. The access token is needed to view results, download models, run inference with the model, and compare runs; it is shown once and cannot be recovered. Save the cancel token too if you may need to stop the job.

This browser remembers tokens for runs you submitted here, so you only need to paste a token when opening a run from a different browser, device, or web address.

A job failed

Check Job Status or Check Model Results for the error. Common causes are invalid sequences, invalid SMILES strings, too many selected pairs, GPU memory limits, or timeout. Reduce the sample size and retry with a smaller embedding model if the job is too heavy.

Which metrics should I report?

Report AUROC, Average Precision, MCC, and the confusion matrix. Accuracy can be included, but it should not be the primary metric when classes are imbalanced.

For candidate screening, also inspect precision and recall at the threshold you plan to use. Lower thresholds find more possible interactors; higher thresholds return fewer but more confident candidates.

Results look too good

Check for duplicate pairs and shared entities between train and test data. High overlap can make validation metrics look better than real-world performance. For publication-style evaluation, prefer disjoint splits where possible.

Accuracy is high but AUROC or MCC is poor

This usually means the dataset is imbalanced. Use AUROC, Average Precision, MCC, and the confusion matrix instead of relying only on accuracy.

How many runs can I compare?

The comparison pages accept up to 5 runs at a time. Compare only runs from the same task type so the metrics and prediction outputs are meaningful.