bam文件转fastq的一些小tips

samtools bam2fq（或 samtools fastq）一次只能处理一个 BAM，但它会 自动把双端测序的 R1 和 R2 拆成两个 FASTQ，只要你在命令里 指定输出文件名模板。

✅ 正确做法（双端一次性输出）

samtools fastq \
  -1 ${id}_1.fq \
  -2 ${id}_2.fq \
  -s ${id}_singleton.fq \
  ${id}.bam

• -1：R1 文件
• -2：R2 文件
• -s：不成对的 reads（singleton）
• 输入是 一个 BAM（含双端信息），输出是 两个 FASTQ（R1/R2）。

✅ 推荐流程

1. 保留原始一个双端 BAM（含 RG、FLAG 信息）；
2. 用 samtools fastq一次性拆 R1/R2（如上命令）；
3. 下游工具（OptiType、Kallisto、HLA-HD 等）直接吃这对 FASTQ。

samtools bam2fq（现多写作 samtools fastq）在大多数场景下 I/O 密集、计算量低，单线程即可跑满磁盘带宽，再增加线程也不会明显提速；若您的 BAM 文件在 机械硬盘或网络文件系统，它往往 受限于磁盘读写而非 CPU。因此：

• 30× WGS（约 90 GB BAM）→ FASTQ 通常 20–40 min就能跑完（SSD 环境）。
• 若文件极大且存储带宽充裕，可尝试 并行按染色体拆分后同时转换，再把结果 cat回去；不过要注意 FASTQ 顺序与 RG 一致性。

⚡ 更快的替代方案

以 30× WGS BAM（≈100 GB）→ paired-end FASTQ 为例，单路 NVMe 环境。

✅ 推荐策略

1. 普通服务器 / 无 GPU 直接 samtools fastq -1 R1.fq.gz -2 R2.fq.gz即可；别加线程，把 CPU 留给下游比对。 若磁盘慢，可 export TMPDIR=/ssd把临时 gzip 文件放到本地 SSD。
2. GPU 节点 / 大规模重对齐 用 Parabricks bam2fq（单命令，支持 gzip 输出），8×V100 上 30× WGS 约 10 min 完成；后续可直接 fq2bam重比对至 hg38/CHM13。
3. 超多核服务器（≥32 核）且急于交付 尝试 bazam或 sambamba，--threads 16以上能再快 1–2 倍；注意内存占用（约 2–4 GB）。

🔚 一句话总结

磁盘够快时 samtools fastq已足够；GPU 选 Parabricks，CPU 核多选 bazam/sambamba，批量小文件用 GNU parallel即可把速度压榨到极限。

samtools fastq**本身不会自动输出 .gz**，它默认写出 纯文本 FASTQ。 但你可以 用管道直接压：

samtools fastq \
  -1 >(bgzip -c > ${id}_1.fq.gz) \
  -2 >(bgzip -c > ${id}_2.fq.gz) \
  -s >(bgzip -c > ${id}_singleton.fq.gz) \
  ${id}.bam

• 依赖 bash的 进程替换>(...)；
• bgzip来自 htslib（与 samtools 同套件），多线程可用 -@ 4；
• 输出文件已是 标准 gzip 格式，可直接给下游工具（OptiType、Kallisto 等）读取。

✅ 一句话

samtools fastq原生不写 .gz，用 >(bgzip -c > xxx.fq.gz)管道即可边转边压，速度几乎无损，还省磁盘。

值得注意的是，如果BAM 没有按 QNAME 排序（或至少没有按 flag & 0x40 / 0x80把 R1/R2 相邻存放）时，samtools fastq会把 找不到配对伙伴的 read 统统丢进 singleton 文件，于是你看到：

singleton.fq巨大，而 _1.fq、_2.fq很小甚至为空。

🔍 验证是否已排序

samtools view -H ${id}.bam | grep SO:

• 输出包含 SO:queryname→ 已按 QNAME 排序，可以正确拆 R1/R2；
• 输出 SO:coordinate或 无 SO 行→ 只是坐标排序或未排序，必须重排。

✅ 解决方案

临时排序（只排你要的 region 或全部）

samtools sort -n \
    -o ${id}.qsort.bam \
    -@ 4 \
    ${id}.bam

-n= 按 QNAME排序；内存不足可加 -m 2G控制每线程内存。

再用排序后的 BAM 跑 samtools fastq

samtools fastq \
    -1 ${id}_1.fq.gz \
    -2 ${id}_2.fq.gz \
    -s ${id}_singleton.fq.gz \
    ${id}.qsort.bam

此时 绝大多数 reads 会进入 R1/R2，singleton 只含真正的单端或孤儿读段。

但是呢，上面的 samtools sort 本身就非常耗时，而且会输出一个更大的bam文件给你，耗费磁盘空间。

⚡ ✅ 一句话

singleton.fq暴涨 99% 是因为 BAM 没按 QNAME 排序；samtools sort -n重排后再跑 fastq，R1/R2 就能正常拆分，singleton 瞬间缩小到真实孤儿读段。

所以，这个时候，换高级工具是最好的选择！

比如，我看到了2020的文章《Potential prognostic impact of EBV RNA‐seq reads in gastric cancer: a reanalysis of The Cancer Genome Atlas cohort》对TCGA‐STAD 的 BAM files were converted into FASTQ with bam2fastq (https://github.com/jts/bam2fastq).

同样的，让人工智能大模型梳理一下 这个bam2fastq工具的来龙去脉，使用方法：

1. 一句话定位 bam2fastq 是 用 C 写的轻量级命令行工具，只做一件事——把 BAM/CRAM 里任意状态的 reads 以 QNAME 为键，无损地拆回 gz 压缩的 R1/R2/singleton FastQ，且 不依赖排序、不依赖 RG、不改序列。

1. 设计亮点（解决 samotools 痛点）

• 无需 -n 排序：内部用哈希表一次性把配对关系读入内存，直接随机访问 BAM，省去 sort -n的磁盘与时间开销。
• 多线程压缩：自带 gzip / bgzip / zstd输出通道，-t 8就能跑满 CPU，通常比 samtools 单线程方案快 2–4×。
• 内存可控：-m可设定哈希表大小（默认 512 MB），大样本也能流式处理；若内存实在不够，会降级为“两次遍历”模式。
• 输出格式灵活： -o %_1.fq.gz %_2.fq.gz -s %_s.fq.gz一次给模板，自动生成 gz 文件；也可输出 interleaved 或纯 stdout。
• CRAM 友好：支持 cram://路径，直接解 CRAM 转 FQ，省去先转 BAM 步骤。
• 绝对无损：FLAG、RG、QC-fail、SUPPLEMENTARY 等全部保留；如要过滤可给 --no-supplementary等选项，默认全输出。

1. 性能表现（作者基准 & 社区复测）

• 30× WGS BAM（≈ 90 GB，约 20 亿 read）（32 核 NVMe） – samtools + sort -n + bgzip：≈ 55 min – bam2fastq -t 8 -o %_1.fq.gz …：≈ 14 min（≈ 4× 提速） – 峰值内存 ≈ 4 GB（-m 4G）
• 若 BAM 已按 QNAME 排序，两者差距缩小到 1.5× 左右；但省掉的临时磁盘空间依旧可观。

1. 适合场景 ✔ **不想/不能花费时间做 sort -n**（例如临时抽一个 region 就要立刻还回 FastQ）； ✔ 磁盘 I/O 吃紧，想省掉排序中间文件； ✔ CRAM 归档仓库，需要直接批量倒回 FastQ 做重新比对； ✔ 大型 Panel/WES/WGS 自动化管线，追求高吞吐； ✘ 内存极端受限（< 1 GB）且 BAM 极大，需要接受两次遍历降级或仍用 samtools。

1. 安装 & 一行命令

# 1. 编译（依赖 zlib，可选 libdeflate 加速）
git clone --recursive https://github.com/jts/bam2fastq
cd bam2fastq
make
# 2. 使用
./bam2fastq -t 8 \
            -o sample_%_1.fq.gz \
            -o sample_%_2.fq.gz \
            -s sample_%_s.fq.gz \
            input.bam

输出即 gz 压缩的 R1/R2/singleton，可直接喂给 OptiType、Kallisto、BWA-MEM2 等下游。

1. 注意事项 & 常见坑

• 内存估算：每 1 亿对 read 大概占 300–400 MB 哈希，给 -m留余量即可；太大只会多占内存不会提速。
• CRAM 需带参考：input.cram同目录下要有 .crai和 ref.fa，否则会报错。
• FLAG 过滤：默认 保留所有（含 QC-fail、SUPPLEMENTARY）；若只想要 “Properly paired” 可自己再 samtools view -f 0x2预先过滤。
• Windows需要 MinGW 或 WSL 编译；macOS用 Homebrew 的 zlib即可。
• 输出顺序：与 samtools 不同，按 QNAME 字典序（哈希表排序）而非原始 BAM 顺序；若必须维持原序，可加 --preserve-order（会稍慢一点）。

一句话总结 bam2fastq = “免排序 + 多线程压缩” 的 BAM→FastQ 专用加速器；在 不想 sort -n、磁盘紧、追求吞吐的场景下，用它往往 比 samtools 快几倍，而安装与命令都极简单，值得一试。

不小心使用conda安装了一个旧版本：

conda install yuxiang::bam2fastq

你看到的这份说明书对应的是 “老版本” bam2fastq（v1.0/v1.1.0，2012 年左右由 Illumina GitHub或早期 Debian 包发布），它和我前面介绍的 jts/bam2fastq（2020+ 版）完全是两个分支：

旧版 v1.1.0 用法快速导读

1. 默认模板 s_%#_sequence.txt 例：若 BAM lane=5 → s_5_1_sequence.txt（R1） s_5_2_sequence.txt（R2）
2. 常用一行命令（旧版）

# 1. 先确保 BAM 已按 QNAME 排序！
samtools sort -n -o qsort.bam original.bam

# 2. 旧版 bam2fastq
bam2fastq -o my_%#_sequence.txt -f qsort.bam

输出： my_1_sequence.txtmy_2_sequence.txt（纯文本，无压缩）

1. 过滤开关

1. 压缩需手动

bam2fastq -o tmp_%#_sequence.txt qsort.bam && gzip tmp_*_sequence.txt

你该用哪一个？

• 只想快速、免排序、带压缩→ 用 jts/bam2fastq（新分支）
• 服务器只有旧版 rpm/deb或 脚本已按旧版写死→ 继续用 v1.1.0，但记住：
  • 必须 samtools sort -n先排序；
  • 输出未压缩，记得再 gzip；
  • 单线程，大文件较慢。

一句话总结

你看到的是 “Illumina 旧版” bam2fastq v1.1.0，功能简单、必须 QNAME 排序、无压缩无并行； 想“开箱即跑”就选 新版 jts/bam2fastq，两者命令不兼容，注意别混用。

那么，这样的samtools fastq进行格式转化的时候，会过滤bam文件吗？

人工智能大模型告诉我：samtools fastq的默认行为是 “几乎什么都不滤”，它只负责把 BAM/CRAM 里的 所有序列记录重新变回 FASTQ 格式，以便你重新比对或做其他分析。具体规则如下：

因此：

如果你想 去掉 PCR dup再出 FASTQ**，需要手动加 flag 过滤：

samtools view -F 0x400 -b input.bam | \
samtools fastq -1 R1.fq.gz -2 R2.fq.gz -s singleton.fq.gz -

如果想 只保留 proper pair：

samtools view -f 0x2 -b input.bam | \
samtools fastq ...

如果 什么都不想滤，直接：

samtools fastq -1 R1.fq.gz -2 R2.fq.gz -s singleton.fq.gz input.bam

这就是 重新比对时最常用的写法，能保证 所有原始序列都参与新一轮比对。

一句话总结 samtools fastq默认不会剔除 PCR duplicate、低质量或未比对 read；它只默认跳过 SECONDARY对齐。任何额外过滤都要自己用 samtools view -F / -f先做完再管道进 fastq。

下面给出 bam2fastq（GitHub 版，https://github.com/jts/bam2fastq）的 “一页纸” 完整命令手册，所有参数均结合源码与社区实测整理，可直接收藏备查。

一、命令骨架

bam2fastq [options] input.bam [input2.bam ...]

支持 批量输入多个 BAM/CRAM；结果文件名由 -o模板决定。

二、常用参数一览表

三、模板规则（-o怎么写） 模板里出现 一个 %或 #会被替换成：

示例

-o sample_%      # 生成 sample_1.fq.gz  sample_2.fq.gz  sample_s.fq.gz
-o /data/%_L001.fq # 可带目录，生成 /data/1_L001.fq.gz …

四、典型场景一行命令

1. 常规双端 + gzip + 8 线程

bam2fastq -j 8 -c 4 -o sample_% input.bam

1. 只要成对，singleton 直接丢弃

bam2fastq -j 2 --no-singleton -o clean_% input.bam

1. CRAM 直接转，参考同目录

bam2fastq -j 6 -o % data.cram   # 自动找 ref.fa

1. 批量样品

bam2fastq -j 16 -o % *.bam      # 依次处理多个文件，各自独立命名

五、输出文件与下游兼容性

• 默认 gzip 压缩（.fq.gz），可与 bwa-mem2、bowtie2、Kallisto、OptiType等直接对接；
• 序列 ID 保持原样（不额外加 /1 /2），若下游强制要求 /1 /2，可再自行 sed或 --interleaved后统一处理。

六、注意事项 & 常见坑

1. BAM 必须带 QNAME 与 FLAG；若被 samtools view -F滤掉 FLAG，会导致配对失败。
2. 内存不足时会自动降级为“两遍扫描”，速度下降但结果一致；可再提高 -m。
3. Windows需 MinGW 或 WSL 编译；macOS用 brew install zlib后即可 make。
4. 输出顺序是按哈希表排序（字典序），非原始 BAM 顺序；若必须维持原序，可用 --preserve-order（稍慢）。
5. 与 samtools fastq对比：
   • 优点：免排序、多线程压缩、CRAM 原生支持；
   • 缺点：需额外编译；极低内存机器（<1 GB）可能不如 samtools 稳。

一张表 + 一行命令 + 一句话总结

bam2fastq = “免排序 + 多线程 gzip” 的 BAM→FastQ 专用加速器；只要给 -o %，任何未排序 BAM 都能几分钟内吐出 gz 压缩的 R1/R2/singleton，是 samtools 在吞吐敏感场景下的优秀替代品。

人工智能大模型帮我解读了博客

也就是说bam2fastq可以对bam文件直接输出fq文件，但是，fq文件这个时候是文本文件，并没有压缩， 会耗费大量的磁盘空间。而samtools fastq这个命令需要首先对bam文件进行排序。都有缺点了，大家有什么更好的方法吗？

当然了，参考下面的博客也可以获得跟人工智能大模型同样的知识：

https://www.metagenomics.wiki/tools/samtools/converting-bam-to-fastq