First, create the Conda environment using the provided MultiNano.yml file. This will install all necessary dependencies.

conda env create -f demo/MultiNano.yml

Tip: After creation, activate the new environment with conda activate MultiNano (the environment name is defined within the .yml file).

This section details the steps required to convert raw Nanopore data into a feature format suitable for model training or prediction.

The first step is to convert the default multi-fast5 files from the sequencer into single-fast5 format, as required by Tombo.

multi_to_single_fast5   -i demo/input_fast5   -s demo/output_fast5_single   --recursive   -t 30

Next, perform base-calling on the single-fast5 files. This step generates base calls and writes them back into the fast5 files, which is essential for the subsequent re-squiggling step.

guppy_basecaller   -i /input/single_fast5   -s /output/basecall   --num_callers 30   --recursive   --fast5_out   --config rna_r9.4.1_70bps_hac.cfg

Tombo's resquiggle command aligns the raw electronic signal events to a reference genome or transcriptome. This step is critical for accurately mapping signals to specific genomic positions.

tombo resquiggle   /path/to/workspace   /path/to/reference.fa   --rna   --overwrite   --processes 50   --corrected-group RawGenomeCorrected_001   --basecall-group Basecall_1D_001

This series of commands aligns the base-called reads to the reference, filters them, and generates a detailed TSV file that describes matches, mismatches, and indels for each read.

# 1. Concatenate all FASTQ files into one
cat /path/to/fast5_guppy/*.fastq > test.fastq

# 2. Align reads, convert to BAM, and sort
minimap2 -t 30 -ax map-ont ref.transcript.fa test.fastq |   samtools view -hSb |   samtools sort -@ 30 -o test.bam

# 3. Index the BAM file
samtools index test.bam

# 4. Generate a detailed error profile in TSV format
samtools view -h -F 3844 test.bam |   java -jar sam2tsv.jar -r ref.transcript.fa > test.tsv

• minimap2: A fast aligner optimized for noisy long-read data. -ax map-ont is a preset for mapping Oxford Nanopore reads.
• samtools view -F 3844: This filter removes unmapped, secondary, supplementary, and low-quality alignments, ensuring only primary alignments are used.
• sam2tsv.jar: A tool that converts SAM/BAM format to a detailed TSV, which is used in the next step to guide feature extraction.

This awk command splits the master test.tsv file into smaller files, one for each read. This allows for massive parallelization in the feature extraction step.

mkdir tmp
awk 'NR==1{ h=$0 } NR>1 {
  print (!a[$2]++ ? h ORS $0 : $0) > "tmp/"$1".txt"
}' test.tsv

• How it works: The script reads test.tsv line by line. It saves the header (h=$0). For each data line, it writes the header and the current line to a new file named after the read ID (tmp/$1.txt). The !a[$2]++ logic ensures the header is only written once per file.

This is the core script that extracts signal features, k-mers, and quality information for each potential m6A site (defined by the DRACH motif).

python scripts/extract.py   -i /path/to/workspace   -o test/features/   --errors_dir test/tmp/   --corrected_group RawGenomeCorrected_001   --w_is_dir yes   -k 5   -s 65   -n 30

The final pre-processing step aggregates the features from all individual reads into a single entry for each genomic site.

# 1. Sort all feature files by genomic location (chromosome, position)
sort -k1,1 -k2,2n -k5,5 -T./ --parallel=30 -S30G test/features/* > test.features.sort.tsv &

# 2. Aggregate the sorted features
python scripts/aggre_features_to_site_level.py   --input test.features.sort.tsv   --output test.features.sort.aggre.tsv &

# 3. Filter for sites with a minimum read coverage of 20
awk 'BEGIN{ FS=OFS="	" } $4>=20 {print $0}' test.features.sort.aggre.tsv > test.features.sort.aggre.c20.tsv

• sort: Sorting is essential to group all reads covering the same site together. -k1,1 -k2,2n sorts by chromosome and then numerically by position.
• aggre_features_to_site_level.py: This script iterates through the sorted file and combines all feature lines corresponding to the same site into a single, aggregated line.
• awk '$4>=20': A common quality control step to ensure that predictions are only made on sites with sufficient evidence (in this case, at least 20 reads).

MultiNano offers several modes for prediction depending on your needs.

This is the standard mode for predicting m6A status directly from aggregated site-level feature files.

python scripts/predict_sl.py     --model /path/to/your/trained_site_model.pt     --input_file /path/to/your/site_features_for_prediction.txt     --output_file /path/to/your/site_predictions.tsv

If you need to determine the modification status of individual reads, use this mode.

python scripts/predict_rl.py     --model /path/to/your/trained_read_model.pt     --input_file /path/to/your/read_features_for_prediction.txt     --output_file /path/to/your/read_predictions.tsv

This advanced workflow first generates per-read probabilities and then uses a second model to reduce false positives. This is the recommended approach for the highest accuracy.

Step 1: Generate Primary Predictions

This script uses a read-level model to generate per-read probabilities for each site and then calculates a preliminary site-level score. The output file contains all the per-read probabilities, which are needed for the next step.

python scripts/predict_sl_with_rl.py     --model /path/to/your/trained_read_model.pt     --input_file /path/to/your/site_features_for_prediction.txt     --output_file /path/to/primary_site_predictions.csv

Step 2: Refine Predictions and Control False Positives

This script uses a trained XGBoost model to analyze the distribution of read probabilities from the previous step. It acts as a second-stage filter to differentiate true positives from likely false positives.

python FP_control/predict.py     --differentiator-model /path/to/xgboost_differentiator.json     --primary-predictions /path/to/primary_site_predictions.csv     --output /path/to/final_refined_predictions.tsv

You can also train MultiNano's models from scratch using your own labeled data.

This trains the model that predicts modification status directly from aggregated site-level features.

python scripts/train.py     --train_file /path/to/your/site_train_data.txt     --valid_file /path/to/your/site_val_data.txt     --save_dir results/site_model_checkpoints/     --model_type comb     --epochs 100     --batch_size 64

This trains the model that predicts modification status for each individual read. This model is required for the two-stage prediction workflow.

python scripts/train_rl.py     --train_file /path/to/your/read_train_data.txt     --valid_file /path/to/your/read_val_data.txt     --save_dir results/read_model_checkpoints/     --model_type comb     --epochs 100     --batch_size 256

This trains the second-stage XGBoost classifier used to reduce false positives. To train it, you need primary prediction results (from predict_sl_with_rl.py) on sites that you know are true positives and true negatives.

python FP_control/train.py     --positive-samples /path/to/primary_preds_on_true_positives.csv     --negative-samples /path/to/primary_preds_on_true_negatives.csv     --model-out /path/to/save/differentiator.json