作物遗传改良全国重点实验室生物信息计算平台¶
平台介绍¶
生物信息高性能计算平台为华中农业大学作物遗传改良全国重点实验室公共技术平台，专注为实验室及全校用户提供高通量测序数据的存储和计算服务。
平台由155个刀片计算节点、2个GPU节点、6个八路大内存胖节点、多套并行存储组成，总体计算能力理论峰值为380万亿次，CPU核心数为5600核，存储硬件12.7PB(可用容量8.8PB)，主存储读写带宽超过45GB/s。平台预装了1000余款各类生物信息分析软件及相关使用文档、各类常用生物信息数据库，用户可使用本平台进行转录调控测序、单细胞测序、三维基因组测序、表观组测序、基因组组装注释等各类常见组学数据分析。可加速大规模重测序数据分析、复杂大基因组组装注释等需消耗大量资源的分析项目。
Info
此文档右上角搜索框，支持完整的英文搜索，中文搜索分词有限制：搜索连续的两个字相比多个字效果更好，多个字之间建议以空格两两隔开进行搜索，如变异 检测。
集群使用指南¶
1、在满足本实验室正常使用的情况下，面向全校师生开放使用，每学年4次集中考核、申请，见 账号申请 考核范围；收费标准见 集群收费标准
2、修改密码见 修改密码。密码遗忘先使用默认密码登录，如若不行则向管理员申请修改密码。
3、禁止在登录节点运行作业，登录节点运行的程序使用CPU或内存超标会被监控程序杀掉。所有作业应由LSF作业调度系统调度至计算节点运行，LSF使用文档见 作业调度系统LSF使用。
4、集群有多种不同硬件配置，根据硬件配置差异和不同功能需求，集群计算节点划分为多个队列，每个队列的具体使用规则见 作业队列划分。
- 默认用户队列为 normal；
- 程序调试使用 interactive 队列（交互模式）；
- gpu 程序使用 gpu 队列；
- 超大内存作业使用 smp 队列；
- 多节点并行作业使用 parrallel 队列等。
5、lsf 作业资源申请规则及注意事项：
- lsf作业申请资源时需遵守资源申请的基本规则，即申请的CPU核心数和程序使用的线程数相等，避免集群资源的浪费或者节点负载过高，如果违反规则导致资源大规模浪费，账号将会被暂停提交作业一段时间或降低可使用的核心数；
- 作业使用内存较多时，需在lsf作业脚本中申请使用的内存大小， 如
-R "rusage[mem=20GB]"; - 提交到 normal、high 队列的作业每核可使用内存分别不超过5G、10G，否则作业被将被系统杀掉(
TERM_ MEMLIMIT: job killed after reaching LSF memory usage limit.)，具体说明见 作业队列划分。同时建议定制bjobs命令输出内容，方便查看作业内存使用，具体见 LSF 作业查询； - 申请多个核心并不能加速单线程作业的运行，即perl、R、python等脚本作业使用一个核心即可；
- 建议使用LSF的环境变量
$LSB_DJOB_NUMPROC来设置程序使用的线程数，方便动态调整； - 有画图等图形界面任务需求，使用
bsub -q interactive -XF -Is bash命令交互进入计算节点进行（xshell需要设置好图形转发），R 画图也可使用 Rstudio，见 集群 Rstudio 使用； - 更多的使用细节见 作业调度系统LSF使用。
6、每个用户可使用的计算和存储资源有一定限制，见 用户资源限制。数据较多、作业任务较多的用户建议时常使用diskquota命令查看自己的存储使用量，以免因为存储空间达到配额限制导致程序挂掉。存储超配额后，无法写入数据，同时也无法登录集群，均会出现 Disk quota exceeded 的报错。
7、集群存储只存储用户目前使用的数据，结果数据应该及时下载到本地，计算中间数据及时删除。测序原始数据一定要在本地备一份。长时间不使用的数据及时压缩后备份到本地，避免额外的存储使用费用。
8、集群装有若干公共应用软件、基础库以及NR、NT等生信数据库，用户可使用module、singularity来查看和调用，见 集群软件使用介绍。有些生信软件在集群使用使用会有一些注意事项，可在本系统上查看相关文档。
9、如果群体数据较多，测试 GATK HaplotypeCaller 运行较慢，可以使用 deepvariant。或使用GPU进行加速的call变异工具 parabricks，人重 30x WGS测试数据，fq->vcf全流程3h，call变异bam->vcf大约20min。
10、大批量的群体数据处理时，不要直接保留sam文件，见 短序列比对输出bam, 数据使用规范 。群体数据处理过程中会使用大量的存储空间，建议群体数据处理过程中时常使用diskquota命令查看自己的存储使用量，以免存储使用达到配额限制导致程序挂掉或空跑，见 存储限制。
11、简单分析流程可以使用LSF处理，见 LSF提交批量流程作业。复杂分析流程，建议使用生信专用流程工具 snakemake或 nextflow，前者依赖python3，上手相对简单，容易理解，复杂脚本编写符合python语法；后者依赖java环境，理解和上手较复杂，复杂场景编写脚本需要使用java语法。
集群相关 ↵
1. 常用命令无法使用¶
用户编辑~/.bashrc 时，PATH 环境变量相关的部分编写错误，会导致出现下面这种常用命令无法使用的情况。
$ cat test.txt
bash: cat: command not found...
~/.bashrc，将写错的部分改正，重新开个登录窗口即可。
$ /bin/vim ~/.bashrc
2. module av显示的软件很少¶
使用系统module之前，需要先设置相关环境变量，否则会出现module av 显示的软件很少，或module load 无法载入某个软件的情况。module环境配置见 Module使用
3. 节点/tmp空间不够¶
部分节点可能会因为作业在/tmp目录下写入的文件过多，导致系统盘耗尽，进而导致作业无法往/tmp目录内写入临时文件，出现类似如下的报错。
cannot create temp file for here-document: No space left on device
使用lsload命令查看该节点的资源信息，可看到tmp剩余空间为0，请联系管理员，清理/tmp目录。
$ lsload c01n01
HOST_NAME status r15s r1m r15m ut pg ls it tmp swp mem
c01n01 ok 8.0 7.8 7.9 22% 0.0 0 4226 0 3.7G 241G
作业本身不往/tmp目录下写入很多数据，是其它作业把/tmp目录写满了。可以使用lsf相关选项，重新投递出错的作业到其它/tmp目录有空闲的节点。
-R "select[tmp>10G]"
作业本身需要往/tmp内写入大量的数据，建议使用TMP 环境变量重新设置临时目录到本地。有多个类似作业时，建议每个作业一个目录，避免文件重名程序出错。bs_seeker repex_tarean paragraph等都会往/tmp目录下写入大量的数据，使用时注意设置TMP环境变量。
#BSUB -J program
#BSUB -n 10
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
tmpn=`mktemp -u programname_XXXXX`
tmpd="${HOME}/tmp/${tmpn}"
mkdir -p ${tmpd}
echo ${tmpd}
export TMP=${tmpd}
# 运行程序
program...
# 清理临时文件
rm -r ${tmpd}
4. 存储超过配额¶
写入数据或程序运行时出现 Disk quota exceeded的报错，说明存储空间或文件数超过配额。diskquota 查看存储使用情况，清理账号下的数据至配额之下方可正常写入数据。建议对所有数据扫描一遍，压缩删除不必要的数据，参考 文件扫描。如果需要增加存储配额，可按这个步骤处理申请增加配额。
$ diskquota
Filesystem type blocks quota limit in_doubt grace | files quota limit in_doubt grace Remarks
public USR 43.74T 20T 20T 0 7 days | 9890452 17500000 17500000 0 none
$ cp data/NT/taxdb.btd.gz .
cp: error writing ‘./taxdb.btd.gz’: Disk quota exceeded
cp: failed to extend ‘./taxdb.btd.gz’: Disk quota exceeded
5. github 下载缓慢¶
校园网下载github上的软件不稳定，经常会出现下载缓慢或无法链接的情况，可以使用github镜像，参考 github
6. 登录节点使用conda安装软件等待时间过长¶
conda安装软件过程中，会运行python程序，如果此时间过长，会被监控程序判定为在登录节点跑作业进而将相关python程序杀掉，导致conda安装过程一直处于等待状态，建议进入交互节点后再使用conda安装程序。R包安装过程也有类似问题，建议在交互节点安装R包。
此外conda安装软件时，刚开始的resolving时间可能会很长，建议使用mamba替代conda，见 mamba使用。
7. 新版conda命令行提示符异常¶
conda升级到22.9.0之后，激活conda环境出现如下的命令行提示符显示异常
(base)
(base)
conda init bash
(base) [username@login01 ~]$
8. 'GLIBC_x.xx' not found¶
软件运行时出现类似version 'GLIBC_2.29' not found 的报错，一般是系统上glibc版本比较低导致的，解决方法见集群文档 glibc。
9. 'GLIBCXX_x.x.x' not found¶
部分应用程序使用高版本GCC编译，直接在集群上运行时，由于集群默认GCC版本较低(gcc 4.8.5)，会出现类似如下的'GLIBCXX_x.x.x' not found报错。
$ ./program
program: /lib64/libstdc++.so.6: version 'GLIBCXX_3.4.20' not found(required by program)
module load GCC/5.4.0-2.26。
常用GCC版本与GLIBCXX的对应版本如下所示，完整列表见：ABI Policy and Guidelines
GCC 4.8.0: GLIBCXX_3.4.18, CXXABI_1.3.7
GCC 4.8.3: GLIBCXX_3.4.19, CXXABI_1.3.7
GCC 4.9.0: GLIBCXX_3.4.20, CXXABI_1.3.8
GCC 5.1.0: GLIBCXX_3.4.21, CXXABI_1.3.9
GCC 6.1.0: GLIBCXX_3.4.22, CXXABI_1.3.10
GCC 7.1.0: GLIBCXX_3.4.23, CXXABI_1.3.11
GCC 7.2.0: GLIBCXX_3.4.24, CXXABI_1.3.11
GCC 8.1.0: GLIBCXX_3.4.25, CXXABI_1.3.11
GCC 9.1.0: GLIBCXX_3.4.26, CXXABI_1.3.12
GCC 9.2.0: GLIBCXX_3.4.27, CXXABI_1.3.12
GCC 9.3.0: GLIBCXX_3.4.28, CXXABI_1.3.12
GCC 10.1.0: GLIBCXX_3.4.28, CXXABI_1.3.12
GCC 11.1.0: GLIBCXX_3.4.29, CXXABI_1.3.13
GCC 12.1.0: GLIBCXX_3.4.30, CXXABI_1.3.13
GCC 13.1.0: GLIBCXX_3.4.31, CXXABI_1.3.14
10. 常用库缺失解决¶
在安装或运行软件过程中经常出现类似 xxxx.so.1.0: cannot open shared object file: No such file or directory的库缺失报错，一般加载或安装对应的库文件即可。
| 缺失库 | 需要加载的库 |
|---|---|
| libbz2.so.1.0 | module load bzip2/1.0.6 |
| libgsl.so.23 | module load GSL/2.4 |
| liblzma.so.0 | module load XZ/5.2.4 |
| libgeos_c.so.1 | module load GEOS/3.7.1 |
| libicuuc.so.42 | module load icu/42 |
| libzstd.so.1 | module load zstd/1.5.0 |
| libjemalloc.so.2 | module load jemalloc/5.2.1 |
| libpng16.so.16 | module load libpng/1.6.24 |
| ltld.so | module load libtool/2.4.6 |
| libpcre2-8.so.0 | module load PCRE/10.00 |
| libglpk.so.40 | module load glpk/5.0 |
11. core dumped¶
造成"core dumped"错误的原因可能有多种，包括：
-
程序Bug：程序中存在错误、内存泄漏或未处理的异常，导致程序崩溃。在这种情况下，需要检查程序代码并修复错误，或向开发人员求助；
-
输入数据有问题。检查输入数据是否符合要求，或更换其他数据尝试；(如bsmap，参考基因组序列需要多行的格式，单行就出现core dump报错)
-
节点内存不够：程序使用的内存超过了系统可用的内存导致出错。可以更换内存更大的节点尝试；
12. too many open files¶
too many open files 报错的原因一般是某个进程打开了超过系统限制的文件数量，默认值为1024，非root用户可以使用命令设置到4096。
在本集群运行此作业如出现此报错，可在lsf脚本中添加 ulimit -n 4096 命令就可以临时将本账号的限制最大提升至4096，大于此值会出现权限不够的报错；如果还出现此报错，建议使用smp队列，smp队列中此值为32768；如果32768也不够，请联系管理员处理。
13. 计算节点未联网导致部分软件无法运行¶
-
部分WDL流程会在运行过程中下载singularity镜像，计算节点未联网会导致流程运行失败。解决办法为，在登录节点下载好镜像，然后替换WDL脚本中的镜像URL。如 atac-seq-pipeline 的WDL脚本中有2个地方用到了
https://encode-pipeline-singularity-image.s3.us-west-2.amazonaws.com/atac-seq-pipeline_v2.2.2.sif，首先下载这个镜像，然后将这个URL替换成DIR/atac-seq-pipeline_v2.2.2.sif即可 - nf-core 流程离线运行，见 nf-core
- nextflow 脚本离线运行需配置
export NXF_OFFLINE='true'
集群硬件资源¶
计算资源¶
本集群在2018年新购置的联想集群基础上，将2014年购置的曙光集群并入其中，共计2个管理节点，4个登陆节点，155个刀片计算节点，2个GPU节点，6个八路胖节点，各节点详细硬件配置如下：
| 节点类型 | 公司 | 投入使用年份 | 节点名称 | 节点数量 | CPU型号 | 核心数 | 内存 |
|---|---|---|---|---|---|---|---|
| 管理节点 | 联想 | 2019.2 | mn01 | 1 | Intel(R) Xeon(R) Gold 5115 CPU @ 2.40GHz | 20 | 96GB |
| 备用管理节点（登录节点） | 联想 | 2019.2 | mn02 | 1 | Intel(R) Xeon(R) Gold 5115 CPU @ 2.40GHz | 20 | 96GB |
| 登录节点 | 曙光 | 2014.12 | login01-04 | 4 | Intel(R) Xeon(R) CPU E5-2630 v2 @ 2.60GHz | 12 | 64GB |
| 刀片计算节点1 | 联想 | 2019.2 | c01n01-c04n03 | 45 | Intel(R) Xeon(R) Gold 6150 CPU @ 2.70GHz | 36 | 384GB |
| 刀片计算节点2 | 联想 | 2019.2 | c04n04-c07n11 | 50 | Intel(R) Xeon(R) Gold 6150 CPU @ 2.70GHz | 36 | 192GB |
| 刀片计算节点3 | 曙光 | 2014.12 | sg01-30 | 30 | Intel(R) Xeon(R) CPU E5-2680 v2 @ 2.80GHz | 20 | 128GB |
| 刀片计算节点4 | 曙光 | 2014.12 | sg31-60 | 30 | Intel(R) Xeon(R) CPU E5-2680 v2 @ 2.80GHz | 20 | 256GB |
| GPU节点1 | 联想 | 2019.2 | gpu01 | 1 | Intel(R) Xeon(R) CPU E5-2680 v2 @ 2.80GHz | 36（两块GPU加速卡，P100） | 512GB |
| GPU节点2 | 曙光 | 2014.12 | gpu02 | 1 | Intel(R) Xeon(R) Gold 6140 CPU @ 2.30GHz | 20（两个GPU加速卡，Tesla K40m） | 256GB |
| 胖节点1 | 联想 | 2019.2 | s001-s004 | 4 | Intel(R) Xeon(R) Platinum 8160 CPU @ 2.10GHz | 192 | 2TB |
| 胖节点2 | 曙光 | 2014.12 | s005 | 1 | Intel(R) Xeon(R) CPU E7-8850 v2 @ 2.30GHz | 96 | 4TB |
| 胖节点3 | 曙光 | 2014.12 | s006 | 1 | Intel(R) Xeon(R) CPU E7-8850 v2 @ 2.30GHz | 96 | 2TB |
存储资源¶
本集群公共存储采用联想DSS高性能存储（IBM ESS同架构），文件系统采用HPC行业广泛使用的IBM GPFS （现名为 IBM Spectrum Scale）文件系统。
公共存储硬件由2套DSS存储组成，每套DSS存储含2台IO节点和6台84盘位磁盘柜，总计4台IO节点，12台磁盘柜，1000余块8TB硬盘。所有硬盘由GPFS文件系统管理，采用了GPFS Declustered RAID冗余策略，实现了8+2数据冗余,并具有统一的用户映像（即所有硬盘由文件系统虚拟成一个data pool，可挂载在单一目录下），实测存储读写带宽达50GB/s。系统挂载目录为/public，可用容量约为5.5PB（1PB=1024TB）。
部分课题组采购了存储硬件挂载集群上，相应课题组的用户可直接使用。这部分的存储性能不及公共存储，如有大规模对存储IO要求较高的作业，建议在公共存储上进行。
存储使用注意事项：为了平衡存储的性能和利用率，GPFS配置的 sub block size（硬盘空间分配的最小尺寸）为128K，即比较小的文件（十几KB，几十KB），其占据的硬盘空间为128KB，因此对于比较小的文件（如解压后的软件源码包等）建议及时删除，减少磁盘空间浪费。
网络资源¶
集群存储节点、计算节点、以及登录节点之间用2套网络进行互联。
存储网络：采用56Gbps的Infiniband网络，存储网络和计算网络采用同一网络；
管理网络：采用千兆以太网，主要用于集群各节点间互联及管理系统；BMC硬件管理网络复用管理网络。
内网网络：登录节点login03配备了内网万兆光纤，直连到二综B座的生物信息室（B111）及附近的办公室，以便于大量数据的上传下载（速度可达100MB/s）。有大量数据传输的用户可联系B111的同学或者管理员帮忙。实验室测序平台测序仪也通过内网直连集群，测序仪下机数据如在本集群存储和分析，可由测序平台负责人直接将其上传到相应目录后再由用户拷贝到自己的账号下分析，避免使用移动硬盘来回拷贝，节省时间。
计算资源限制¶
系统对每个用户提交的作业数无限制，每个用户所有正在运行的作业同时使用的CPU核心总数限制白天为400核，夜间10点至第二天早晨6点为400核。
每个队列的内存、可用核数、用户限制略有不同，具体见 作业队列划分。
集群运行过程中，根据实际情况会略有调整，具体每个队列资源定义和限制，可使用bqueues -l 队列名 查看。
根据集群使用情况，当集群计算资源非常紧张时，可能会适当调低每个人最多能同时使用的CPU核心总数。
存储资源¶
目前对每个新用户所能使用的存储空间限制为10TB，有需要可以逐步调高到20TB，文件数限制为300万，课题组总的存储空间限制为400TB，任何一项超过阈值时，账号无法写入数据。当系统总的存储使用过高时会通知大家清理数据。
查看账号存储使用¶
用户可使用diskquota 命令查看当前存储使用量和配额，避免写满。特别是当有产生大量中间文件和结果文件的作业运行时，需时时关注，及时清理，以免超过配额。由于海量的小文件（小于128KB）会对存储系统性能有一定影响，因此大量小文件使用完之后需要即使删除或者打包压缩存放。
如下，当前的存储使用量为17.55TB，存储配额为20TB；账号下文件数据量为2145851，文件数配额为8000000；
$ diskquota
Filesystem type blocks quota limit in_doubt grace | files quota limit in_doubt grace Remarks
public USR 17.55T 20T 20T 108.1G none | 2145851 8000000 8000000 2966 none
Disk quota exceeded。清理账号下的数据至配额之下方可正常写入数据。
$ diskquota
Filesystem type blocks quota limit in_doubt grace | files quota limit in_doubt grace Remarks
public USR 43.74T 20T 20T 0 7 days | 9890452 17500000 17500000 0 none
$ cp data/NT/taxdb.btd.gz .
cp: error writing ‘./taxdb.btd.gz’: Disk quota exceeded
cp: failed to extend ‘./taxdb.btd.gz’: Disk quota exceeded
申请增加配额¶
如果因有较大项目需要大量存储时，可向管理员申请增加存储配额。在向管理员申请增加配额之前，需要先做以下几步：
-
先扫描账号下所有 大于100M的文本文件，将其中的fastq、fasta、sam、vcf、hmp、txt、csv等需要保留的文件进行压缩，将其它不需要的中间文件、日志文件等删除；然后再扫描大于100M的所有文件，时间较长的原始数据、程序运行的中间文件、冗余的bam文件等都可以删除，冗余数据的压缩清理见 数据使用规范。这2步清理完成之后再扫描大于100M的所有文件，扫描的结果发给管理员。扫描方式参考 文件扫描；
-
所有暂时不用的大批量fastq、bam、vcf等文件，需使用 genozip 压缩；
-
测试运行一个样本，并告知管理员中间数据和结果数据的路径，以及总的原始数据的大小、样本数量和运行脚本，以便管理员评估所需存储空间；
Info
流程规定得这么繁琐的目的是督促用户清理数据，避免浪费，因此用户之间不允许调剂配额；平常注意扫描数据、清理数据，到存储不够了再走申请配额的流程比较耽误时间；
集群登录方式为动态口令+密码，不支持密码和秘钥登录，集群可在校内和校外登录。校内登录IP地址和端口见管理员发送的账号信息邮件，校外登录专用的IP地址和端口号见登录集群后的欢迎信息提示。
集群登录IP地址和端口以下以 ip 和 port 代称。
登录节点生成密钥¶
在校园网内登录个人的集群帐号(登录节点 mn02 ) ，输入google-authenticator 命令回车，然后一路Y回车，如下所示，即可生成用于手机端的密钥(secret key)以及备用登录口令，备用登录口令在手机端无法生成口令时使用，务必妥善保管，过程如下所示：
$ google-authenticator
Do you want authentication tokens to be time-based (y/n) y
Warning: pasting the following URL into your browser exposes the OTP secret to Google:
https://www.google.com/chart?chs=200x200&chld=M|0&cht=qr&chl=otpauth://totp/test@localhost%3Fsecret%3DURUUTDFSZJLINDA6WYNCPFLBOQ%26issuer%3Dlocalhost
二维码
Your new secret key is: URUUTDFSZJLINDA6WYNCPFLBOQ
Enter code from app (-1 to skip): -1
Code confirmation skipped
Your emergency scratch codes are:
88914024
73601356
36327618
38345087
25344244
Do you want me to update your "/home/test/.google_authenticator" file? (y/n) y
Do you want to disallow multiple uses of the same authentication
token? This restricts you to one login about every 30s, but it increases
your chances to notice or even prevent man-in-the-middle attacks (y/n) y
By default, a new token is generated every 30 seconds by the mobile app.
In order to compensate for possible time-skew between the client and the server,
we allow an extra token before and after the current time. This allows for a
time skew of up to 30 seconds between authentication server and client. If you
experience problems with poor time synchronization, you can increase the window
from its default size of 3 permitted codes (one previous code, the current
code, the next code) to 17 permitted codes (the 8 previous codes, the current
code, and the 8 next codes). This will permit for a time skew of up to 4 minutes
between client and server.
Do you want to do so? (y/n) y
If the computer that you are logging into isn't hardened against brute-force
login attempts, you can enable rate-limiting for the authentication module.
By default, this limits attackers to no more than 3 login attempts every 30s.
Do you want to enable rate-limiting? (y/n) y
- 第一个"Y"，选择用户口令生成方式，有基于时间和计数两种方式，填"Y"表示使用基于时间生成的用户口令，否则是基于计数方式。
- 第二个"Y"，更新 ~/.google_authenticator文件，该文件内存放生成的密钥、备用码，文件权限为400，安全起见，请勿更改该文件权限。
- 第三个"Y"，禁止一个口令多人使用。
- 第三个"Y"，允许手机和服务器之间的时间有一点的误差，默认为30s，即当前时间动态口令的前一个和后一个动态口令都可用，我们也可以将这个时间误差扩大到4min。
- 第五个"Y"，默认限制30s内尝试登录的次数为3次，防止服务器被暴力攻击。
Warning
google-authenticator 命令运行完成之后，注意检查~/.google_authenticator文件是否存在ls ~/.google_authenticator。
账号的home目录权限只限于700或750，others权限不可开放，以及~/.google_authenticator文件的权限仅为400，否则二次验证会失败无法登录账号。
手机客户端生成动态验口令¶
app安装¶
在安卓的应用商店输入"身份验证器"或"google authenticator"，IOS应用商店内输入"google authenticator"以搜索安装google authenticator身份验证软件。每个安卓应用商店搜索出来的软件不太一样，如小米应用商城搜索出来的为微软的"Authenticator"，使用方式都大同小异。也可在集群用户qq群内群文件中下载google authenticator安卓安装包。
安卓手机也可以下载其它 TOTP 客户端APP 酷安
app设置¶
以google authenticator为例
-
点击"开始设置"
-
点击"手动输入动态口令"
-
填写账户信息
在"账户"内随便填方便标识的字符串，有多个账户时方便标识，此处填写的"账户"与服务器账户无关。密钥内填刚刚生成的的密钥(secret key)
URUUTDFSZJLINDA6WYNCPFLBOQ。软件根据该密钥生成对应的6位数动态口令，动态口令每30s自动更新一次。
-
最终效果
Warning
此处的动态口令基于时间生成，登录节点的时间已经与标准时间同步，因此如果手机时间有误，则生成的动态口令不可用，每个动态口令只能使用一次。
密钥和备用口令位于 ~/.google_authenticator 内，如果遗忘密钥或更换手机，可查看该文件内的密钥重新设置app以生成动态口令。建议将秘钥在电脑上备份，以便更换手机后能重新设置app生成动态口令。
客户端登录¶
Windows¶
以xshell为例，IP地址和端口为 ip 和 port ，用户名和密码为个人的集群用户名和密码。
-
新建xshell会话，填写"会话名称"以及"IP地址"
-
点击右侧的"用户身份验证"，身份方法选择"Keyboard Interactive"，不能勾选"password"，用户名填写服务器用户名，密码空着不能填写，点击确定。
-
尝试连接服务器，弹出"Verification code"窗口，填写手机上显示的6位数动态口令，点击确定。
-
在弹出的"Password"窗口内填写服务器用户密码，点击"确定"即可登录到服务器。如果出现
keyboard-interactive身份验证失败。请再试一次的报错，则需要重新输入动态口令和密码。
-
xshell成功登录之后，如果需要传输数据，可以点击xshell的sftp按钮，打开sftp，同时也会弹出与xshell类似的窗口以输入动态口令和用户密码。
linux/mac¶
使用ssh命令登录，IP地址和端口为 ip 和 port ，用户名和密码为个人的集群用户名和密码。
注意不同的系统，指定登录端口的选项略有不同，有的选项为 -p (小写)，有的选项为 -P (大写)，如果出现端口相关的报错请更换选项。
$ ssh -p port username@ip
Verification code:
Password:
Last login: Wed Dec 8 16:55:49 2021 from xxx.xxx.xxx.xxx
数据传输¶
工具推荐：Xftp(Windows 推荐)、WinSCP、Termius (macOS 推荐)、FileZilla(支持Windows、Linux、Mac OS三种平台)。
Xftp¶
Xftp 如长时间连接后传输文件出错，设置 会话 (Sessions)->属性 (Properties)->选项 (Options)->仅使用主连接 (Use main connection only)。
WinSCP¶
WinSCP 不可使用后台传输 (Background Transfers)
FileZilla¶
二次验证设置
文件->站点管理器->新站点->协议:sftp->填写ip和端口->登录方式:交互式->用户:个人账号->连接
第一个弹窗输入6位动态口令，第二个弹窗输入个人账号密码
FileZilla 长时间空闲不操作连接会中断，须在站点 (Site)->传输设置 (Transfer Settings)->勾选限制并发连接数 (Limit number of simultaneous connections)->设置最大连接数 (Maximum number of connections)为1。
其它¶
vscode¶
在config文件中添加 KbdInteractiveAuthentication yes 以便连集群时进行二次验证。
Host cluster
HostName login_ip
User username
Port login_port
KbdInteractiveAuthentication yes
从其它服务器登录或传输数据¶
本集群的安全策略禁止在校内其它服务器上通过ssh登录本集群及使用scp往本集群传输数据。
如果需要从校内其他服务器往本集群上传输数据，可以在本集群上运行如下命令，即在本集群上使用scp获取在其他服务器上的数据。
$ scp -p port -r dir user@remote:~
Warning
在校外登录时，部分单位的网络环境中，可能单位的防火墙不允许使用非22端口对外登录服务器，表现为确认使用的登录IP和端口正确无误后，登录时仍然无法弹出输入动态口令和密码的窗口。建议与网络管理员沟通放行该端口，或者使用手机热点网络登录集群。
LSF 基本使用¶
LSF（Load Sharing Facility）是IBM旗下的一款分布式集群管理系统软件，负责计算资源的管理和批处理作业的调度。它给用户提供统一的集群资源访问接口，让用户透明地访问整个集群资源。同时提供了丰富的功能和可定制的策略。LSF 具有良好的可伸缩性和高可用性，支持几乎所有的主流操作系统。它通常是高性能计算环境中不可或缺的基础软件。
LSF的功能和命令非常多，这里主要介绍普通用户常用命令，更详细的命令文档参见 IBM Spectrum LSF command reference。
提交作业¶
LSF命令行提交作业¶
与PBS不同，大部分情况下，可以不需要写作业脚本，直接一行命令就可以提交作业
bsub -J blast -n 10 -R span[hosts=1] -o %J.out -e %J.err -q normal "blastn -query ./ZS97_cds.fa -out ZS97_cds -db ./MH63_cds -outfmt 6 -evalue 1e-5 -num_threads \$LSB_DJOB_NUMPROC"
LSF脚本1-串行作业(单节点)¶
LSF中用户运行作业的主要方式为，编写LSF作业脚本，使用bsub命令提交作业脚本。如下所示为使用LSF脚本blastn.lsf
#BSUB -J blast
#BSUB -n 10
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
# 注意-num_threads是blastn的线程设置参数，不同软件参数不同
# 如果软件没有明确有设置线程数的参数，则不设置，默认使用单线程，作业也只需申请一个CPU核心
blastn -query ./ZS97_cds.fa -out ZS97_cds -db ./MH63_cds -outfmt 6 -evalue 1e-5 -num_threads $LSB_DJOB_NUMPROC
提交作业blastn.lsf
bsub < blastn.lsf
脚本中每行内容解释
- -J 指定作业名称
- -n 作业使用核心数，LSF中一般称之为slot
- -R span[hosts=1] 指定作业只能在单个节点运行，不能跨节点（跨节点作业需要MPI支持，生物中比较少）。-R 可以使得作业在需要满足某种条件的节点上运行，常用的有
-R "rusage[mem=20GB]"，表示作业预计消耗的内存为20G，节点需要为作业预留20G内存，消耗内存较大的作业需要合理设置该选项，以避免多个作业挤在一个节点而导致节点因内存耗尽而挂掉，内存也不可写得太大，否则会导致大量节点因为要预留很多内存，而不能接收新的作业，造成资源浪费；-R "select[maxmem>224800]"，表示选择节点物理内存大于224800MB的节点来运行当前作业，需要使用大内存节点时，可以使用此选项。多个-R 选项可以组合，如-R "span[hosts=1] rusage[mem=20GB] select[maxmem>224800]"。 - -o 作业标准输出，%J为作业ID，即此处的作业输出文件为 jobid.out
- -e 作业错误输出，%J为作业ID，即此处的作业输出文件为 jobid.err
- -q 作业提交的作业队列
Note
$LSB_DJOB_NUMPROC 为LSF系统变量，表示作业脚本申请的CPU核心数。建议所有作业都使用这个变量设置程序使用的线程数，方便动态调整以及作业脚本申请的核心数和程序设置的线程数保持一致。如blastn使用-num_threads这个参数设置线程数，LSF脚本申请4核用多线程跑时，一般写法为blastn -num_threads 4，LSF脚本内的推荐写法为：用$LSB_DJOB_NUMPROC变量代替4，即 blastn -num_threads $LSB_DJOB_NUMPROC，这样调整LSF -n参数申请不同的核数时，-num_threads 参数可以不用同步调整。
另外还有一些常用选项
- -M 内存控制参数，作业占用的内存超过其指定值时，作业会被系统杀掉。如
-M 20GB -R "rusage[mem=20GB]"申请20GB的内存，且其内存使用量不能超过20G - -m 指定作业运行节点，如
-m c01n01 - -W hh:mm 设置作业运行时间
- -w 作业依赖，方便写流程，如
-w "done(JobA)"，作业名为JobA的作业完成之后，该作业才开始运行；作业依赖详细用法 - -K 提交作业并等待作业结束，在写流程时会用得上，可以见后面的例子
- -P 指定project name，如果我们需要统计某个项目消耗的计算资源，如CPU时等，可以将相关的作业都指定为同一个project name，然后根据project name统计资源消耗
- -r rerun选项，即作业失败后自动重新运行，提交大量作业时此选项比较有用
LSF脚本2-并行作业(多节点)¶
#BSUB -J MPIJob ### set the job Name
#BSUB -q normal ### specify queue
#BSUB -n 400 ### ask for number of cores (default: 1)
#BSUB -R "span[ptile=20]" ### ask for 20 cores per node
#BSUB -W 10:00 ### set walltime limit: hh:mm
#BSUB -o stdout_%J.out ### Specify the output and error file. %J is the job-id
#BSUB -e stderr_%J.err ### -o and -e mean append, -oo and -eo mean overwrite
# here follow the commands you want to execute
# load the necessary modules
# NOTE: this is just an example, check with the available modules
module load intel/2018.4
module load mpi/intel/2018.4
### This uses the LSB_DJOB_NUMPROC to assign all the cores reserved
### This is a very basic syntax. For more complex examples, see the documentation
mpirun -np $LSB_DJOB_NUMPROC ./MPI_program
此脚本申请400核，每个节点20个核。
多节点并行作业需要程序本身支持，使用mpirun等MPI命令运行，绝大部分生物软件不支持多节点并行。强行使用，会出现作业申请了并占用了多个节点，但程序实际只使用了一个节点，其它节点无程序运行，造成资源的极大浪费 。如不确定程序是否支持多节点并行，请勿使用，避免资源浪费。
使用系统范围的intelmpi / openmpi时，可以省略-np $ LSB_DJOB_NUMPROC命令，因为程序会自动获取有关核心总数的信息。如果使用不同的MPI库，可能需要明确指定MPI的数量 以这种方式在命令行上进行处理。
LSF批量提交作业¶
批量提交简单作业¶
需要处理的数据样本较多时，手工提交非常繁琐，且容易出错，我们可以编写简单的shell脚本来实现大批量自动提交多个作业（可同时提交上万个作业）。
以跑多样本的STAR为例，将下面的脚本保存为run_STAR.sh，运行该脚本，即可同时提交一批作业，而不用一个个手动提交。
for sample in /public/home/username/work/lsf_bwait/raw_data/*trim_1.fq.gz;do
index=$(basename $sample |sed 's/_trim_1.fq.gz//')
prefix=$(dirname $sample)
star_index=/public/home/username/work/lsf_bwait/star/
gtf=/public/home/username/work/lsf_bwait/MH63.gtf
bsub -J ${index} -n 8 -o %J.${index}.out -e %J.${index}.err -R span[hosts=1] \
"STAR --runThreadN 8 --genomeDir ${star_index} --readFilesIn ${prefix}/${index}_trim_1.fq.gz ${prefix}/${index}_trim_2.fq.gz --outFileNamePrefix ${index}. --sjdbGTFfile $gtf"
sleep 10
done
批量提交分析流程¶
生信中经常会遇到需要跑大量作业以及复杂流程的情况，特别是当流程中使用的软件为多线程和单线程混杂时，如果把所有流程步骤写到同一个shell脚本，并按多线程需要的线程数来申请CPU 核心数，无疑会造成比较大的浪费。
在此建议将流程中的主要运行步骤直接用bsub提交，按需要申请核心数、内存等，需要用上文中提到的bsub的 -K 参数。这里写了一个跑RNA-Seq流程的example，主要是2个脚本，RNA.sh 为具体处理每个样本的流程脚本，在batch_run.sh 对每个样本都提交运行RNA.sh脚本。
使用时，提交batch_run.lsf脚本即可, bsub < batch_run.lsf 。
RNA.sh
#!/bin/sh
sample=$1
index=$(basename $sample |sed 's/_trim_1.fq.gz//')
prefix=$(dirname $sample)
star_index=/public/home/username/work/lsf_bwait/star/
gtf=/public/home/username/work/lsf_bwait/MH63.gtf
bsub -K -J STAR1 -n 8 -o %J.STAR1.out -e %J.STAR1.err -R span[hosts=1] "module purge;module load STAR/2.6.0a-foss-2016b;STAR --runThreadN 8 --genomeDir ${star_index} \
--readFilesIn ${prefix}/${index}_trim_1.fq.gz ${prefix}/${index}_trim_2.fq.gz \
--outSAMtype SAM --readFilesCommand zcat --alignIntronMax 50000 --outFileNamePrefix ${index}. --sjdbGTFfile $gtf --outReadsUnmapped None"
bsub -K -J STAR2 -n 1 -o %J.STAR2.out -e %J.STAR2.err -R span[hosts=1] "grep -E '@|NH:i:1' ${index}.Aligned.out.sam >${index}.Aligned.out.uniq.sam"
bsub -K -J STAR3 -n 2 -o %J.STAR3.out -e %J.STAR3.err -R span[hosts=1] "module purge;module load SAMtools/1.3;samtools sort -@2 ${index}.Aligned.out.uniq.sam > ${index}.Aligned.out.bam"
rm ${index}.Aligned.out.sam
rm ${index}.Aligned.out.uniq.sam
rm ${index}.Aligned.out.uniq.bam
bsub -K -J STAR4 -n 1 -o %J.STAR4.out -e %J.STAR4.err -R span[hosts=1] "module purge;module load HTSeq/0.8.0;htseq-count -f bam -s no ${index}.Aligned.out.bam -t gene $gtf >${index}.Genecounts 2>${index}.htseq.log"
batch_run.lsf
#BSUB -J STAR
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
for sample in /public/home/username/work/lsf_bwait/raw_data/*trim_1.fq.gz;do
index=$(basename $sample |sed 's/_trim_1.fq.gz//')
sh RNA.sh ${sample} &
sleep 10
done
wait
不合理批量提交方式¶
如下这个脚本所示，在一个lsf脚本内循环跑多个样本，即一个样本跑完之后才能跑下一个，每个样本的运行时间较长，这样不能充分利用集群节点多、核多的优势，比较浪费时间，因此如果不是有特殊需求，不建议使用这种方式跑多个样本的作业。
#BSUB -J STAR
#BSUB -n 8
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
for sample in /public/home/username/work/lsf_bwait/raw_data/*trim_1.fq.gz;do
index=$(basename $sample |sed 's/_trim_1.fq.gz//')
prefix=$(dirname $sample)
star_index=/public/home/username/work/lsf_bwait/star/
gtf=/public/home/username/work/lsf_bwait/MH63.gtf
STAR --runThreadN 8 --genomeDir ${star_index} --readFilesIn ${prefix}/${index}_trim_1.fq.gz ${prefix}/${index}_trim_2.fq.gz --outFileNamePrefix ${index}. --sjdbGTFfile $gtf"
sleep 10
done
大批量小作业提交¶
由于作业排队调度和退出需要一定时间，如果每个作业内程序运行时间很短(小于10min)、且作业数量较大(大于1000)，建议将多个作业合并在一个作业内运行。
如下所示，需要提交1000个不同参数的作业，可以每个作业内跑100个作业，提交10这样的作业：
#BSUB -J process1-100
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
for args in {args1,args2..args100};do
python process.py ${args}
done
合理设置作业内存¶
对于部分程序，因其使用的核数较少、单个作业内存消耗较大，直接批量提交时，容易多个作业被系统分配在一个节点，导致节点内存耗尽、作业被挂起的情况。
跑GWAS流程时所用的一些软件比较频繁出现这种情况，如fastlmmc tassel。因此需要先跑一个作业，结束后查看内存使用(maxmem)，如15G，然后批量提交使用lsf参数 -R rusage[mem=15G]来申请内存。
同时不建议盲目申请远远超出实际使用的内存量，如-R rusage[mem=100G]，这会导致一个节点只会运行2-3个作业，其它作业也无法使用该节点，造成计算资源大量浪费。
单个作业使用的核心数低于4时，需要及时关注作业运行情况，如果出现大量作业被挂起的情况，使用lsload查看节点内存剩余情况，bjobs -l jobid查看作业内存使用量，使用bmod -R "rusage[mem=15GB] select[maxmem>224800]" jobid调整作业内存消耗，然后brequeue jobid重新运行该作业。
多次出现作业被大面积挂起的情况且没有及时处理，将被降低可使用的核数。
LSF交互作业¶
类似于PBS中的qsub -I，为了防止滥用（开了之后长期不关等）交互模式，目前只允许在interactive队列使用交互模式，且时间限制为48h，超时会被杀掉。
bsub -q interactive -Is bash
也可以
bsub -q interactive -Is sh
此时不会加载~/.bashrc
如果需要进行图形转发，如画图等，可以加-XF 参数
bsub -q interactive -XF -Is bash
查询作业¶
使用bjobs命令查看作业运行状态、所在队列、从哪个节点提交、运行节点及核心数、作业名称、提交时间等。
$ bjobs
JOBID USER STAT QUEUE FROM_HOST EXEC_HOST JOB_NAME SUBMIT_TIME
10498205 username RUN smp login01 10*s001 fq Sep 6 17:54
10498206 username RUN smp login01 10*s001 fq Sep 6 17:54
10498207 username RUN smp login01 10*s001 fq Sep 6 17:54
10498209 username RUN smp login01 10*s001 fq Sep 6 17:54
10498211 username RUN smp login01 10*s001 fq Sep 6 17:54
10498217 username RUN smp login01 10*s001 fq Sep 6 17:54
10498219 username RUN smp login01 10*s001 fq Sep 6 17:54
10498226 username RUN smp login01 10*s001 fq Sep 6 17:54
10498227 username RUN smp login01 10*s001 fq Sep 6 17:54
10498708 username PEND smp login01 fq Sep 6 17:54
10498709 username PEND smp login01 fq Sep 6 17:54
10498710 username PEND smp login01 fq Sep 6 17:54
10498711 username PEND normal login01 fq Sep 6 17:54
10498712 username PEND normal login01 fq Sep 6 17:54
10559750 username USUSP high login02 2*c03n07 GWA Sep 7 14:30
作业状态主要有:
- PEND 正在排队
- RUN 正在运行
- DONE 正常退出
- EXIT 异常退出
- SSUSP 被系统挂起
- USUSP 被用户自己挂起
bjobs还有一些常用的选项，
- -r 查看正在运行的作业
- -pe 查看排队作业
- -l 查看作业详细信息
- -sum 查看所有未完成作业的汇总信息
- -p 查看作业排队的原因，如下面这个作业的排队原因为用户所有正在运行作业所使用的总核心数达到了该用户所能使用核心数上限
其它相关提示如下：
$ bjobs -p 40482594 JOBID USER STAT QUEUE FROM_HOST EXEC_HOST JOB_NAME SUBMIT_TIME 10482594 username PEND normal c01n05 bwa Sep 6 06:33 The user has reached his/her job slot limit (Limit Name: N/A, Limit Value: 1200);User has reached the pre-user job slot limit of the queue
: 用户作业达到了排队中作业所在队列的个人作业核数上限。 : 此队列中用户正在运行的作业有计算结束后，才会再分配后续的排队作业。The slot limit reached;4 hosts: 排队中作业数达到了所在队列可使用节点数的上限。 : 此队列中所有用户正在运行的作业有计算结束，才会再分配此队列中排在最前边的作业。The user has reached his job slot limit: 用于已运行的作业数达到了系统规定的上限。 : 需已运行的作业有新的计算结束，排队中的作业才会进入调度系统。The queue has reached its job slot limit: 排队中已经运行的所有作业达到了系统上队列总作业核数的上限。 : 需该队列中已经运行的作业有新的计算结束，才会调度该队列中排在第一位的作业。Pending job threshold reached. Retrying in 60 seconds: 提交的作业超过系统对用户提交作业数的上限。 : 需该队列中已经运行的作业有新的计算结束，新提交的作业才会被LSF接收。
- -o 定制输出格式，如为了方便实时查看作业使用的最大内存，添加
max_mem选项，宽度为14。使用$ bjobs -o "jobid:10 user:6 stat:6 queue:6 exec_host:10 job_name:10 max_mem:14 submit_time:12" JOBID USER STAT QUEUE EXEC_HOST JOB_NAME MAX_MEM SUBMIT_TIME 46477783 username RUN high c01n09 AS_TWAS 30.3 Gbytes Dec 12 13:32 46477903 username RUN high c01n09 AS_TWAS 22.6 Gbytes Dec 12 13:32 46477766 username RUN high c01n09 AS_TWAS 20.3 Gbytes Dec 12 13:32 46477725 username RUN high c01n05 AS_TWAS 26.5 Gbytes Dec 12 13:32 46477726 username RUN high c01n05 AS_TWAS 22.7 Gbytes Dec 12 13:32 46477727 username RUN high c01n05 AS_TWAS 19.2 Gbytes Dec 12 13:32 46477804 username RUN high c01n05 AS_TWAS 26.6 Gbytes Dec 12 13:32 46477805 username RUN high c01n05 AS_TWAS 20.3 Gbytes Dec 12 13:32 46477836 username RUN high c01n04 AS_TWAS 25.2 Gbytes Dec 12 13:32alias简写该命令此外也可以添加$ vim ~/.bashrc alias bbjobs='bjobs -o "jobid:10 user:6 stat:6 queue:6 exec_host:10 job_name:10 max_mem:14 submit_time:12"' $ source ~/.bashrc $ bbjobs JOBID USER STAT QUEUE EXEC_HOST JOB_NAME MAX_MEM SUBMIT_TIME 46477783 username RUN high c01n09 AS_TWAS 30.3 Gbytes Dec 12 13:32 46477903 username RUN high c01n09 AS_TWAS 22.6 Gbytes Dec 12 13:32 46477766 username RUN high c01n09 AS_TWAS 20.3 Gbytes Dec 12 13:32 46477725 username RUN high c01n05 AS_TWAS 26.5 Gbytes Dec 12 13:32 46477726 username RUN high c01n05 AS_TWAS 22.7 Gbytes Dec 12 13:32 46477727 username RUN high c01n05 AS_TWAS 19.2 Gbytes Dec 12 13:32 46477804 username RUN high c01n05 AS_TWAS 26.6 Gbytes Dec 12 13:32 46477805 username RUN high c01n05 AS_TWAS 20.3 Gbytes Dec 12 13:32 46477836 username RUN high c01n04 AS_TWAS 25.2 Gbytes Dec 12 13:32run_timecpu_used查询作业的runtime(即，作业运行的时间)和cputime(即，作业运行消耗的CPU时)。一般而言，cputime=runtime*核数，若cputime远小于runtime，则表示作业资源申请不合理，或作业在空跑，请检查作业是否正常在跑。 如下所示，作业cputime远小于runtime，经检查作业运行出错，但没有退出。$ bjobs -o "jobid:8 user:8 stat:6 queue:6 exec_host:10 job_name:8 nreq_slot:6 slots:5 max_mem:12 submit_time:12 start_time:12 run_time:16 cpu_used" JOBID USER STAT QUEUE EXEC_HOST JOB_NAME NREQ_S SLOTS MAX_MEM SUBMIT_TIME START_TIME RUN_TIME CPU_USED 6554018 username RUN normal 8*c03n02 *g_BK200 8 8 520 Mbytes Sep 13 15:38 Sep 13 20:28 48509 second(s) 3285 second(s) 6554039 username RUN normal 8*c03n06 *g_BR461 8 8 473 Mbytes Sep 13 15:38 Sep 13 21:18 45488 second(s) 4043 second(s) 6554029 username RUN normal 8*c03n09 *g_BL300 8 8 517 Mbytes Sep 13 15:38 Sep 13 21:09 46049 second(s) 4067 second(s) 6554015 username RUN normal 8*c01n05 *_BJS500 8 8 516 Mbytes Sep 13 15:38 Sep 13 20:20 48979 second(s) 3222 second(s) 6554021 username RUN normal 8*c02n09 *g_BK350 8 8 482 Mbytes Sep 13 15:38 Sep 13 20:32 48232 second(s) 2963 second(s) 6554022 username RUN normal 8*c02n08 *g_BK400 8 8 699 Mbytes Sep 13 15:38 Sep 13 20:37 47988 second(s) 3952 second(s) 6554028 username RUN normal 8*c03n01 *g_BL250 8 8 539 Mbytes Sep 13 15:38 Sep 13 21:03 46410 second(s) 3755 second(s) 6554024 username RUN normal 8*c04n03 *g_BK500 8 8 515 Mbytes Sep 13 15:38 Sep 13 20:38 47873 second(s) 3867 second(s) 6554044 username RUN normal 8*c01n13 *g_BS400 8 8 507 Mbytes Sep 13 15:38 Sep 13 21:23 45191 second(s) 2018 second(s) 6554043 username RUN normal 8*c01n02 *g_BS300 8 8 593 Mbytes Sep 13 15:38 Sep 13 21:23 45221 second(s) 3394 second(s) 6554046 username RUN normal 8*c02n10 *g_BS500 8 8 534 Mbytes Sep 13 15:38 Sep 13 21:28 44888 second(s) 3262 second(s)
修改排队作业运行参数¶
bmod可更改正在排队的作业的多个参数，如
bmod -n 2 jobid 更改作业申请的核心数
bmod -q q2680v2 jobid 更改作业运行队列
挂起/恢复作业¶
用户可自行挂起或者继续运行被挂起的作业。
bstop jobid 挂起作业，如作业被系统挂起（节点剩余可用内存过低系统会自动挂起该节点上的部分作业），则作业状态为SSUSP；如被用户自己或管理员挂起，则作业状态为USUSP
bresume bjoid 继续运行被挂起的作业
因为作业在挂起时，仍然会占用计算资源，因此用户不可自己随意长时间大批量挂起自己的作业以避免资源浪费。
调整排队作业顺序¶
bbot jobid 将排队的作业移动到队列最后（bottom）
btop jobid 将排队的作业移动到队列最前（top）
查询输出文件¶
在作业完成之前，输出文件out和error被保存在系统文件中无法查看，可以使用bpeek命令查看输出文件
终止作业¶
如果用户要在作业提交后终止自己的作业，可以使用bkill命令，用法为bkill jobid。非root用户只能查看、删除自己提交的作业。
bkill 12345 杀死作业id为12345的作业
bkill 0 杀死当前用户的所有作业(正在运行的、排队的、挂起的等)
资源查看¶
bhosts¶
查看所有节点核心数使用情况
$ bhosts
HOST_NAME STATUS JL/U MAX NJOBS RUN SSUSP USUSP RSV
c01n01 closed - 36 36 36 0 0 0
c01n02 closed - 36 36 36 0 0 0
c01n03 closed - 36 36 36 0 0 0
c01n04 closed - 36 36 36 0 0 0
c01n05 closed - 36 36 36 0 0 0
c07n09 closed - 36 36 36 0 0 0
c07n10 closed - 36 36 36 0 0 0
c07n11 closed - 36 36 36 0 0 0
gpu01 ok - 36 29 29 0 0 0
gpu02 ok - 20 0 0 0 0 0
login01 closed - 0 0 0 0 0 0
login02 closed - 0 0 0 0 0 0
login03 closed - 0 0 0 0 0 0
mn02 closed - 0 0 0 0 0 0
mn02 closed - 0 0 0 0 0 0
s001 closed - 192 192 192 0 0 0
s002 closed - 192 192 192 0 0 0
s003 ok - 192 189 189 0 0 0
sg01 closed - 20 20 20 0 0 0
sg02 closed - 20 20 20 0 0 0
sg03 closed - 20 20 20 0 0 0
sg04 closed - 20 20 20 0 0 0
sg05 closed - 20 20 20 0 0 0
sg06 ok - 20 0 0 0 0 0
sg07 closed - 20 20 20 0 0 0
sg08 closed - 20 20 20 0 0 0
sg09 ok - 20 0 0 0 0 0
sg10 ok - 20 17 17 0 0 0
- HOST_NAME 节点名称
- STATUS： ok：表示可以接收新作业，只有这种状态可以接受新作业 closed：表示已被作业占满，不接受新作业 unavail和unreach：系统停机或作业调度系统服务有问题
- JL/U 每个用户在该节点最多能使用的核数，- 表示没有限制
- MAX 最大可以同时运行的核数
- NJOBS 当前所有运行和待运行作业所需的核数
- RUN 已经开始运行的作业占据的核数
- SSUSP 系统所挂起的作业所使用的核数
- USUSP 用户自行挂起的作业所使用的核数
- RSV 系统为你预约所保留的核数
lsload¶
查看所有节点的负载、内存使用等
$ lsload
HOST_NAME status r15s r1m r15m ut pg ls it tmp swp mem
sg17 ok 0.0 0.0 0.1 0% 0.0 0 2e+5 264G 2.4G 113G
sg11 ok 0.0 0.0 0.1 0% 0.0 0 49055 264G 3.7G 113G
gpu02 ok 0.0 0.0 0.1 0% 0.0 0 7337 248G 29.8G 52.9G
login01 ok 0.2 0.7 0.6 6% 0.0 39 0 242G 0M 47.6G
login02 ok 0.7 0.4 0.6 5% 0.0 41 0 241G 27.8G 42.9G
sg27 ok 0.8 0.6 0.6 4% 0.0 0 88098 264G 3G 110G
c01n11 ok 0.8 19.7 19.6 4% 0.0 0 1788 432G 2.1G 348G
c05n07 ok 1.0 1.0 1.0 3% 0.0 0 1463 429G 3G 170G
c07n09 ok 1.0 1.0 1.0 3% 0.0 0 14604 432G 3.9G 158G
c01n10 ok 1.1 18.7 18.7 3% 0.0 0 3713 432G 3G 349G
sg21 ok 1.2 1.2 1.2 7% 0.0 0 5054 258G 3.6G 109G
c03n07 ok 1.3 18.6 18.6 4% 0.0 0 15072 429G 3.1G 340G
sg30 ok 1.3 1.0 1.0 5% 0.0 0 734 265G 2.4G 69.6G
c01n06 ok 1.3 20.0 20.6 5% 0.0 0 13242 432G 3.7G 351G
sg25 ok 1.5 1.0 1.7 5% 0.0 0 2e+5 258G 2.1G 108G
c06n03 ok 1.6 13.3 13.4 9% 0.0 0 14576 432G 3.7G 168G
sg02 ok 1.8 54.3 45.7 9% 0.0 2 18 239G 63.9M 78.5G
c06n01 ok 1.9 7.7 7.6 5% 0.0 0 3718 432G 3.8G 167G
c07n06 ok 2.0 14.3 14.2 12% 0.0 0 14956 431G 3.8G 166G
c05n05 ok 35.6 35.5 33.8 96% 0.0 0 15103 426G 2.9G 119G
c04n05 ok 35.7 35.8 35.4 94% 0.0 0 15972 427G 2.8G 114G
c06n06 ok 36.0 36.0 36.1 100% 0.0 0 14658 432G 3.7G 173G
c05n01 ok 37.4 38.3 37.5 97% 3.7 0 12160 432G 1.4G 141G
c06n12 ok 39.4 36.8 34.2 94% 0.0 0 7495 430G 3.6G 132G
c01n12 ok 45.1 48.2 46.8 82% 0.0 0 8000 432G 1.7G 278G
s002 ok 61.0 61.5 57.6 31% 0.0 1 739 1309G 3.1G 1.5T
s001 ok 70.9 73.7 91.8 19% 0.0 0 740 1286G 42.8M 1.3T
s006 ok 124.6 128.4 132.1 100% 0.0 0 432 1101G 3.5G 1.9T
s004 ok 128.1 125.3 123.3 65% 0.0 0 758 1318G 429M 1.8T
s003 ok 244.5 235.9 240.7 98% 0.0 1 3 1288G 2.8G 1.6T
bqueues¶
查看队列信息
$ bqueues
QUEUE_NAME PRIO STATUS MAX JL/U JL/P JL/H NJOBS PEND RUN SUSP
interactive 80 Open:Active - 3 - - 81 1 74 6
normal 30 Open:Active - - - - 19012 15984 3028 0
parallel 30 Open:Active - - - - 725 500 225 0
gpu 30 Open:Active - 10 - - 37 8 29 0
high 30 Open:Active - - - - 349 182 166 1
smp 30 Open:Active - 300 - - 6106 5166 940 0
q2680v2 30 Open:Active - 100 - - 5330 4784 546 0
- -u 查看所用所能使用的队列
- -m 查看节点所在的队列
- -l 查看队列的详细信息
$ bqueues -l smp QUEUE: smp -- huge memory jobs PARAMETERS/STATISTICS PRIO NICE STATUS MAX JL/U JL/P JL/H NJOBS PEND RUN SSUSP USUSP RSV PJOBS 30 0 Open:Active - 300 - - 6106 5156 950 0 0 0 737 Interval for a host to accept two jobs is 0 seconds HOSTLIMIT_PER_JOB 1 SCHEDULING PARAMETERS r15s r1m r15m ut pg io ls it tmp swp mem loadSched - - - - - - - - - - 29.2G loadStop - - - - - - - - - - 9.7G SCHEDULING POLICIES: NO_INTERACTIVE USERS: all HOSTS: s001 s002 s003 s004 s005 s006 RES_REQ: rusage[mem=10000] span[hosts=1] RESRSV_LIMIT: [mem=2000000] RERUNNABLE : yes
常见问题¶
- 程序运行异常但没有作业没有退出，最常见于 hisat2 比对，使用 bpeek 查看作业日志，报错如下
(ERR): "/public/home/username/database/reference/genome" does not exist Exiting now ...
帐号申请¶
用户范围¶
本系统实行收费使用的管理办法，在满足本实验室正常使用的情况下，面向全校师生开放使用。
帐号申请时间¶
本集群每学期初和学期中（第12周左右）开放一次申请、考核，具体的通知会发到重点实验室各个老师的邮箱、重点实验室集群用户群等处。由于各种原因错过每学期帐号申请的同学，需等到下次开放申请。
帐号申请流程¶
- 学期初或12周左右，管理员下发集群开放申请通知，并开放集群考核报名的在线文档，如果有需要可填写报名文档参加考核。时间约为一周，期间练习账号也会开放，可向管理员申请使用。
- 申请用户参加集群用户考核，考核形式为纸质试卷+上机测试，考核内容见 集群考试内容。考试为开卷考试，可以携带学习资料、使用机房电脑搜索查询等。
- 考核80分通过，通过的申请用户需填写重点实验室服务器用户申请表，纸质版需本人和导师签字同意，然后将签字后的申请表拍照连同申请表电子版(word)发送到管理员邮箱。
- 管理员开通集群帐号，并将相关信息发到申请用户邮箱。
集群采用NIS用户认证，如用户需要修改密码，只需在登陆节点运行yppasswd，根据提示输入旧密码，然后输入新密码即可。新密码需要遵循以下规则，否则无法修改成功：
- 新密码长度至少包含 10 个字符
- 新密码至少包含1个数字
- 新密码至少包含1大写字母
- 新密码至少包含1个特殊字符
- 新密码至少包含1个小写字母
作业队列划分¶
根据硬件配置和功能划分需要，集群划分为6个作业队列，normal、high、interactive、parrallel、smp、q2680v2和gpu，默认6个队列所对应的计算节点和使用限制如下。在集群实际运行过程中可能会根据使用情况有所调整，用户可以使用bquque命令查看每个作业队列的使用情况。
- normal、high队列单个作业申请的CPU数不超过36核；q2680v2队列申请的CPU核数不超过20核；smp队列申请的核数不超过50核；
- normal队列作业每核内存不超过5G，否则会被系统杀掉；作业如需较多内存，则需申请多个核；high队列每核内存限制为10G；
- 运行perl、python、R等脚本，如果使用内存较少，建议只申请1核；
- 集群作业较多、排队时间较长时，请注意减少作业申请核数或使用q2680v2队列，以避免排队时间过长；
| 队列 | 节点 | 使用限制 | 功能说明 |
|---|---|---|---|
| normal | c01n01-c07n11 | 作业平均每核内存不超过5G，否则会被系统杀掉；作业需要较多的内存，则需要申请更多核，如预计作业会用到20G内存，则至少申请4核 | 集群默认队列 |
| high | c01n01-c04n03 | 作业平均每核内存不超过10G，否则会被系统杀掉；作业需要较多的内存，则需要申请更多核，如预计作业会用到50G内存，则至少申请5核 | 每节点内存384GB |
| interactive | sg57-sg60 | 2核/用户，24h | 交互作业队列，用于调试代码或画图等 |
| parrallel | c01n01-c07n11 | 100核/用户，使用需向管理员申请 | 并行作业队列，运行MPI作业，如maker |
| smp | s001-s006 | 50核/节点/用户 | 胖节点队列，节点内存2T-4T，建议作业内存200G使用此队列 |
| gpu | gpu01-02 | 使用需向管理员申请 | GPU作业可申请使用，见GPU节点使用 |
| q2680v2 | sg01-sg60 | 100核/用户 | 老集群队列，速度相对较慢 |
备份存储使用¶
Warning
因备份存储早已过了保修期，且故障率非常高，现已不再往备份存储内存放数据。
为了提高系统并行存储的利用率和节省大家服务器存储使用费用，大家可以把服务器上使用频率较少的重要数据存放在服务器的备份存储上，具体使用方法如下，
- 向管理员申请使用备份存储，然后管理员会在备份存储节点上建立相应的目录，并赋予相应的权限
- 登录login02节点，将并行存储中的数据转移到备份存储上，如username用户在份存储上的数据目录为
/backup/data/username - 严禁在备份存储上直接跑作业
- 大的文本文件如fastq、fasta、sam、vcf等，务必先压缩后再备份到备份存储上，以节省备份存储的磁盘空间
- 如果一次备份的数据量较大，建议先使用rsync将数据同步到备份存储，如
rsync -av --progress /public/home/username/data /backup/data/username，确认完全同步完之后，再将源数据删除
账户注销¶
在学期结束后，已毕业不再使用集群的用户，需备份下载自己需要保留的数据，然后将账号内的数据清空，以免产生不必要的存储费用。管理员择时统一注销所有账号。注销账号前会再跟本人或导师进行确认。
考试内容¶
服务器考试范围大致分为三块：
- Linux基本使用
- LSF作业提交系统的使用
- 集群使用规章制度和注意事项
Linux基本使用¶
- 文件目录操作，要求掌握文件所属的用户和用户组、文件权限的概念（可读、可写、可执行），理解不同的文件类型，如普通文件、目录、块设备、链接文件等，要求掌握的命令
ls、pwd、cd、mv、rm、mkdir、ln、cp、chmod、alias； - 文本操作，需要掌握至少一种文本编辑器（推荐vim），理解管道、重定向，要求掌握基本的文本处理命令
cat、more、less、head、tail、wc、nl、cut、sort、uniq、grep、sed、awk、file； - 查看系统信息，能使用Linux系统提供的工具和命令查看磁盘使用、系统负载、内存使用、系统版本等信息，需要掌握的命令
df、du、free、uptime； - 进程管理，了解进程和多线程的基本概念，需要掌握的命令
top、ps、bg、fg、jobs、kill、pgrep、nohup、screen、Ctrl+z、Ctrl+c； - 掌握Linux软件的安装，主要是能从源码编译安装二进制文件，理解PATH变量，编辑
~/.bashrc文件，使用rpm -qa命令查看系统安装的一些库和软件； - 简单的Linux shellscprit编程知识，掌握基本的语法；
- 其他，文件查找
which、locate、find、where，文件压缩tar、gzip、pigz，查看帮助文档man，远程文件传输scp rsync，不同节点间跳转ssh，查看已使用的命令history，查看当前登陆用户who，文件下载wget，windows文件转Unix文件dos2unix。
linux学习可以参考：Linux 基础
LSF作业提交系统的使用¶
集群使用规章制度和注意事项¶
集群收费标准¶
收费标准¶
每个CPU时0.1元，并行存储空间每GB每月0.05元。
折扣标准¶
重点室用户3折；重点实验室之外的用户不打折。
文章机时折扣¶
根据用户上报的上一年度的文章，决定本年度的集群机时折扣。
论文致谢模板¶
中文： 本论文的计算结果得到了华中农业大学作物遗传改良全国重点实验室生物信息计算平台的支持和帮助。
English: The computations in this paper were run on the bioinformatics computing platform of the National Key Laboratory of Crop Genetic Improvement, Huazhong Agricultural University.
新闻稿致谢： 该研究数据分析工作得到华中农业大学作物遗传改良全国重点实验室生物信息计算平台的支持和帮助。
致谢文章列表¶
点击表头可以将表格重新排序
| 年份 | 文章 | 期刊 | 期刊分级 |
|---|---|---|---|
| 2021 | Using high-throughput multiple optical phenotyping to decipher the genetic architecture of maize drought tolerance | Genome Biology | A |
| 2021 | The genetic mechanism of heterosis utilization in maize improvement | Genome Biology | A |
| 2021 | Cotton pan-genome retrieves the lost sequences and genes during domestication and selection | Genome Biology | A |
| 2021 | ASMdb: a comprehensive database for allele-specific DNA methylation in diverse organisms | Nucleic Acids Research | B |
| 2021 | An inferred functional impact map of genetic variants in rice | Molecular Plant | B |
| 2021 | Comparative Genome Analyses Highlight TransposonMediated Genome Expansion and the Evolutionary Architecture of 3D Genomic Folding in Cotton | Molecular Biology and Evolution | B |
| 2021 | Two gap-free reference genomes and a global view of the centromere architecture in rice | Molecular Plant | B |
| 2021 | Calling large indels in 1047 Arabidopsis with IndelEnsembler | Nucleic Acids Research | B |
| 2022 | A multi-omics integrative network map of maize | Nature Genetics | A |
| 2022 | Genome sequencing reveals evidence of adaptive variation in the genus Zea | Nature Genetics | A |
| 2022 | Genomic innovation and regulatory rewiring during evolution of the cotton genus Gossypium | Nature Genetics | A |
| 2022 | Origin and chromatin remodeling of young X/Y sex chromosomes in catfish with sexual plasticity | National Science Review | A |
| 2022 | DNA demethylation affects imprinted gene expression in maize endosperm | Genome Biology | A |
| 2022 | DNA methylation underpins the epigenomic landscape regulating genome transcription in Arabidopsis | Genome Biology | A |
| 2022 | Dynamic 3D genome architecture of cotton fiber reveals subgenome-coordinated chromatin topology for 4-staged single-cell differentiation | Genome Biology | A |
| 2022 | Multi-omics analysis dissects the genetic architecture of seed coat content in Brassica napus | Genome Biology | A |
| 2022 | Comprehensive transcriptional variability analysis reveals gene networks regulating seed oil content of Brassica napus | Genome Biology | A |
| 2022 | A pan-Zea genome map for enhancing maize improvement | Genome Biology | A |
| 2022 | Hierarchical Accumulation of Histone Variant H2A.Z Regulates Transcriptional States and Histone Modifications in Early Mammalian Embryos | Advanced Science | A |
| 2022 | Heritability of tomato rhizobacteria resistant to Ralstonia | Microbiome | B |
| 2022 | Pervasive misannotation of microexons that are evolutionarily conserved and crucial for gene function in plants | Nature Communications | B |
| 2022 | A NAC-EXPANSIN module enhances maize kernel size by controlling nucellus elimination | Nature Communications | B |
| 2022 | ChromLoops: a comprehensive database for specific protein-mediated chromatin loops in diverse organisms | Nucleic Acids Research | B |
| 2022 | CottonMD: a multi-omics database for cotton biological study | Nucleic Acids Research | B |
| 2022 | Coordination of zygotic genome activation entry and exit by H3K4me3 and H3K27me3 in porcine early embryos | Genome Research | B |
| 2022 | DeepBSA: A deep-learning algorithm improves bulked segregant analysis for dissecting complex traits | Molecular Plant | B |
| 2022 | Starch phosphorylase 2 is essential for cellular carbohydrate partitioning in maize | Journal of Integrative Plant Biology | |
| 2022 | Constructing the maize inflorescence regulatory network by using efficient tsCUT&Tag assay | The Crop Journal | |
| 2022 | Precision Probiotics in Agroecosystems: Multiple Strategies of Native Soil Microbiotas for Conquering the Competitor Ralstonia solanacearum | Msystems | |
| 2022 | Molecular evidence for adaptive evolution of drought tolerance in wild | New Phytologist | |
| 2022 | eQTLs play critical roles in regulating gene expression and identifying key regulators in rice | Plant Biotechnology Journal | |
| 2022 | Genome‑wide association study identifies new loci for 1000‑seed weight in Brassica napus | Euphytica | |
| 2022 | Genome‑wide association study identifies candidate genes and favorable haplotypes for seed yield in Brassica napus | Molecular Breeding | |
| 2022 | Stomata at the crossroad of molecular interaction between biotic and abiotic stress responses in plants | Frontiers in plant science | |
| 2022 | Identification of a candidate gene underlying qHKW3, a QTL for hundred-kernel weight in maize | Theoretical and Applied Genetics | |
| 2022 | Sexually Dimorphic Gene Expression in X and Y Sperms Instructs Sexual Dimorphism of Embryonic Genome Activation in Yellow Catfish | Biology (Basel) | |
| 2023.06 | Genome editing of a rice CDP-DAG synthase confers multipathogen resistance | Nature | A+ |
| 2023.12 | Two teosintes made modern maize | Science | A+ |
| 2023.03 | A translatome-transcriptome multi-omics gene regulatory network reveals the complicated functional landscape of maize | Genome Biology | A |
| 2023.04 | Asymmetric gene expression and cell-type-specific regulatory networks in the root of bread wheat revealed by single-cell multiomics analysis | Genome Biology | A |
| 2023.08 | 3D organization of regulatory elements for transcriptional regulation in Arabidopsis | Genome Biology | A |
| 2023.08 | Single-cell resolution analysis reveals the preparation for reprogramming the fate of the plant stem cell niche in lateral meristems | Genome Biology | A |
| 2023.08 | A DNA adenine demethylase impairs PRC2-mediated repression of genes marked by a specific chromatin signature | Genome Biology | A |
| 2023.08 | Suppressing a phosphohydrolase of cytokinin nucleotide enhances grain yield in rice | Nature Genetics | A |
| 2023.10 | Regulatory controls of duplicated gene expression during fiber development in allotetraploid cotton | Nature Genetics | A |
| 2023.08 | Spontaneous movement of a retrotransposon generated genic dominant male sterility providing a useful tool for rice breeding | National Science Review | A |
| 2023.11 | Single-Cell Transcriptome Atlas and Regulatory Dynamics in Developing Cotton Anthers | Advanced Science | A |
| 2023.11 | Age-dependent seasonal growth cessation in Populus | PNAS | A |
| 2023.05 | Haplotype mapping of H3K27me3-associated chromatin interactions defines topological regulation of gene silencing in rice | Cell Reports | B |
| 2023.09 | DELLA-mediated gene repression is maintained by chromatin modification in rice | EMBO Journal | B |
| 2023.08 | Centromere plasticity with evolutionary conservation and divergence uncovered by wheat 10+ genomes | Molecular Biology and Evolution | B |
| 2023.02 | A minimal genome design to maximally guarantee fertile inter-subspecific hybrid rice | Molecular Plant | B |
| 2023.03 | Rice Gene Index: A comprehensive pan-genome database for comparative and functional genomics of Asian rice | Molecular Plant | B |
| 2023.03 | BnIR: A multi-omics database with various tools for Brassica napus research and breeding | Molecular Plant | B |
| 2023.08 | MaizeNetome: A multi-omics network database for functional genomics in maize | Molecular Plant | B |
| 2023.10 | Control of rice ratooning ability by a nucleoredoxin that inhibits histidine kinase dimerization to attenuate cytokinin signaling in axillary bud growth | Molecular Plant | B |
| 2023.08 | Integrated 3D Genome, Epigenome, and Transcriptome Analyses Reveal Transcriptional Coordination of Circadian Rhythm in Rice | Nucleic Acids Research | B |
| 2023.10 | SoyMD: a platform combining multi-omics data with various tools for soybean research and breeding | Nucleic Acids Research | B |
| 2023.10 | PMhub 1.0: a comprehensive plant metabolome database | Nucleic Acids Research | B |
| 2023.10 | MethMarkerDB: a comprehensive cancer DNA methylation biomarker database | Nucleic Acids Research | B |
| 2023.03 | Pan-genome inversion index reveals evolutionary insights into the subpopulation structure of Asian rice | Nature Communications | B |
| 2023.08 | QTG-Miner aids rapid dissection of the genetic base of tassel branch number in maize | Nature Communications | B |
| 2023.10 | Paternal DNA methylation is remodeled to maternal levels in rice zygote | Nature Communications | B |
| 2023.11 | Transcriptome-wide association analyses reveal the impact of regulatory variants on rice panicle architecture and causal gene regulatory networks | Nature Communications | B |
| 2023.06 | Serine protease NAL1 exerts pleiotropic functions through degradation of TOPLESS-related corepressor in rice | Nature Plants | B |
| 2023.11 | Chemical-tag-based semi-annotated metabolomics facilitates gene identification and specialized metabolic pathway elucidation in wheat | Plant Cell | B |
| 2023.04 | Identification of sex-linked codominant markers and development of a rapid LAMP-based genetic sex identification method in channel catfish (Ictalurus punctatus) | Aquaculture | |
| 2023.12 | Comparative Mitogenome Analyses Uncover Mitogenome Features and Phylogenetic Implications of the Reef Fish Family | Biology (Basel) | |
| 2023.09 | The chromosome-scale reference genome of mirid bugs (Adelphocoris suturalis) genome provides insights into omnivory, insecticide resistance, and survival adaptation | BMC Biology | |
| 2023.03 | RNA binding proteins are potential novel biomarkers of egg quality in yellow catfish | BMC Genomics | |
| 2023.03 | The genomic characteristics affect phenotypic diversity from the perspective of genetic improvement of economic traits | iScience | |
| 2023.03 | ZmHOX32 is related to photosynthesis and likely functions in plant architecture of maize | Frontiers in Plant Science | |
| 2023.02 | A heavy metal transporter gene ZmHMA3a promises safe agricultural production on cadmium-polluted arable land | Journal of Genetics and Genomics | |
| 2023.05 | Revealing the process of storage protein rebalancing in high quality protein maize by proteomic and transcriptomic | Journal of Integrative Agriculture | |
| 2023.02 | ArecaceaeMDB: a comprehensive multi-omics database for Arecaceae breeding and functional genomics studies | Plant Biotechnology Journal | |
| 2023.04 | Domains Rearranged Methylase 2 maintains DNA methylation at large DNA hypomethylated shores and long-range chromatin interactions in rice | Plant Biotechnology Journal | |
| 2023.04 | The amino acid residue E96 of Ghd8 is crucial for the formation of the flowering repression complex Ghd7‐Ghd8‐OsHAP5C in rice | Journal of Integrative Plant Biology | |
| 2023.06 | Deciphering genetic basis of developmental and agronomic traits by integrating high-throughput optical phenotyping and genome-wide association studies in wheat | Plant Biotechnology Journal | |
| 2023.05 | Complex genetic architecture underlying the plasticity of maize agronomic traits | Plant Communications | |
| 2023.03 | Ribosome profiling reveals the translational landscape and allele-specific translational efficiency in rice | Plant Communications | |
| 2023.07 | Histone H3 lysine 27 trimethylation suppresses jasmonate biosynthesis and signaling to affect male fertility under high temperature in cotton | Plant Communications | |
| 2023.09 | High-quality reference genome assemblies for two Australimusa bananas provide insights into genetic diversity of the Musaceae family and regulatory mechanisms of superior fiber properties | Plant Communications | |
| 2023.09 | Identification of propranolol and derivatives that are chemical inhibitors of phosphatidate phosphatase as potential broad-spectrum fungicides | Plant Communications | |
| 2023.09 | High-quality Gossypium hirsutum and Gossypium barbadense genome assemblies reveal the centromeric landscape and evolution | Plant Communications | |
| 2023.10 | PlantCFG: A comprehensive database with web tools for analyzing candidate flowering genes in multiple plants | Plant Communications | |
| 2023.10 | The CCT transcriptional activator Ghd2 constantly delays the heading date by upregulating CO3 in rice | Journal of Genetics and Genomics | |
| 2023.11 | Two haplotype-resolved genome assemblies for AAB allotriploid bananas provide insights into banana subgenome asymmetric evolution and Fusarium wilt control | Plant Communications | |
| 2023.11 | A complete reference genome for the soybean cv. Jack | Plant Communications | |
| 2023.10 | Hi-Tag: A Simple and Efficient Method for Identifying Protein-Mediated Long-Range Chromatin Interactions with Low Cell Numbers | Science China Life Sciences | |
| 2023.04 | iBP-seq: An efficient and low-cost multiplex targeted genotyping and epigenotyping system | The Crop Journal | |
| 2023.11 | High-quality assembly and methylome of a Tibetan wild tree peony genome (Paeonia ludlowii) reveal the evolution of giant genome architecture | Horticulture Research | |
| 2023.12 | Characterizing of structural variants based on graph-genotyping provides insights into pig domestication and local adaption | Journal of Genetics and Genomics | |
| 2023.12 | Genomic evidence for climate-linked diversity loss and increased vulnerability of wild barley spanning 28 years of climate warming | Science of The Total Environment | |
| 2024.01 | Synergistic interplay of redox homeostasis and polysaccharide synthesis promotes cotton fiber elongation | Plant Journal | |
| 2024.01 | Dynamic metabolic-QTL analyses provide novel biochemical insights into the kernel development and nutritional quality improvement in common wheat | Plant Communications | |
| 2024.01 | KLF4 facilitates chromatin accessibility remodeling in porcine early embryos | SCIENCE CHINA Life Sciences | |
| 2024.02 | Lysine acetylation of histone acetyltransferase adaptor protein ADA2 is a mechanism of metabolic control of chromatin modification in plants | Nature Plants | B |
| 2024.02 | Precise fine-turning of GhTFL1 by base editing tools defines ideal cotton plant architecture | Genome Biology | A |
| 2024.02 | Beyond pathways: accelerated flavonoids candidate identification and novel exploration of enzymatic properties using combined mapping populations of wheat | Plant Biotechnology Journal | |
| 2024.03 | Three near-complete genome assemblies reveal substantial centromere dynamics from diploid to tetraploid in Brachypodium genus | Genome Biology | A |
| 2024.03 | Constructing the metabolic network of wheat kernels based on structure-guided chemical modification and multi-omics data | Journal of Genetics and Genomics | |
| 2024.03 | Dissecting the molecular basis of spike traits by integrating gene regulatory network and genetic variation in wheat | Plant Communications | |
| 2024.03 | A double-stranded RNA binding protein enhances drought resistance via protein phase separation in rice | Nature Communications | B |
| 2024.04 | DNA methylation remodeling and the functional implication during male gametogenesis in rice | Genome Biology | A |
| 2024.04 | A comprehensive benchmark of graph-based genetic variant genotyping algorithms on plant genomes for creating an accurate ensemble pipeline | Genome Biology | A |
| 2024.05 | The Genetic Basis and Process of Inbreeding Depression in an Elite Hybrid Rice | Science China Life Sciences | |
| 2024.05 | A spatial transcriptome map of the developing maize ear | Nature Plants | B |
| 2024.06 | Progressive meristem and single-cell transcriptomes reveal the regulatory mechanisms underlying maize inflorescence development and sex differentiation | Molecular Plant | B |
| 2024.06 | Powerful QTL mapping and favorable allele mining in an all-in-one population: a case study of heading date | National Science Review | A |
| 2024.06 | LEUTX regulates porcine embryonic genome activation in somatic cell nuclear transfer embryos | Cell Reports | B |
| 2024.07 | Dissecting the Superior Drivers for the Simultaneous Improvement of Fiber Quality and Yield under Drought Stress Via Genome-Wide Artificial Introgressions of Gossypium barbadense into Gossypium hirsutum | Advanced Science | A |
| 2024.07 | Stress-induced nuclear translocation of ONAC023 improves drought and heat tolerance through multiple processes in rice | Nature Communications | B |
| 2024.08 | The OsSRO1c-OsDREB2B complex undergoes protein phase transition to enhance cold tolerance in rice | Molecular Plant | B |
| 2024.08 | aChIP is an efficient and sensitive ChIP-seq technique for economically important plant organs | Nature Plants | B |
| 2024.08 | Genetic regulatory perturbation of gene expression impacted by genomic introgression in fiber development of allotetraploid cotton | Advanced Science | A |
| 2024.09 | A dynamic regulome of shoot-apical-meristem-related homeobox transcription factors modulates plant architecture in maize | Genome Biology | A |
-
常用比对软件及fq文件处理工具 seqkit 等均已支持直接使用fq.gz压缩文件，原始fq.gz文件如无必要，不要解压；
-
下载完sra文件之后，直接转成fq.gz文件，然后删掉sra文件，如无必要切勿直接转成fq文件；
-
比对过程中不要直接输出sam文件，可以利用管道组合其他工具(samtools等)或软件自带参数输出 bam 文件。相比sam，bam可节省约60%的存储空间。部分软件（gatk、sentieon等）后续流程支持cram，因此bam可以继续转成 cram 格式，可节省约30%-50%的存储空间；相应的文档可参考 短序列比对输出bam ；
-
文章发表后原始fq已经上传ncbi等数据，如无必要可直接将原始数据删除，后面需要使用时下载比较方便；
-
需要长期存放的群体数据(
fq/bam/vcf)，可以使用 genozip 压缩，相比gzip，可以节省至少50%以上的存储空间，支持fq/bam/vcf等多种文件的压缩及多种压缩模式，使用参考 genozip ; -
大量的 vcf 建议使用 bgzip 压缩后再使用，同时也可以用tabix建索引，方便操作非常大的vcf文件，具体见 tabix操作VCF文件 ；
-
数据处理过程中如生成较大的文本文件，建议压缩成gz格式，linux命令和各编程语言均支持直接处理gz文件，参考 gzip文件读写 ;
-
一般文本文件压缩除使用gzip外，也可以使用 pigz(支持多线程) 来加速文件压缩解压；
-
集群存储不支持被删除数据恢复，重要的数据及时本地备份，避免误删；
-
大量小文件会影响集群性能，数据处理过程中生成的大量小文件需及时删除，如maker和Trinity的中间文件、软件源码等；
-
每个集群账号均有一定的存储配额，超过配额无法写入数据，如有大量数据在处理，建议定期使用 diskquota 命令查看存储使用情况，避免超过使用配额导致程序挂掉；
-
大量文件拷贝和跨服务器传输建议使用 rsync ，方便校验数据拷贝和传输是否完整，也可避免重复拷贝和传输；
-
从服务器上传或下载原始数据后，建议做 md5校验 ，避免各种原因导致的数据传输不完整，具体使用参考文件 文件完整性检查；
-
数据较大的数据库 (nr、nt、interproscan等) 建议使用集群已下载好的，不要自己下载；
-
用户组之间数据共享切不可简单地通过将home目录权限设置为 777 来实现，建议使用 ACL 精确地控制目录权限，以实现安全地与其它用户或用户组共享数据的目的，参考文档 数据共享;
GPU节点介绍和基本使用¶
本集群配备了2个GPU节点 gpu01、gpu02，每个节点2张GPU卡。这两个节点单独划分给了gpu队列，作业脚本中指定队列为gpu( #BSUB -q gpu )才能使用GPU节点。使用该队列需向管理员申请，每个用户最多使用5个CPU核。
显卡型号：gpu01 P100，gpu02 K40m
cuda版本:11.4，如需其它cuda版本，可使用module加载，如 module load cuda/10.2
深度学习库¶
python深度学习库集群没有预装，需要用户自行安装。这里以tensorflow为例来说明如何在集群上安装和使用深度学习库。
conda安装¶
需要先通过交互模式进入GPU节点 bsub -q gpu -Is bash
#创建conda环境，可以指定为python版本，如 conda create -n tf python=3.6
conda create -n tf
#激活环境
source activate tf
#安装TensorFlow，亦可指定版本，如 conda install tensorflow==1.14
conda install tensorflow
#测试安装效果
python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000, 1000])))"
pip安装¶
需要先通过交互模式进入GPU节点 bsub -q gpu -Is bash
# 创建虚拟环境，其中 `./tf_venv` 为虚拟环境目录，此后所有该虚拟环境的包都会安装在该目录下
python3 -m venv ./tf_venv
#激活环境
source ./tf_venv/bin/activate
#安装TensorFlow，可指定版本，如 pip install --upgrade tensorflow==1.15，1.15为TensorFlow 1.x的最终版本
pip install --upgrade tensorflow
#测试安装效果
python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000, 1000])))"
singularity镜像¶
NVIDIA官方自己构建的pytorch和TensorFlow的容器镜像，每个里面包含了cuda、显卡驱动以及cudnn，据说比自己装的速度要快，使用时singularity需要 --nv 选项。
集群上下载了部分NVIDIA的官方深度学习库镜像，目录为 /share/Singularity/nvidia
使用举例
需要先通过交互模式进入GPU节点 bsub -q gpu -Is bash
module load Singularity/3.7.3
singularity exec --nv /share/Singularity/nvidia/tensorflow_20.11-tf2-py3.sif python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000, 1000])))"
查看GPU资源使用¶
使用lsload -gpuload 命令可以查看所有GPU卡的资源使用情况。
$ lsload -gpuload
HOST_NAME gpuid gpu_model gpu_mode gpu_temp gpu_ecc gpu_ut gpu_mut gpu_mtotal gpu_mused gpu_pstate gpu_status gpu_error
gpu02 0 TeslaK40m 0.0 38C 0.0 0% 0% 11.9G 0M 8 ok -
1 TeslaK40m 0.0 39C 0.0 0% 0% 11.9G 0M 8 ok -
gpu01 0 TeslaP100_P 0.0 60C 0.0 93% 36% 15.8G 11.9G 0 ok -
1 TeslaP100_P 0.0 66C 0.0 99% 35% 15.8G 15.2G 0 ok -
FAQ¶
-
GPU卡显存不足报错，RuntimeError: CUDA error: out of memory
一般是显卡上已经有其它程序在运行占用了部分显存导致的，可手动指定程序使用其它空闲显卡来解决
import os os.environ['CUDA_VISIBLE_DEVICES'] = "0" #或1 -
gpu02上的k4m支持pytorch最高版本为1.2
micromamba create -n pytorch12 python==3.7 micromamba activate pytorch12 conda install pytorch=1.2 torchvision
速度测试¶
$ python pytorch_benchmark.py -h
usage: pytorch_benchmark.py [-h] [-i I] [-e E] [-bp BP] [-bs BS]
Used to check pytorch speed benchmark.
optional arguments:
-h, --help show this help message and exit
-i I Card id. Which cuda card do you want to test. default: 0
-e E Epoch. defaule: 500
-bp BP Use backward. defaule: True
-bs BS Batch size. defaule: 8
# -e 改变问题规模，同等规模，运行时间越短，速度越快
# -i 指定显卡id
$ python pytorch_benchmark.py -e 50 -i 0
Speed benchmark begin.
Speed benchmark finish.
Result
cuda_time: 56.0926796875
perf_counter_time: 56.09359596297145
no_num_error: True
deterministic: True
benchmark: False
platform: Linux-3.10.0-862.el7.x86_64-x86_64-with-centos-7.5.1804-Core
machine: x86_64
python_build: ('default', 'Oct 9 2018 10:31:47')
test_time: 2023-02-25T17:39:57.235769
'''
用于测试显卡速度
'''
import os
import torch
import torch.nn as nn
from torch.backends import cudnn
import argparse
import time
import datetime
import platform
os.environ["CUDA_VISIBLE_DEVICES"]="0"
def ConvBnAct(in_ch, out_ch, ker_sz, stride, pad, act=nn.Identity(), group=1, dilation=1):
return nn.Sequential(nn.Conv2d(in_ch, out_ch, ker_sz, stride, pad, groups=group, bias=False, dilation=dilation),
nn.GroupNorm(16, out_ch, eps=1e-8),
act)
def DeConvBnAct(in_ch, out_ch, ker_sz, stride, pad, act=nn.Identity(), group=1, dilation=1):
return nn.Sequential(nn.ConvTranspose2d(in_ch, out_ch, ker_sz, stride, pad, groups=group, bias=False, dilation=dilation),
nn.GroupNorm(16, out_ch, eps=1e-8),
act)
class RevSequential(nn.ModuleList):
'''
功能大部分与ModuleList重叠
'''
def __init__(self, modules=None):
super().__init__(modules)
def append(self, module):
assert hasattr(module, 'invert') and callable(module.invert)
super().append(module)
def extend(self, modules):
for m in modules:
self.append(m)
def forward(self, x1, x2):
y1, y2 = x1, x2
for m in self:
y1, y2 = m(y1, y2)
return y1, y2
def invert(self, y1, y2):
x1, x2 = y1, y2
for m in list(self)[::-1]:
x1, x2 = m.invert(x1, x2)
return x1, x2
class RevGroupBlock(RevSequential):
'''
当前只支持输入通道等于输出通道，并且不允许下采样
'''
def __init__(self, in_ch, out_ch, stride, act, block_type, blocks, **kwargs):
assert in_ch == out_ch
assert stride == 1
mods = []
for _ in range(blocks):
mods.append(block_type(in_ch=in_ch, out_ch=out_ch, stride=1, act=act, **kwargs))
# self.extend(mods)
super().__init__(mods)
class RevBlockC(nn.Module):
def __init__(self, in_ch, out_ch, stride, act, **kwargs):
super().__init__()
inter_ch = in_ch // 2
self.conv1 = ConvBnAct(in_ch, inter_ch, ker_sz=5, stride=1, pad=2, act=act)
self.conv2 = ConvBnAct(inter_ch, inter_ch, ker_sz=5, stride=1, pad=2, act=act, group=inter_ch)
self.conv3 = ConvBnAct(in_ch, in_ch, ker_sz=1, stride=1, pad=0, act=nn.Identity())
def func(self, x):
y1 = self.conv1(x)
y2 = self.conv2(y1)
y = torch.cat([y1, y2], dim=1)
y = self.conv3(y)
return y
def forward(self, x1, x2):
y = x1 + self.func(x2)
return x2, y
def invert(self, y1, y2):
x2, y = y1, y2
x1 = y - self.func(x2)
return x1, x2
def new_model():
act = nn.ELU()
rvb = RevGroupBlock(128, 128, 1, act, RevBlockC, 12).to(device)
rvb.eval()
return rvb
if __name__ == '__main__':
cudnn.benchmark = False
cudnn.deterministic = True
torch.set_grad_enabled(False)
parse = argparse.ArgumentParser(description='Used to check pytorch speed benchmark.')
parse.add_argument('-i', type=int, help='Card id. Which cuda card do you want to test. default: 0', default=0)
parse.add_argument('-e', type=int, help='Epoch. defaule: 500', default=500)
parse.add_argument('-bp', type=bool, help='Use backward. defaule: True', default=True)
parse.add_argument('-bs', type=int, help='Batch size. defaule: 8', default=8)
parse = parse.parse_args()
card_id = parse.i
epoch = parse.e
use_backward = parse.bp
batch_size = parse.bs
# 使用cpu测试理论上是永远不会报错的
device = 'cpu' if card_id == -1 else f'cuda:{card_id}'
device = torch.device(device)
assert epoch > 0
assert batch_size > 0
rvb = new_model()
is_no_num_error = True
torch.set_grad_enabled(use_backward)
start_record = torch.cuda.Event(enable_timing=True)
end_record = torch.cuda.Event(enable_timing=True)
print('Speed benchmark begin.')
start_time = time.perf_counter()
start_record.record()
for e in range(epoch):
e = e+1
a1 = torch.randn(batch_size, 128, 64, 64, device=device)
b1, b2 = rvb(a1, a1)
o_a1, o_a2 = rvb.invert(b1, b2)
if use_backward:
(o_a1.max() + o_a2.max()).backward()
with torch.no_grad():
max_diff_1 = torch.abs(o_a1 - o_a2).max().item()
max_diff_2 = torch.abs(a1 - o_a1).max().item()
# cur_time = time.perf_counter()
# cost_time = cur_time-start_time
# guess_full_cost_time = cost_time / e * epoch
#
# line = f'card_id: {card_id} elapsed/total: {e}/{epoch} time: {int(cost_time)}/{int(guess_full_cost_time)} md1: {max_diff_1:.8f} md2: {max_diff_2:.8f}'
# print(line)
if max_diff_1 > 1e-3 or max_diff_2 > 1e-3:
print(f'A large numerical error was found! diff_1: {max_diff_1:.8f} diff_2: {max_diff_2:.8f}')
is_no_num_error = False
end_record.record()
torch.cuda.synchronize()
end_time = time.perf_counter()
cuda_time = start_record.elapsed_time(end_record) / 1000
perf_counter_time = end_time - start_time
print('Speed benchmark finish.')
result = {
'cuda_time': cuda_time,
'perf_counter_time': perf_counter_time,
'no_num_error': is_no_num_error,
'deterministic': cudnn.deterministic,
'benchmark': cudnn.benchmark,
'platform': platform.platform(),
'machine': platform.machine(),
'python_build': platform.python_build(),
# 'device': 'cpu' if device == torch.device('cpu') else torch.cuda.get_device_name(device),
# 'cuda_version': '' if device == torch.device('cpu') else torch.cuda_version,
'test_time': datetime.datetime.now().isoformat(),
}
print('Result')
for k, v in result.items():
print(f'{k}: {v}')
参考资料：
扫描大文本文件并压缩¶
扫描当前账号下，大于100M的文本文件，fq、fa、sam、vcf、bed等，将扫描出来的文件列表存放于filestxt_username_211124文件中。
bsub -n 5 -J scan -o filecan.out -e filescan.err "ls -d ~/* |xargs -I[] -P 5 find [] -size +100M -type f -exec sh ASCII.sh {} \; >filetxt_username_211124"
sam文件建议排序并转成bam或cram存放，如果已有对应的bam文件，sam文件直接删除即可。
fq的rawdata和cleandata只保留其中一份即可。
bsub -n 5 -J gzip -o filegzip.out -e filesgzip.err "cat filetxt_username_211124|awk '{print \$2}'|xargs -P 5 -i sh gzip.sh {} > filegzip_username_211124 2>&1"
#!/bin/sh
na=$1
ty=`file -b $1|xargs echo -n|cut -d" " -f 1`
si=`du -sm $1`
if [ $ty == ASCII ];then
echo $si
fi
#!/bin/sh
file=$1
if [ -f $file ];then
echo $file
gzip $file
fi
扫描所有大文件¶
扫描当前账号下所有大于100M的文件，建议不再使用的文件或从服务器下载备份或删除。
bsub -n 5 -J scan -o filecan.out -e filescan.err "ls -d ~/* |xargs -I[] -P 5 find [] -size +100M -type f |xargs du -sm >fileall_username_211124"
bsub -n 5 -J scan -o filecan.out -e filescan.err "ls -d ~/* |xargs -I[] -P 5 find [] -mtime +90 -size +100M -type f |xargs du -sm >fileall_username_211124"
在拷贝完原始数据之后，应对拷贝后的数据进行完整性校验，以确认数据正常拷贝完成；部分场景中程序运行中断但没有报错日志，用户通过日志无法判断该程序是否正常跑完，通过校验文件完整性可以判断程序是否正常跑完。
不同的文件可以有不同的校验方式，其中利用md5值进行校验为通用的校验方式。
md5检验¶
MD5是报文摘要算法5（Message-Digest Algorithm 5）的缩写，该算法对任意长度的信息逐位进行计算，产生一个二进制长度为128位（十六进制长度就是32位）的“指纹”（或称“报文摘要”），不同的文件产生相同的报文摘要的可能性非常小。
利用这一特性可以校验文件的完整性，这也是最通用的文件校验方式，linux/mac/windows等各个平台通用。
生成md5校验文件。一般测序公司给的原始数据会生产md5校验文件。
# 同时对5个文件生成检验码，加速速度。文件越大，运行时间越长。
$ ls *gz|xargs -i -P 5 md5sum {} > md5.txt
$ cat md5.txt
d77344a98132c6d1469200d5ad466ea5 BYU21001_1.fastq.gz
568baf7a8b6ea8069026c86388905235 BYU21001_2.fastq.gz
$ md5sum -c md5.txt
BYU21001_1.fastq.gz: OK
BYU21001_2.fastq.gz: OK
gzip完整性检查¶
如果是gzip压缩后的文件，且没有原始的md5校验文件，可以使用这种方式进行快速校验文件是否完整。
# 同时检查5个文件，加速速度。文件越大，运行时间越长。没有任何输出则说明所有gzip文件是完整的。
$ ls|xargs -i -P 5 gzip -t {}
# 如果出现类似如下报错，则说明gzip文件不完整，需要重新拷贝。
$ gzip -t BYU21001_1_part1.fastq.gz
gzip: BYU21001_1_part1.fastq.gz: unexpected end of file
seqkit校验fq文件完整性¶
seqkit子命令stats可以统计fastq/fasta文件的reads数、碱基数、Q30等信息，如果文件有问题则会出现报错，利用这一特性也以校验fastq文件的完整性。
# -j 10 多线程加速，大量文件校验可加快速度
# -e skip error，加上这个选项可以一次跑完所有文件校验，否则遇到问题文件会报错停下
$ seqkit stats -j 10 tests/* -e
[WARN] tests/hairpin.fa.fai: fastx: invalid FASTA/Q format
[WARN] tests/hairpin.fa.seqkit.fai: fastx: invalid FASTA/Q format
[WARN] tests/miRNA.diff.gz: fastx: invalid FASTA/Q format
[WARN] tests/test.sh: fastx: invalid FASTA/Q format
file format type num_seqs sum_len min_len avg_len max_len
tests/contigs.fa FASTA DNA 9 54 2 6 10
tests/hairpin.fa FASTA RNA 28,645 2,949,871 39 103 2,354
tests/Illimina1.5.fq FASTQ DNA 1 100 100 100 100
tests/Illimina1.8.fq.gz FASTQ DNA 10,000 1,500,000 150 150 150
tests/hairpin.fa.gz FASTA RNA 28,645 2,949,871 39 103 2,354
tests/reads_1.fq.gz FASTQ DNA 2,500 567,516 226 227 229
tests/mature.fa.gz FASTA RNA 35,828 781,222 15 21.8 34
tests/reads_2.fq.gz FASTQ DNA 2,500 560,002 223 224 225
bam文件完整性检查¶
大量群体样本比对过程中，可能会因为各种原因导致作业中断，因此建议比对完成之后，检查所有bam文件的完整性，将bam文件不完整的样本重新比对。cram文件也同样适用。
大量bam转cram之后、大量bam保存备份之前，建议都跑一遍完整性检查。
for i in *.bam ;do (samtools quickcheck $i && echo "ok" || echo $i error);done
集群normal、high以及smp队列本地均为SSD，IO性能较好，如果作业有大量的小文件读写，此时使用计算节点本地SSD进行文件读写会有较大的速度提升。
Warning
由于本地盘较小(normalhigh为480G，smp为1.4T)，因此不可拷入或生成大型文件。使用LSF选项-R "rusage[tmp=10G]"来指定预计使用的本地存储大小，以免出现/tmp目录写满或/tmp空间不够导致作业挂掉。
使用方式如下，输入和输出文件分别为inputfile和outputfile，两个文件大小一起不超过5G。
#BSUB -J program
#BSUB -n 10
#BSUB -R "rusage[tmp=5G]"
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
# 生成随机字符串，以免与其它目录重复
tmpn=`mktemp -u program_XXXXX`
# 在/tmp/中新建运行目录，并进入该目录
tmpd="/tmp/${tmpn}"
mkdir ${tmpd}
# 打印节点名称和新建目录名称，以方便出错处理
hostname
echo ${tmpd}
# 将输入文件拷到节点本地存储目录
cp /path/inputfile ${tmpd}
# 运行程序
program ${tmpd}/inputfile ${tmpd}/outputfile
# 程序运行结束后，将生成文件拷回共享存储目录
mv ${tmpd}/outputfile .
# 清理临时文件
rm -r ${tmpd} && echo "program done"
# 如果因程序出错、节点宕机等原因导致作业日志没有输出program done的提示，此时节点本地数据很可能未删除，需要另外提作业到该节点将本地数据删除。
# 节点和目录为23和24行的输出，可以在作业日志中获取。
Warning
数据下载不需要提交lsf作业，直接在登录节点运行wget、prefetch等下载程序即可。
目前集群只有3台登录节点联网(2台校内登录，1台校外登录)、并具有独立IP，每个节点理论最高网速为100MB/s。计算节点禁止联网，因此数据下载仅能在登录节点进行，数据上传到ncbi同理。
有大批量数据下载时，建议在3台节点上分别跑一部分下载任务，方可达到最高的下载速度。
如果下载时间较长，建议开个screen进行操作，使用wget时加上断点续传选项。screen 和 wget 使用见 Linux基础。
大量数据下载时，一个用户在登录节点上同时运行不超过3个下载任务，以prefetch为例：
$ screen -S prefetch
$ cat id_list
ID1
ID2
ID3
ID4
ID5
ID6
ID7
ID8
ID9
ID10
$ cat id_list|xargr -i -P 3 prefetch {}
kingfisher¶
使用kingfisher可以快速从多个源下载公共测序数据 (EBI ENA, NCBI SRA, Amazon AWS 和 Google Cloud )，用户提供一个或多个"run accession number"，如
ERR1739691，或 "BioProject accession number"，如PRJNA621514`` 或SRP260223`。
SRA数据下载可以使用kingfisher代替prefetch、ascp等工具，具体使用见 kingfisher。
ascp¶
$ module load aspera-connect/3.9.9.177872
$ ascp -i $ASPERAKEY -k 1 -T -l1000m anonftp@ftp.ncbi.nih.gov:/blast/db/FASTA/nr.gz ./
nr 100% 186GB 19.4Mb/s 7:37:51
Completed: 195328267K bytes transferred in 27472 seconds
(58245K bits/sec), in 1 file.
EdgeTurbo¶
CNCB 数据下载
https://cloud.tencent.com/developer/article/2228281
百度云¶
集群上可以使用命令行工具 BaiduPCS-Go 进行百度云文件的上传和下载，具体使用见 BaiduPCS-Go。
Ended: 集群相关
应用软件 ↵
集群公共平台软件调用主要有2种方式
module¶
module使用之前需要配置，见 Module使用
目前module中包含几百个常用软件及常用库文件，另外也可以使用module调用常用生信数据库，见 NR等常用生信数据库使用。
module av 查看所有软件
module av a 查看软件名以a开头的软件
module av A 查看软件名以A开头的软件
modul load augustus/3.3.3 载入这个版本的augustus
因为有的软件名称首字母大小写不确定，搜的时候可以都大小写都可尝试。
singularity¶
singularity是专为HPC环境开发的一款容器，核心优点有3个：不需要常驻服务，使用时消耗的资源非常少；不需要特殊权限，普通用户就可以使用，多用户环境中安全性有保障；可直接使用docker镜像。
集群上下载了部分安装比较复杂的软件，放在/share/Singularity/下，可以直接调用，部分镜像列表见 集群singularity镜像列表。
具体的使用方式见 集群文档 Singularity使用。
说明¶
- 各种脚本、jar包、编译好的二进制可执行包, e.g. NCBI直接下载编译好的blast
- 采用C/C++等编写, 只有源码，按文档要求编译, e.g. 下载R源码, 自己编译安装
- 系统自带的包管理器（需root权限）
- bioconda, 生信软件包管理器
- docker、singularity容器镜像
- Python、perl、R等的模块或包
环境变量¶
PATH, 自动搜索安装的可执行文件
LD_LIBRARY_PATH，动态链接库搜索位置
PERL5LIB，perl模块位置
PYTHONPATH，python模块位置
export PATH=/opt/bin/:$PATH #或写入~/.bashrc文件
脚本软件¶
采用Perl/Python等解释型语言编写, 下载后有解释器即可运行。
用法：系统安装对应的解释器, 添加x权限
优点：下载就可以直接用, 修改方便
缺点：可能需要很多依赖, 性能差
$ mv N50.pl ~/opt/bin/
$ export PATH="$PATH:$HOME/opt/bin/" #或写入~/.bashrc文件
jar包¶
采用java或类java语言编写, 开发人员已编译打包好, 下载可用。
用法：系统安装java运行环境JDK, java -jar package.jar
优点：下载就可以直接用, 跨平台
缺点： 相比C/C++性能较差, 对内存有一定要求
$ cd ~/opt
$ wget http://www.usadellab.org/cms/uploads/supplementary/Trimmomatic/Trimmomatic-0.39.zip
$ unzip Trimmomatic-0.39.zip
$ java -jar trimmomatic-0.36.jar PE \
-phred33 input_forward.fq.gz input_reverse.fq.gz \
output_forward_paired.fq.gz output_forward_unpaired.fq.gz \
output_reverse_paired.fq.gz output_reverse_unpaired.fq.gz \
ILLUMINACLIP:/usr/local/src/Trimmomatic/Trimmomatic-0.36/adapters/TruSeq3-PE.fa:2:30:10 \
LEADING:3 TRAILING:3 SLIDINGWINDOW:4:15 HEADCROP:8 MINLEN:36
二进制可执行包¶
采用C/C++等编译语言编写, 开发人员已编译好, 下载可用
用法：下载系统对应版本的二进制软件, 添加x权限
优点：下载就可以直接用, 不依赖编译器
缺点：没法看到源码;不能根据需要预编译;依赖预编译系统的底层库; 跨平台性差
$ cd ~/opt
$ mkdir sratoolkit && cd sratoolkit
$ wget http://ftp-trace.ncbi.nlm.nih.gov/sra/sdk/2.6.3/sratoolkit.2.6.3-centos_linux64.tar.gz
$ tar zxvf sratoolkit.2.6.3-centos_linux64.tar.gz
$ chmod +x ~/opt/sratoolkit/sratoolkit.2.6.3-centos_linux64/bin/*
$ ~/opt/sratoolkit/sratoolkit.2.6.3-centos_linux64/bin/fastdump -h
源码编译¶
采用C/C++等编译语言编写, 开发人员提供源代码以及安装文档, 用户根据平台自行编译
用法： 安装好编译器以及依赖库，按文档要求编译
优点： 可以指定预编译选项；使用自己系统的依赖库
缺点： 对新手不友好; 很多软件编译步骤复杂; 自己手动解决依赖;
常用编译器¶
GCC（GNU Compiler Collection，GNU编译器套件）
- 由GNU开发的编程语言编译器，是采用GPL及LGPL协议所发行的自由软件，是Linux及类Unix标准编译器，被认为是跨平台编译器的事实标准
- GCC可处理C、C++、Fortran、Pascal、Objective-C、Java等其他语言
Intel Composer XE (ntel 编译器)
- Intel编译器是Intel公司发布的x86平台（IA32/INTEL64/IA64/MIC）编译器产品，支持C/C++/Fortran编程语言
- Intel编译器针对Intel处理器进行了专门优化，性能优异，在其它x86处理器平台上表现同样出色
LLVM (Low Level Virtual Machine，底层虚拟机)
- Apple资助开发的编译器，支持C、C++、Objective-C和Objective-C++
- 编译速度快；占用内存小；模块化设计，易与IDE集成及其他用途重用；诊断信息可读性强，有利于调试
源代码后缀规范¶
在Linux系统中，可执行文件没有统一的后缀，系统从文件的属性来区分。而源代码、目标文件等后缀名最好保持统一的规范，便于识别区分。
| 文件类型 | 后缀名 |
|---|---|
| C source | .c |
| C++ source | .C, .cc, .cpp, .cxx, .c++ |
| Fortran77 source | .f, .for |
| Fortran90/95 source | .f90 |
| 汇编source | .s |
| 目标文件 | .o |
| 头文件 | .h |
| Fortran90/95模块文件 | .mod |
| 动态链接库 | .so |
| 静态链接库 | .a |
c语言编译¶
# 编译时，指定生成可执行文件的路径或文件名（-o参数）
$ gcc -o hello hello.c
$ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV),
for GNU/Linux 2.6.4, dynamically linked (uses shared libs), not stripped
$ gcc -o /home/test/hello hello.c
#include <stdio.h>
int main()
{
printf("Hello world.\n");
}
#多个源文件同时编译,生成可执行文件sum
$ gcc -o sum main.c function.c
# 源文件分别编译，再将目标文件连接成可执行文件
$ gcc -c main.c
$ gcc -c function.c
$ gcc -o sum main.o function.o
#include <stdio.h>
int main()
{
int sum=0,r,i;
for(i=1;i<=10;i++)
{
r=function(i);
sum=sum+r;
}
printf("sum is %d\n",sum);
}
int function(int x)
{
int result;
result=x*x; return(result);
}
Makefile¶
源文件数量非常多、存放在不同目录下、相互之间有各种依赖关系以及先后顺序关系时，需要使用Makefile进行管理。Makefile定义了一系列的规则来指定哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作。
- 软件程序的管理工具
- 定义规则，实现自动化编译
- 处理源代码、目标文件、头文件、库文件等依赖关系
- 根据规则和依赖关系，结合时间戳实现精细化控制
make命令执行 Makefile 中的定义的编译流程。make命令默认读取当前目录 Makefile 或 makefile 文件，也可以用 -f 参数指定 Makefile 文件
configure¶
autotool生成configure文件, 有程序不提供configure, 提供autogen.sh
Makefile.am和makefile.in生成Makefile
大型开源程序通常使用configure脚本生成Makefile，Configure脚本作用：
- 检查编译环境 （数据类型长度(int)，操作系统，CPU平台）
- 检查依赖头文件及库文件
- 设置安装路径
- 设置编译器及编译参数
configure → make → make install
Configure常用参数：
- --prefix=/opt/software 指定安装路径
- -h 查看configure帮助，configure支持选项
- CC=gcc/icc 设置c语言编译器
- CFLAGS=-O2 –funrool- c编译器参数
- CXX=g++/icpc 设置c++编译器
- CXXFLAGS=-O2 c++编译器参数
- FC=gfortran/ifort 设置fortran编译器
- FCFLAGS=-O2 fortran编译器参数
- --with-XXX 编译时使用XXX包
- --without-XXX 编译时不使用XXX包
- --enable-XXX 启用XXX特性
- --disable-XXX 不启用XXX特性
编译安装samtools
$ wget https://github.com/samtools/samtools/releases/download/1.3.1/samtools-1.3.1.tar.bz2
$ tar xvfj samtools-1.3.1.tar.bz2
$ cd samtools-1.3.1
$ ./configure –prefix=/home/username/opt/samtools/1.3.1
$ make
$ make install
$ echo "export PATH=/home/username/opt/samtools/1.3.1:$PATH" >> ~/.bashrc
cmake¶
cmake：跨平台编译工具，生成makefile。其配置文件为CMakeLists.txt。
cmake → make → make install
cmake常用参数：
- -DCMAKE_INSTALL_PREFIX=/opt/software 指定安装路径
- -DCMAKE_C_COMPILER=/opt/gcc/bin/gcc 设置c语言编译器
- -DCMAKE_CXX_FLAGS ="-O2 –funrool-" c编译器参数
- -DCMAKE_CXX_COMPILER = =/opt/gcc/bin/gcc 设置c++编译器
也可以使用CC CXX 指定gcc
$ export CC=$HOME/opt/gcc/9.4/bin/gcc
$ export CXX=$HOME/opt/gcc/9.4/bin/g++
$ tar –xf gromacs-5.1.4.tar.gz
$ cd gromacs-5.1.5
$ mkdir build && cd build
$ cmake ..
$ make –j 20
$ make install
系统包管理器¶
用法：不同的操作系统用法不大一样 yum: RedHat, CentOS, Fedora; apt-get: Ubuntu, Debian; brew:MacOS
优点：简单, 一键搞定；包管理器自己解决软件依赖
缺点：生物信息软件大部分不在包管理器中, 用于安装底层依赖库；需要root权限
# ubuntu
sudo apt-get -y install libcurl4-gnutls-dev
sudo apt-get -y install libxml2-dev
sudo apt-get -y install libssl-dev
sudo apt-get -y install libmariadb-client-lgpl-dev
# centos
$ yum search openssl
$ yum install -y openssl-devel
conda¶
Anaconda 用于科学计算Python发行版，使用conda 管理包和环境。conda 不仅管理安装python包，还可以是各种其他的应用软件。
优点：不需要root权限；自行解决依赖关系；一键安装, 不需要配置环境
缺点：有些软件conda中没有, 需要自己手动安装；环境混乱、版本管理麻烦
Note
conda 安装软件较慢，可以使用mamba代替，使用方式与conda一直。其配置使用见集群文档 mamba。
配置¶
# 第一步：下载miniconda3
$ wget https://nanomirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-$(uname -m).sh
# 第二步：安装miniconda3
$ bash Miniconda3-latest-Linux-x86_64.sh -b -p $HOME/miniconda3
# 第三步：将miniconda3保存到环境路径并启用
$ echo "export PATH=$PREFIX/bin:"'$PATH' >> ~/.bashrc
$ source ~/.bashrc
#第四步：基本配置bioconda，添加清华源镜像
$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda
$ conda config --set show_channel_urls yes
管理软件包¶
# 搜索需要安装的软件包，获取其完成名字
conda search <package name>
# 安装软件包
conda install <package name>
# 安装特定版本的软件包
conda install <package name>=版本号
# 更新软件包
conda update <package name>
# 移除软件包
conda remove <package name>
# 安装R,及80多个常用的数据分析包, 包括idplyr, shiny, ggplot2, tidyr, caret 和 nnet
conda install -c r r-essentials
管理环境¶
通过conda环境，可以实现软件版本管理、流程环境管理。
# 创建名为env_name的新环境，并在该环境下安装名为 package_name 的包
$ conda create -n env_name package_name
# 可以指定新环境的版本号，例如：创建python2环境，python版本为2.7，同时还安装了numpy pandas包
$ conda create -n python2 python=2 numpy pandas
# 激活 python2环境，通过python -V可以看到是python2.7
$ conda activate python2
# python2 环境中安装相关包
$ conda install pandas
# 退出 python2 环境
$ conda deactivate
# 删除环境
$ conda remove -n env_name --all
# 查看当前存在的虚拟环境
$ conda env list
$ conda info -e
直接使用bioconda内的软件¶
部分编译比较复杂的软件，可以在bioconda内找到该软件，然后点击"Files"，在里面下载编译好的软件，执行时如果有库缺失、GCC版本不够的报错，可以载入相应的库和GCC，此方式可以快速安装复杂软件。
docker¶
操作系统之上的虚拟层，提供独立于系统的软件环境；兴起于互联网行业，便于项目开发和交付部署，提高硬件资源利用率。
优点： 简单，对于复杂软件可以一键安装；无需安装任何依赖
缺点： 无法与作业调度软件结合使用；权限要求较高，多用户使用有风险
docker pull quay.io/qiime2/core:2021.8
singularity¶
HPC集群的容器工具，直接使用docker镜像。使用singularity搭建分析流程，可以在所有机器上运行。
优点： 简单；无需安装任何依赖；安全；可结合作业调度系统；高性能；适应性广
缺点： 软件较少；文件比较大
# 从给定的URL下载容器镜像，常用的有URL有Docker Hub(docker://user/image:tag) 和 Singularity Hub(shub://user/image:tag)
$ singularity pull tensorflow.sif docker://tensorflow/tensorflow:latest
# 在容器中执行某个命令
$ singularity exec /share/Singularity/saige_0.35.8.2.sif
# 进入容器
$ singularity shell /share/Singularity/ubuntu.sif
R包安装¶
# 从官方源安装，最常见方式
$ >install.packages("ggplot2")
# 同时安装多个包
$ >install.packages(c("broom", "clusterProfiler", "dorothea", "DOSE", "dplyr"))
# 指定安装源和安装路径
$ >install.packages("ggplot2", repos = "https://mirrors.ustc.edu.cn/CRAN/",lib="~/opt/Rlib")
# 使用Rscript，方便安装包报错时试错，不用每次进入R交互界面，然后又退出
$ Rscript -e 'install.packages(c("RcppArmadillo"), repos="https://mirrors.ustc.edu.cn/CRAN/")'
# 源码安装
$ R CMD INSTALL /path/rpackage.tar.gz
# 或
$ >install.packages("/path/rpackage.tar.gz", repos = NULL, type = "source")
# 安装指定版本的R包
$ >require(devtools)
$ >install_version("limma", version = "1.8.0")
# 或
$ >install.packages("https://cran.r-project.org/src/contrib/Archive/limma/limma_1.8.10.tar.gz", repos=NULL, type="source")
# bioconductor包安装
$ >install.packages("BiocManager")
$ >BiocManager::install("clusterProfiler")
# 指定安装位置和源
$ >options(BioC_mirror="https://mirrors.tuna.tsinghua.edu.cn/bioconductor")
$ >.libPaths(c("~/R/4.2/", .libPaths()))
$ >BiocManager::install("clusterProfiler")
# 也可以使用Rscript
$ Rscript -e 'BiocManager::install("clusterProfiler")'
# 测试包是否正常安装
$ >library(package)
# 其它包常见操作
# 卸载包
$ >remove.packages("package")
# 更新包
$ >update.packages("package")
# 查看R包安装位置
$ >.libPaths()
# 查看已安装包
$ >installed.packages()
# 查看包版本
$ >packageVersion("package")
# 查看包安装位置
$ >find.package("package")
$ >install.packages("pak")
$ >library(pak)
# 安装CRAN中的包
$ >pak:pak("ggplot2")
# 指定安装路径
$ >pak:pak("ggplot2", lib="PATH")
# 安装Bioconductor中的包
$ >pak::pak("clusterProfiler")
# 安装github上的包
$ >pak::pak("lchiffon/REmap")
# 使用URL
$ >pak::pkg("url::https://cran.r-project.org/src/contrib/Archive/tibble/tibble_3.1.7.tar.gz")
# 本地安装
# shell
$ wget https://cytotrace.stanford.edu/CytoTRACE_0.3.3.tar.gz
# 解压后为CytoTRACE
$ tar -xf CytoTRACE_0.3.3.tar.gz
# R
$ >pak::local_install("CytoTRACE")
# 或
$ >pkg_install("local::./CytoTRACE_0.3.3.tar.gz")
# 安装多个包
$ >pak::pkg(c("BiocNeighbors", "ComplexHeatmap", "circlize", "NMF"))
# 更新包
$ >pak::pkg_install("tibble")
# 更新包的所有依赖，默认不更新依赖
$ >pak::pkg("tibble", upgrade = TRUE)
# 重装包
$ >pak::pkg_install("tibble?reinstall")
# 卸载包
$ >pkg_remove("tibble")
perl包安装¶
# CPAN 模块自动安装
# 如果使用系统的cpan，则需要root权限，因此普通用户建议使用cpanm代替
$ cpan -i Bio::SeqIO
# cpanm 推荐
$ cpanm --mirror http://mirrors.163.com/cpan --mirror-only Bio::SeqIO
# 源码安装
$ tar xvzf BioPerl-1.7.5.tar.gz
$ cd BioPerl-1.7.5
$ perl Makefile.PL (PREFIX=/home/opt/perl_modules)
$ make && make install
# 添加环境变量
$ export PERL5LIB=$PERL5LIB:/home/opt/perl_modules/lib/site_perl #或者把该行内容添加到 ~/.bashrc
# 测试perl模块安装正常
$ perl -MBio::SeqIO -e1 或 perldoc Bio::SeqIO
#如下报错，可能是perl版本冲突导致，即安装perl包的版本和使用perl包的版本不一致，建议将~/.bashrc perl相关的部分注释，然后再测试
perl: symbol lookup error: perl5/lib/perl5/x86_64-linux-thread-multi/auto/Cwd/Cwd.so: undefined symbol
python包安装¶
# conda
$ conda install biopython
# pip
$ pip install --prefix=/home/opt/ppython_modules/ biopython 或 pip install --user biopython
# 使用国内源
$ pip install --prefix=/home/opt/ppython_modules/ -i https://pypi.tuna.tsinghua.edu.cn/simple biopython
# requirements.txt文件
$ pip install -r requirements.txt --prefix=/home/opt/ppython_modules/
# 源码
$ git clone https://github.com/madmaze/pytesseract.git
$ python setup.py install --prefix=/home/opt/ppython_modules或 pip install . --prefix=$PREFIX_PATH
# 测试python模块安装正常
$ python -c "import Bio"
# 添加环境变量
$ export PYTHONPATH=$PREFIX_PATH:/home/opt/python_modules/lib/python2.7/site-packages/ #或者加到 ~/.bashrc
centos7中高版本的python，使用pip安装包时可能出现报错 pip is configured with locations that require TLS/SSL, however the ssl module in Python is not available，最快捷的解决办法为：
$ pip3 install pymysql -i http://mirrors.aliyun.com/pypi/simple --trusted-host mirrors.aliyun.com
注意事项¶
-
生信绝大部分软件都可以使用普通用户安装，不需要root权限。普通用户无法在集群上使用yum apt等安装软件；
-
软件安装过程中出现libxx库文件缺失的问题，一般都可以找到相应的源码，编译安装，设置环境变量即可；
-
避免使用conda一键安装软件，时间长了会导致各种环境问题，直至所有软件不可用，推到重来；
-
软件安装或使用过程中出现问题，最好将~/.bashrc中无关部分都临时注释掉，避免其它软件的影响；
-
使用软件前看一下集群公共软件库，尽量使用公共软件，一个软件一个环境，出现问题比较好排查；
生信数据库¶
集群上下载了一些数据库，包括NR、NT、Pfam、Rfam、swissprot等，路径为/share/database/，如果还有其它文件比较大的数据库需要下载的，请联系管理员。
配置好module后，使用module av 可以查看集群下载的公共数据库(module av 输出文字的最下方)，module load 载入相应的数据库后可以看到相应的使用提示，根据提示使用公共数据库即可。
$ module av
nr/20141218 nr/20190625-diamond nt/20171030 Pfam/31.0 Rfam/14.0 uniref50/201705
nr/20170605 nr/20201013 nt/20190802 Pfam/32.0 Rfam/14.1 uniref90/201705
nr/20171030 nr/20201013-diamond nt/20201013 Rfam/12.3 swissprot/20170604
nr/20190625 nt/20170605 Pfam/30.0 Rfam/13.0 uniref100/201705
$ module load nr/20201013
To use NR database, please just reference variable $NR, for example: blastp -query example.fa -db $NR -out example
$ blastp -query example.fa -db $NR -out example
bam文件格式为sam文件格式的二进制形式，但bam文件大小只有sam文件的⅓左右，同时对于大部分分析流程，使用bam文件即可满足需求，因此为节省存储空间，如无特殊需求建议在比对阶段直接输出bam或排序后的bam文件，如果下游分析软件支持可进一步压缩成cram格式，另外大部分比对软件可直接使用fq.gz文件进行比对，因此无需解压fq.gz。以下是各常用比对软件直接输出bam的方式：
fq->bam¶
BWA¶
直接输出bam文件
bwa mem -t 8 genome.fa read1.fq.gz read2.fq.gz | samtools view -bS > output.bam
输出排序后的bam文件
bwa mem -t 8 genome.fa read1.fq.gz read2.fq.gz | samtools sort -@8 -o output_sorted.bam
sentieon-bwa¶
输出排序后的bam
sentieon bwa mem -R "@RG\tID:ID\tSM:SM\tPL:PL" -t 8 -K 10000000 genome.fa read1.fq.gz read2.fq.gz | sentieon util sort -r genome.fa -o output_sorted.bam -t 8 --sam2bam -i -
hisat2¶
直接输出bam文件
hisat2 -p 8 -x genome.fa -1 read1.fq.gz -2 read2.fq.gz | samtools view -bS > output.bam
hisat2 -p 8 -x genome.fa -1 read1.fq.gz -2 read2.fq.gz | samtools sort -@8 -o output_sorted.bam
bowtie2¶
直接输出bam文件
bowtie2 -p 8 -x genome.fa -1 read1.fq.gz -2 read2.fq.gz | samtools view -bS > output.bam
bowtie2 -p 8 -x genome.fa -1 read1.fq.gz -2 read2.fq.gz | samtools sort -@8 -o output_sorted.bam
tophat2¶
软件直接输出排序后的bam文件
STAR¶
有参数可以直接输出bam文件
--outSAMtype BAM Unsorted
--outSAMtype BAM SortedByCoordinate
--outSAMtype BAM Unsorted SortedByCoordinate
sentieon-STAR¶
输出排序后的bam
sentieon STAR --runThreadN NUMBER_THREADS --genomeDir genome.fa \
--readFilesIn read1.fq.gz read2.fq.gz --readFilesCommand "zcat" \
--outStd BAM_Unsorted --outSAMtype BAM Unsorted --outBAMcompression 0 \
--outSAMattrRGline ID:GROUP_NAME SM:SAMPLE_NAME PL:PLATFORM \
--twopassMode Basic --twopass1readsN -1 --sjdbOverhang READ_LENGTH_MINUS_1 \
| sentieon util sort -r genome.fa -o output_sorted.bam -t 8 -i -
bam转cram¶
长期存放的bam文件，可以转成cram存放，可节省大约⅓-½的磁盘空间
# bam转cram
samtools view -C -T genome.fasta out.bam > out.cram
# cram转bam
samtools view -b -h out.cram > out.bam
bam文件完整性检查¶
大量群体样本比对过程中，可能会因为各种原因导致作业中断，因此建议比对完成之后，检查所有bam文件的完整性，将bam文件不完整的样本重新比对。cram文件也同样适用。
大量bam转cram之后、大量bam保存备份之前，建议都跑一遍完整性检查。
for i in *.bam ;do (samtools quickcheck $i && echo "ok" || echo $i error);done
目前各流程的常规分析中，原始数据比对通常是比较占用存储空间的部分，这里以常用软件为例，给定一个原始数据比对、比对结果存放的参考建议。
大规模比对和格式转换需要较高的存储带宽，建议在normal队列上运行。
原始数据¶
大部分比对软件可直接使用fq.gz文件进行比对，因此无需解压fq.gz。原始数据从ncbi上下载的，sra文件转成fq.gz之后，需及时删除sra文件。
部分不能直接使用fq.gz的程序，可以尝试使用类似下面的变通方式。
#程序输出转gz
program file | gzip > out.gz
#gz文件为输入
program < gzip -dc file.gz
#综合
blastn -query <(gzip -dc ZS97_cds_10^6.fa.gz) -db ./MH63_cds -outfmt 6 |gzip > ZS97_cds_10000.gz
质控¶
fastp可以在完成质控的同时输出质控报告，运行速度非常快。如无特殊需求，质控建议使用fastp。多个样本跑完之后可以使用multiqc整合所有样本的质控报告。
module load fastp
fastp -w 8 -i 00-raw-data/sample.R1.fq.gz -o 01-clean-data/sample.R1.fq.gz -I 00-raw-data/sample.R2.fq.gz -O 01-clean-data/sample.R2.fq.gz
比对¶
对于大部分分析，只需要保留bam文件即可，因此可以在比对阶段直接输出bam或排序后的bam文件，以下是各常用比对软件直接输出bam的方式：
BWA¶
输出排序后的bam文件
module load BWA
module load SAMtools
bwa mem -t 8 genome.fa 01-clean-data/sample.R1.fq.gz 01-clean-data/sample.R2.fq.gz | samtools sort -@8 -o 02-read-align/sample_sorted.bam
sentieon-bwa¶
输出排序后的bam。绝大多数场景下，可以使用sentieon bwa代替bwa，速度有显著提升。
module load sentieon
sentieon bwa mem -R "@RG\tID:sample\tSM:sample\tPL:illumina" -t 8 -K 10000000 genome.fa 01-clean-data/sample.R1.fq.gz 01-clean-data/sample.R2.fq.gz | sentieon util sort -r genome.fa -o 02-read-align/sample_sorted.bam -t 8 --sam2bam -i -
hisat2¶
输出排序后的bam文件
module load hisat2
hisat2 -p 8 -x genome.fa -1 01-clean-data/sample.R1.fq.gz -2 01-clean-data/sample.R2.fq.gz | samtools sort -@8 -o 02-read-align/sample_sorted.bam
bowtie2¶
输出排序后的bam文件
module load Bowtie2
module load SAMtools
bowtie2 -p 8 -x genome.fa -1 01-clean-data/sample.R1.fq.gz -2 01-clean-data/sample.R2.fq.gz | samtools sort -@8 -o 02-read-align/sample_sorted.bam
tophat2¶
比对输出bam后，使用samtool进行排序，之后删除未排序的bam
module load Tophat
module load SAMtools
tophat2 -p 8 -o 02-read-align/sample 01-clean-data/sample.R1.fq.gz 01-clean-data/sample.R2.fq.gz
samtools sort -@8 -o 02-read-align/sample/accepted_hits_sorted.bam 02-read-align/sample/accepted_hits.bam
rm 02-read-align/sample/accepted_hits.bam
STAR¶
指定参数输出排序后的bam。STAR内存使用较多，建议在high队列运行。
module load STAR
STAR --runThreadN 8 --genomeDir genome_dir/ --outSAMtype BAM SortedByCoordinate --outFileNamePrefix 01-clean-data/sample --readFilesCommand gunzip -c --readFilesIn 01-clean-data/sample.R1.fq.gz 01-clean-data/sample.R2.fq.gz
去重¶
部分流程比对完成之后需要去重，推荐使用sambamba。
module load sambamba
sambamba markdup -t 8 -p --overflow-list-size 600000 --tmpdir='./tmp' -r 02-read-align/sample_sorted.bam 02-read-align/sample_sorted_rmd.bam
RNA-seq 一般不去重
ChIP-seq 一般要去重
Call SNP 一般要去重
RRBS 一般不去重
Targeted-seq （Amplicon seqencing） 一般不去重
WGBS 一般要去重
ATAC-seq 一般要去重
bam文件完整性检查¶
大量群体样本比对过程中，可能会因为各种原因导致作业中断，因此建议比对完成之后，检查所有bam文件的完整性，将bam文件不完整的样本重新比对。cram文件也同样适用。
for i in *.bam ;do (samtools quickcheck $i && echo "ok" || echo $i error);done
数据保存建议¶
对于样本数不超过200个的项目，流程定型跑完后，cleandata可以删除，保存rawdata即可。所有bam文件建议保存至多不过3个月，如有必要，重新比对得到bam时间也非常快。需要长期存放的bam文件，建议转成cram保存。如非必要，vcf.gz 不建议解压。流程中间步骤需要用到sam等大文本文件的情况，在写流程时，在使用完之后需立即压缩或者删除。
samtools view -C -T genome.fasta sample.bam > sample.cram
linux 读gzip文件¶
gz相关linux命令
less file.gz
zcat file.gz
zless file.gz
zmore file.gz
#合并gzip文件
cat file1.gz file2.gz > file3.gz
#程序输出转gz
program file | gzip > out.gz
#gz文件为输入
program < gzip -dc file.gz
# 将2个文件解压再按列合并，最后压缩输出到新文件
paste <(gzip -dc file1.gz ) <(gzip -dc file2.gz ) | gzip > merge.gz
# 将fq文件转成fa
zcat ERR365991_1.fastq.gz |cat -n|awk '{if(NR%4 ==2) {n=int($1/4)+1;print ">"n"\n"$2}}' |gzip > reads.fa.gz
#blastn
blastn -query <(gzip -dc ZS97_cds_10^6.fa.gz) -db ./MH63_cds -outfmt 6 |gzip > ZS97_cds_10000.gz
#csvtk
csvtk -t filter2 -f '$2>3' <(gzip -dc 12_peak_region_addTC.tsv.gz) |gzip > test.gz
#或用csvtk -o 选项直接输出gz文件
csvtk -t filter2 -f '$2>3' <(gzip -dc 12_peak_region_addTC.tsv.gz) -o test.gz
python 读写gzip文件¶
python2、3通用
# 写文件，file.gz 不存在，则自动创建
f_out = gzip.open("file.gz", "wt")
f_out.write("new_write1\n")
f_out.close()
# 写文件,追加写
f_out = gzip.open("file.gz", "at")
f_out.write("new_write2\n")
f_out.close()
# 读文件
f_in = gzip.open("file.gz", "rt")
f_content = f_in.read()
print(f_content)
f_in.close()
perl 读写gzip文件¶
use PerlIO::gzip;
#写文件,file.gz 不存在，则自动创建
open FO, ">:gzip", "file.gz";
print FO "new_num\n";
close FO;
#追加写
open FO, ">>:gzip", "file.gz";
print FO "new_num2\n";
close FO;
#读文件
open FI, "<:gzip", "file.gz";
my $f_content = <FI>;
print $f_content;
R 读写gzip文件¶
#写文件
gz1 <- gzfile("file.gz", "w")
writeLines(c("new_num"), gz1)
close(gz1)
#读文件
gz2 <- gzfile("file.gz", "r")
readLines(gz2)
close(gz2)
java 读写gzip文件¶
import java.io.*;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
public class GzipTest {
public static void main(String[] args) throws IOException {
// 写文件
BufferedWriter fout = new BufferedWriter(new OutputStreamWriter(new GZIPOutputStream(new FileOutputStream("file.gz"))));
fout.write("new_write1\n");
fout.write("new_write2\n");
fout.close();
// 读文件
BufferedReader fin = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream("file.gz"))));
String line;
while ((line=fin.readLine()) != null) {
System.out.println(line);
}
}
}
生信分析中有大量的对fa/fq/vcf/sam/gff等文件操作的各种需求，目前有不少主流开源工具实现了非常多的功能，以满足生信数据处理的诸多需求。这里对常用处理工具和使用做个记录。
常用工具
seqkit module load seqkit/0.11.0
EMBOSS module load EMBOSS/6.5.7
ucsc_kentUtils github module load ucsc_kentUtils/v389
-
fa序列拆分
seqkit split可用于拆分fa序列，按序列id拆分后的序列文件名带有fa文件名的前缀，部分场景下可能还需要重命名一下将前缀去掉$ seqkit split -i genome_1.0.fa $ ls genome_1.0.fa.split/genome_1.0.id_Chr1.fafaSplit拆分后的序列文件名直接为序列id，不带前缀。可以适合在cnvnator中直接使用mkdir genome && cd genome faSplit byname ../genome.fa genome -
fq文件随机提取
随机提取10条序列
$ seqkit sample -n 10 -s 11 ../sample1_1.fq.gz -o sample1_1_n10.fq.gz随机提取10%的序列
$ seqkit sample -p 0.1 -s 11 ../sample1_1.fq.gz -o sample1_1_p10.fq.gz -
按染色体拆分bam文件
bam 文件需要先排序
input_bam=$1 chromosomes=($(samtools view -H "$input_bam" | grep "@SQ" | cut -f 2 | cut -d ':' -f 2)) for chromosome in "${chromosomes[@]}" do output_bam="${chromosome}.bam" samtools view -b "$input_bam" "$chromosome" > "$output_bam" done
使用singularity容器运行32位软件¶
在镜像/share/Singularity/centos/centos7_32.sif中配置了运行32位软件所需的环境，因此可以使用该镜像的环境在集群上运行32位软件。 使用方法为，使用singularity绑定目录的特性将软件目录绑定到镜像中，使软件在镜像的环境中运行。如下所示：
# 如软件放置在当前目录下，且具有可执行权限x
$ singularity exec -B ${PWD}:/opt/ $IMAGE/centos/centos7_32.sif /opt/32bitprogram -h
在使用或安装各类软件过程中，经常需要用到高版本的GCC，用户可以根据自己的需求，使用集群预装的高版本GCC或自行编译需要版本的GCC。
使用集群预装的GCC¶
# 查看集群预装的GCC版本
$ module av GCC
-------------------------------------------------- /public/home/software/opt/bio/modules/all/ ---------------------------------------------------
GCC/10.3.0 GCC/4.9.2 GCC/6.2.0-2.27 GCC/7.2.0-2.29 GCCcore/10.3.0 GCCcore/5.4.0 GCCcore/6.4.0
GCC/4.8.5 GCC/5.4.0-2.26 GCC/6.4.0-2.28 GCC/9.4.0 GCCcore/11.2.0 GCCcore/6.2.0 GCCcore/7.2.0
# 载入需要的GCC版本
$ module load GCC/10.3.0
$ gcc -v
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/public/home/software/opt/bio/software/GCCcore/10.3.0/libexec/gcc/x86_64-pc-linux-gnu/10.3.0/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none
Target: x86_64-pc-linux-gnu
Configured with: ../configure --enable-languages=c,c++,fortran --without-cuda-driver --enable-offload-targets=nvptx-none --enable-lto --enable-checking=release --disable-multilib --enable-shared=yes --enable-static=yes --enable-threads=posix --enable-plugins --enable-gold=default --enable-ld --with-plugin-ld=ld.gold --prefix=/public/home/software/opt/bio/software/GCCcore/10.3.0 --with-local-prefix=/public/home/software/opt/bio/software/GCCcore/10.3.0 --enable-bootstrap --with-isl=/public/home/software/.local/easybuild/build/GCCcore/10.3.0/dummy-dummy/gcc-10.3.0/stage2_stuff
Thread model: posix
Supported LTO compression algorithms: zlib
gcc version 10.3.0 (GCC)
普通用户编译安装GCC¶
相关软件下载¶
安装gcc之前依赖gmp、mpc、mpfr这三个包，所以先安装这个三个包，这三个包可以在下面的infrastructure目录下下载，gcc源码包在releases中下载，这里gcc下载的版本为gcc-4.8.5。
因为这三个包之间有依赖关系，安装顺序为gmp->mpfr->mpc->gcc
gmp安装¶
$ tar -jxvf gmp-4.3.2.tar.bz2
$ cd gmp-4.3.2
$ ./configure --prefix=/home/software/opt/gmp-4.3.2/ #gmp安装路径
$ make
$ make check #这一步可以不要
$ make install
mpfr安装¶
$ tar -jxvf mpfr-2.4.2.tar.bz2
$ cd mpfr-2.4.2
$ ./configure --prefix=/home/software/opt/mpfr-2.4.2/ --with-gmp=/home/software/opt/gmp-4.3.2/ #congfigure后面是mpfr安装路径及依赖的gmp路径
$ make
$ make check #这一步可以不要
$ make install
mpc安装¶
$ tar -zxvf mpc-0.8.1.tar.gz
$ cd mpc-0.8.1
$ ./configure --prefix=/home/software/opt/mpc-0.8.1/ --with-gmp=/home/software/opt/gmp-4.3.2/ --with-mpfr=/home/software/opt/mpfr-2.4.2/
$ make
$ make check #这一步可以不要
$ make install
更改~/.bashrc文件¶
在这个文件中添加一下三行（因为系统的LD_LIBRARY_PATH中有两个相邻的冒号，编译gcc的导致通不过，所以先把这个变量自己重新定义一下，然后将上面装的三个包添加到该变量中）
export LD_LIBRARY_PATH=/home/software/opt/gmp-4.3.2/lib/:/home/software/opt/mpfr-2.4.2/lib/:/home/software/opt/mpc-0.8.1/lib/
export LIBRARY_PATH=$LD_LIBRARY_PATH
gcc安装¶
$ tar -jxvf gcc-4.8.2.tar.bz2
$ cd gcc-4.8.2
$ ./configure --prefix=/home/software/opt/gcc-4.8.5/ --enable-threads=posix --disable-checking --disable-multilib --with-mpc=/home/software/opt/mpc-0.8.1/ --with-gmp=/home/software/opt/gmp-4.3.2/ --with-mpfr=/home/software/opt/mpfr-2.4.2/ make -j 10 #类似于使用10个线程编译，速度要快很多
$ make install
更改~/.bashrc文件¶
在~/.bashrc文件中加入一下两句
export PATH=/home/software/opt/gcc-4.8.5/bin/:$PATH
export LD_LIBRARY_PATH=/home/software/opt/gcc-4.8.5/lib/:~/opt/gcc-4.8.5/lib64/:$LD_LIBRARY_PATH
glibc是GNU发布的libc库，即c运行库。glibc是linux系统中最底层的api，几乎其它任何运行库都会依赖于glibc。glibc除了封装linux操作系统所提供的系统服务外，它本身也提供了许多其它一些必要功能服务的实现。
Linux系统上基本所有程序运行都依赖glibc库，不同Linux发行版或同一发行版的不同版本glibc库的版本都可能不大一样，一般原则是Linux发行版更新越快，其glibc的版本越新，如Ubuntu大版本更新很快，其glibc库的版本比较新；同一Linux发行版，系统版本越新，glibc的版本也越新，如CentOS6.x的glibc版本为2.12，CentOS7.x的glibc版本为2.17，CentOS8.x为2.28。
在低版本glibc的Linux系统上编译的软件，可以在高版本glibc的Linux系统上运行，反之则报错，如在CentOS7.x上编译的软件无法在CentOS6.x上运行。
许多软件的作者经常会在glibc版本非常高的Linux系统上编译软件然后在github上发布，用户下载之后由于系统的glibc版本较低而无法运行，报类似如下的报错：
$ SVvadalidation -h
[47944] Error loading Python lib '/tmp/_MEIYlB3Lh/libpython3.8.so.1.0': dlopen: /lib64/libm.so.6: version `GLIBC_2.29' not found (required by /tmp/_MEIYlB3Lh/libpython3.8.so.1.0)
$ ldd --version
ldd (GNU libc) 2.17
Copyright (C) 2012 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Written by Roland McGrath and Ulrich Drepper.
集群目前的系统版本为CentOS7.x，glibc版本为2.17，10年前的版本，非常古老了，未来会有越来越多的软件出现glibc版本不够的报错。
解决办法有以下几种：
更换系统¶
出现glibc相关的报错，使用高版本glibc的系统即可解决。
常见服务器Linux系统版本对应的glibc版本如下，更多的Linux系统版本及对应的glibc库见 distrowatch。
- 系统版本：6.x，glibc版本：2.12，生命周期(EOL)：2020-11
- 系统版本：7.x，glibc版本：2.17，EOL：2024-06
- 系统版本：8.5，glibc版本：2.28，EOL：2021-12
- 系统版本：9，glibc版本：2.34，EOL：2021-12
- 系统版本：Rocky 8.7，glibc版本：2.28，EOL：2029-05
- 系统版本：Rocky 9.1，glibc版本：2.34，EOL：2032-05
- 系统版本：12.04 LTS precise，glibc版本：2.15，EOL：2017-04
- 系统版本：14.04 LTS trusty，glibc版本：2.19，EOL：2019-04
- 系统版本：16.04 LTS xenial，glibc版本：2.23，EOL：2021-04
- 系统版本：18.04 LTS bionic，glibc版本：2.27，EOL：2023-04
- 系统版本：20.04 LTS focal，glibc版本：2.31，EOL：2025-04
- 系统版本：22.04 LTS jammy，glibc版本：2.35，EOL：2027-04
- 系统版本：24.04 LTS noble，glibc版本：2.39，EOL：2029-04
- 系统版本：6.0 squeeze，glibc版本：2.11.2，EOL：2016-02
- 系统版本：7.0 wheezy，glibc版本：2.13，EOL：2018-05
- 系统版本：8.0 jessie，glibc版本：2.19，EOL：2020-07
- 系统版本：9 stretch，glibc版本：2.24
- 系统版本：10 buster，glibc版本：2.28
- 系统版本：11 bullseye，glibc版本：2.31
- 系统版本：12 bookworm，glibc版本：2.36
源码编译¶
软件作者分发的编译好的软件，依赖作者的编译环境和底层glibc库，运行时在低版本glibc的系统上出现找不到glibc库的兼容性报错。如果软件作者提供了软件的源代码，则下载源代码自行编译，编译之后的软件只会依赖当前系统的glibc库，不会出现glibc版本兼容性的问题。
安装高版本glibc¶
Danger
glibc是系统上非常底层的库，如果不是非常熟悉，切勿按照网上的教程用root账户一把梭安装高版本glibc、替换系统的库文件，其结果很可能是系统崩溃无法开机。
一般建议使用普通账户安装。
$ wget https://ftp.gnu.org/gnu/glibc/glibc-2.21.tar.gz
$ tar xf glibc-2.21.tar.gz && cd glibc-2.21
$ mkdir build && cd build
$ ../configure -prefix=/path/to/install
$ make -j12 && make install
# 设置环境变量
$ echo $LD_LIBRARY_PATH=/path/to/install/lib >> ~/.bashrc
这种方式无法安装版本比较高的glibc，如在集群上，最高只能安装glibc 2.23，且能正常使用。再高一点的版本要么安装报错，要么使用的时候报错。
此外对于需要使用高版本glibc的.so动态链接库，此方法无效。
用户在集群上可以直接调用：module load glibc/2.23。
patchelf¶
直接载入高版本的glibc后，部分软件运行出现类似如下的报错
Segmentation fault
libc.so.6: symbol _dl_find_dso_for_object, version GLIBC_PRIVATE not defined in file ld-linux-x86-64.so.2 with link time reference
此种情况可以使用 patchelf 解决，其原理是可以改变二进制文件使用的 ld-linux.so.2，默认使用 /lib64/ld-linux-x86-64.so.2。
Warning
patchelf 会改变二进制文件包的内容，其过程是不可逆的。因此为防止出现意外情况，使用 patchelf 之前建议先备份一下二进制文件。
软件运行过程中会用到安装的 glibc 库，因此建议将 glibc 安装在一个固定的位置，以免 glibc 改变了目录或被删除后，相关软件无法运行。
https://stackoverflow.com/questions/847179/multiple-glibc-libraries-on-a-single-host/851229#851229
# glibc 版本报错
$ ./glnexus_cli
./glnexus_cli: /lib64/libc.so.6: version `GLIBC_2.18' not found (required by ./glnexus_cli)
# patchelf 处理
$ module load patchelf/0.9
$ patchelf --set-interpreter /public/home/software/opt/bio/software/Glibc/2.18/lib/ld-linux-x86-64.so.2 --set-rpath /public/home/software/opt/bio/software/Glibc/2.18/ glnexus_cli
# 正常运行
$ ./glnexus_cli-bak
[43076] [2024-10-06 23:31:46.729] [GLnexus] [info] glnexus_cli release v1.4.1-0-g68e25e5 Aug 13 2021
[43076] [2024-10-06 23:31:46.730] [GLnexus] [warning] jemalloc absent, which will impede performance with high thread counts. See https://github.com/dnanexus-rnd/GLnexus/wiki/Performance
Usage: ./glnexus_cli-bak [options] /vcf/file/1 .. /vcf/file/N
Merge and joint-call input gVCF files, emitting multi-sample BCF on standard output.
利用 patchelf 的 --set-rpath 选项，也可以永久更改二进制包使用的 GCC 版本，而不用每次写 LD_LIBRARY_PATH 环境变量
$ patchelf --set-interpreter /public/home/software/opt/bio/software/Glibc/2.18/lib/ld-linux-x86-64.so.2 --set-rpath /public/home/software/opt/bio/software/Glibc/2.18/:/public/home/software/opt/bio/software/GCCcore/5.4.0/lib64/ myapp
glibc-all-in-one¶
glibc 安装比较费时间，其高版本的glibc不容安装成功，可以利用 glibc-all-in-one 这个项目下载使用编译好的 glibc。
$ git clone https://github.com/matrix1001/glibc-all-in-one
cd glibc-all-in-one
# 将可下载使用的glibc版本更新到list文件中
$ ./update_list
$ cat list
2.23-0ubuntu11.3_amd64
2.23-0ubuntu11.3_i386
2.23-0ubuntu3_amd64
2.23-0ubuntu3_i386
2.27-3ubuntu1.5_amd64
2.27-3ubuntu1.5_i386
2.27-3ubuntu1.6_amd64
2.27-3ubuntu1.6_i386
2.27-3ubuntu1_amd64
2.27-3ubuntu1_i386
2.31-0ubuntu9.16_amd64
2.31-0ubuntu9.16_i386
2.31-0ubuntu9_amd64
2.31-0ubuntu9_i386
2.35-0ubuntu3.8_amd64
2.35-0ubuntu3.8_i386
2.35-0ubuntu3_amd64
2.35-0ubuntu3_i386
2.37-0ubuntu2.2_amd64
2.37-0ubuntu2.2_i386
2.37-0ubuntu2_amd64
2.37-0ubuntu2_i386
2.38-1ubuntu6.3_amd64
2.38-1ubuntu6.3_i386
2.38-1ubuntu6_amd64
2.38-1ubuntu6_i386
2.39-0ubuntu8.3_amd64
2.39-0ubuntu8.3_i386
2.39-0ubuntu8_amd64
2.39-0ubuntu8_i386
2.40-1ubuntu3_amd64
2.40-1ubuntu3_i386
# 下载指定版本的glibc
$ ./download 2.27-3ubuntu1_amd64
# 查看下载的glibc
$ ls libs
2.27-3ubuntu1_amd64/
#patchelf 处理
patchelf --set-interpreter ./libs/2.27-3ubuntu1_amd64/ld-linux-x86-64.so.2 --set-rpath ./libs/2.27-3ubuntu1_amd64 --force-rpath myapp
使用singularity容器安装¶
创建glibc版本较高的singularity镜像，如 debian 11，将软件拷贝至debian 11的目录下，如/opt/，测试软件是否正常，如果正常则将该镜像打包使用。这一步需要有root权限才可以操作，一般建议在虚拟机上进行，如果出现问题，影响也不会太大。这里以SVvadalidation为例进行操作说明。
$ pwd
$ /root
$ unzip SVvaliation-main.zip
$ singularity build --sandbox ./debian docker://debian:11
# 进入debian镜像的shell，将软件拷贝至/opt/目录下
$ singularity shell --writable ./debian
> cp -r /root/SVvaliation-main /opt/
# 测试是否可用
$ singularity exec ./debian /opt/SVvaliation-main/dist/SVvadalidation -h
# 打包镜像
$ singularity build debian_11.sif ./debian
# 将打包好的镜像传到集群上使用
使用singularity容器调用¶
此方式跟上一种方式的区别在于，无需root权限，普通用户就可以操作，不需要将软件拷贝至镜像中，pull一次镜像之后其它的软件都可以使用，比较方便。 核心点在于调用时，使用singularity绑定目录的特性将软件目录绑定到镜像中，使软件在镜像的环境中运行。
# pull镜像
$ singularity pull docker://debian:11
$ singularity exec -B ./SVvaliation-main/:/opt/ $IMAGE/debian/debian11.sif /opt/dist/SVvadalidation -h
Info
集群镜像目录中有debian 11的镜像，可以直接使用$IMAGE/debian/debian11.sif，glibc版本为2.31。
注意事项
如果程序运行需要的数据不在当前目录挂载的存储上，则需要将该目录绑定到镜像中。
$ singularity exec -B ./SVvaliation-main/:/opt/ debian11.sif /opt/dist/SVvadalidation test.bed /data/test/test.cram
[E::hts_open_format] Failed to open file "/data/test/test.cram" : No such file or directory
Traceback (most recent call last):
File "SVvadalidation.py", line 26, in <module>
File "pysam/libcalignmentfile.pyx", line 751, in pysam.libcalignmentfile.AlignmentFile.__cinit__
File "pysam/libcalignmentfile.pyx", line 950, in pysam.libcalignmentfile.AlignmentFile._open
FileNotFoundError: [Errno 2] could not open alignment file `Sha_15_sorted.cram`: No such file or directory
[29216] Failed to execute script 'SVvadalidation' due to unhandled exception!
# 将/data/test/目录绑定到容器中的/mnt/目录后正常运行
$ singularity exec -B ./SVvaliation-main/:/opt/ -B /data/test/:/mnt/ debian11.sif /opt/dist/SVvadalidation test.bed test.cram
Module 介绍¶
传统上，我们在服务器上安装软件分为两步：
- 下载软件并将其安装在服务器上；
- 在
~/.bashrc中写入相应的环境变量，例如$PATH,$LD_LIBRAPRY_PATH等。
软件数量较少时可能并不会出现什么问题，但当使用的软件很多，很多软件又依赖大量的库，并且依赖库的版本不同时，如果还是用传统的方法在~/.bashrc 中写入这些变量，可能不同的库之间会产生严重的干扰导致软件不能使用，这时可能需要我们把~/.bashrc中的内容一项项注释掉，直到我们需要的软件能正常运行（平台用户碰到过这种情况较多）。
这里推荐一个很好用的集群应用软件环境管理工具Module，它可以动态地更改$PATH, $LD_LIBRARY等环境变量，每次只引入我们需要的库文件、应用软件的相关环境变量。
module基本使用¶
使用之前我们需要知道Module中一个比较重要的文件modulefile文件，每个软件都需要有对应的modulefile文件，里面定义了该软件所需要的所有环境变量、软件说明、依赖的其他软件和库文件等，需要使用该软件时，我们用相关命令载入该modulefile文件，即可载入该软件的所有环境变量、依赖软件和库文件等。下面是module常用的一些命令：
module available
odule av简写来代替，同时module av支持模糊搜索，例如module av m会列出所有以m开头的软件
module load modulefile
module unload modulefile
module purge
module list
module show modulefile
module swith|swap [modulefile_old][modulefile_new]
在实验室集群中使用module¶
我在software帐号下预装了一些常用的软件，大家可以在自己的~/.bashrc内写入基本的配置，即可使用module来引用预装好的各种软件。
- 将下面高亮为黄色部分的代码写在所有其它用户自己写入的变量之前，注意要在那3行系统自带
if语句之后，否则会有异常；
# .bashrc
# Source global definitions
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
export LD_LIBRARY_PATH=""
export LIBRARY_PATH=""
export MANPATH=""
export INCLUDE=""
export FPATH=""
export CPATH=""
export MKLROOT=""
export MIC_LD_LIBRARY_PATH=""
export NLSPATH=""
export PATH="/public/home/software/opt/moudles/Modules/3.2.10/bin/:/opt/ibm/lsf/10.1/linux3.10-glibc2.17-x86_64/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin"
source /public/home/software/opt/moudles/Modules/3.2.10/init/bash
- 当需要使用SOAPdenovo2时，我们可以先用
module list查看一下目前的环境中是否加载了SOAPdenovo2，如果没有，则首先通过module av S来搜索SOAPdenovo2的modulefile文件；
$ module av
--------------------------------------------- /public/home/software/opt/bio/modules/all/ ----------------------------------------------
ABySS/1.9.0-foss-2016b Java/1.8.0_92
ALLPATHS-LG/52488 JUnit/4.12-Java-1.8.0_92
Anaconda2/4.0.0 libevent/2.0.22-foss-2016b
ant/1.9.7-Java-1.8.0_92 libffi/3.2.1-foss-2016b
argtable/2.13-foss-2016b libjpeg-turbo/1.5.0-foss-2016b
augustus/2.7 libpng/1.6.23-foss-2016b
augustus/3.2.7 libreadline/6.3
Autoconf/2.69-foss-2016b libreadline/6.3-foss-2016b
Automake/1.15-foss-2016b LibTIFF/4.0.6-foss-2016b
Autotools/20150215-foss-2016b libtool/2.4.6-foss-2016b
BamTools/2.4.0-foss-2016b libunwind/1.1-foss-2016b
BamUtil/1.0.13-foss-2016b libxml2/2.9.4-foss-2016b
BCFtools/1.3-foss-2016b log4cplus/1.1.2
BEDTools/2.26.0-foss-2016b log4cplus/1.1.2-foss-2016b
BFAST/0.7.0 Lua/5.1.4-8
binutils/2.26 M4/1.4.17
binutils/2.26-GCCcore-5.4.0 M4/1.4.17-foss-2016b
binutils/2.27 M4/1.4.17-GCCcore-5.4.0
binutils/2.27-GCCcore-6.2.0 M4/1.4.17-GCCcore-6.2.0
BioPerl/1.6.924-foss-2016b-Perl-5.22.1 maker/2.31.9
Bison/3.0.4 MaSuRCA/3.2.1
Bison/3.0.4-foss-2016b MATLAB/2015a
Bison/3.0.4-GCCcore-5.4.0 METIS/5.1.0-foss-2016b
- 通过第二步，我们得知SOAPdenovo2的
modulefile文件为SOAPdenovo2/r240-foss-2016b，此时我们可以使用module load SOAPdenovo2/r240-foss-2016b命令来加载SOAPdenovo2的所有环境变量； - 如果不再需要使用SOAPdenovo2，我们可以使用
module unload SOAPdenovo2/r240-foss-2016b命令来卸载所有SOAPdenovo2相关的环境变量。如果我们一次加载了很多软件，我们可以使用module purge来卸载所有软件的环境变量。
自定义modulefile文件¶
有时我们需要用的软件在系统上没有预装，此时，我们可以将此软件安装在用户自己的目录下，然后自定义modulefile文件来通过module来加载自己安装的软件。以sratoolkit为例，具体步骤如下：
- 建立一个目录用于放置所有自定义的
modulefile文件；
mkdir ~/.modulefiles
- 运行
module use ~/.modulefiles命令，使得module av, module load可以搜索、加载~/.modulefiles目录下的modulefile文件（其实该命令的作用是将~/.modulefiles加入到$MODULEPATH变量中）。为了保证长期可用，建议将改命令写入到~/.bashrc文件中；
module use ~/.modulefiles
- 在
~/.modulefiles创建目录sratoolkit：mkdir sratoolkit，编辑一个以该软件版本为名字的文件：vim 2.5.7，文件内容如下（内容比较简单，更复杂的例子可以查看官网）；
#%Module
set root /public/home/software/opt/bio/software/sratoolkit/2.5.7
conflict sratoolkit
prepend-path PATH $root/bin
- 保存退出后，运行module av 即可以看到sratoolkit的
modulefile文件sratoolkit/2.5.7，需要使用时运行命令：module load sratoolkit/2.5.7，就可以使用该软件了。
module load sratoolkit/2.5.7
注意事项¶
有的用户自己的~/.bashrc等文件内有自己写入的环境变量，使用module载入系统装好的软件时，载入的环境变量可能会与自己已有的环境变量产生冲突，导致载入的软件不可用，此时需要注释掉自己的环境变量。典型例子，载入需要perl支持的软件时如RepeatMasker，如果自己的用户环境内已经有了perl相关的环境变量，可能会因为两个不同版本的perl之间的冲突导致软件不可用，此时需要注释自己的perl的相关环境变量。
singularity 介绍¶
容器作为轻量级的虚拟机，可在主机之外提供多种系统环境选择，如某些软件可能只在某个linux发行版本上运行；另外，在容器中一次打包好软件及相关依赖环境之后，即可将复杂的软件环境在各种平台上无缝运行，无需重复多次配置，大大减轻相关工作人员的工作量；因为可以利用容器技术在一台物理机器上部署大量不同的系统（一台物理机支持的容器远多于传统虚拟机），提高了资源利用率，因此在近几年变得非常流行。目前主流的容器为docker，其最初被用于软件产品需要快速迭代的互联网行业，极大地简化了系统部署、提高了硬件资源的利用率，近来也在各种特定领域的应用系统中被使用。
在生物信息领域，为了一次配置，多次使用的目的，一些复杂的软件开始使用docker进行打包分发，另外由于云的兴起，docker也用于搭建私有生物信息云分析平台。尽管如此，由于权限、资源管理等因素限制，docker并未在传统HPC集群（物理裸机+操作系统+作业调度系统+高速互联网络）中流行开。于是，有人开发了专门针对传统HPC集群的容器工具singularity，其使得普通用户可以方便地在集群使用打包好的容器镜像，配合作业调度系统，其使用也非常方便，跟使用其它应用软件的方式相同。singularity还有一大优势是，可直接使用docker镜像，大大提高了singularity的可用性，不必重新造轮子。
singularity 调用¶
module load Singularity/3.1.1
singularity 使用¶
singularity有许多命令，常用的命令有，pull、run、exec、shell、build
-
pull
从给定的URL下载容器镜像，常用的有URL有Docker Hub(docker://user/image:tag) 和 Singularity Hub(shub://user/image:tag)，如
singularity pull tensorflow.sif docker://tensorflow/tensorflow:latest -
run
执行预定义的命令
-
exec
在容器中执行某个命令
或singularity exec docker://tensorflow/tensorflow:latest python example.pysingularity exec tensorflow.sif python example.py -
shell
进入容器中的shell
或singularity shell docker://tensorflow/tensorflow:latest然后可在容器的shell中运行自己的程序singularity shell tensorflow.sif -
build
创建容器镜像
singularity 使用举例¶
在/share/Singularity/ 中放了一些下载好的容器镜像，大家可以自己调用，同时也可以联系管理员将自己下好的镜像放到这个公共目录，供大家使用。
这里以qiime2为例，其安装比较繁琐，依赖的python和R包较多，因此官方也给了docker镜像，这里我们可以使用singularity下载、使用qiime2的docker镜像
-
下载qiime2镜像
singularity pull qiime2_core_2018.11.sif docker://qiime2/core:2018.11 -
载入数据
bsub -J qiime2_1 -o %J.out -e %J.err "module load Singularity/3.1.1;singularity exec -B /share/exercise/qiime2/emp-single-end-sequences qiime2_core_2018.11.sif qiime tools import --type EMPSingleEndSequences --input-path /share/exercise/qiime2/emp-single-end-sequences --output-path emp-single-end-sequences.qza"因为在容器中是没有/share/exercise/qiime2/emp-single-end-sequences 这个绝对路径的，所以需要使用-B选项将宿主机的/share/exercise/qiime2/emp-single-end-sequences映射到容器中/share/exercise/qiime2/emp-single-end-sequences
-
按barcode拆分样品 Demultiplexing sequences
bsub -J qiime2_2 -o %J.out -e %J.err "module load Singularity/3.1.1;singularity exec qiime2_core_2018.11.sif qiime demux emp-single --i-seqs emp-single-end-sequences.qza --m-barcodes-file sample-metadata.tsv --m-barcodes-column BarcodeSequence --o-per-sample-sequences demux.qza" -
结果统计
bsub -J qiime2_3 -o %J.out -e %J.err "module load Singularity/3.1.1;singularity exec qiime2_core_2018.11.sif qiime demux summarize --i-data demux.qza --o-visualization demux.qzv"
常用生信singularity镜像¶
galaxy 项目组利用 mulled 自动将 Bioconda 中的所有软件自动转成了 Singularity 容器镜像，目前共计约有 10 万个生信软件镜像，用户可以直接下载使用，比使用 conda 安装更简单，容器列表：https://depot.galaxyproject.org/singularity/， 容器构建说明： https://docs.galaxyproject.org/en/master/admin/special_topics/mulled_containers.html
Note
由于这个列表长度很长网页加载需要很长时间，可以将列表下载到服务器本地搜索。
$ curl -o list https://depot.galaxyproject.org/singularity/
$ grep -o 'href="[^"]*"' list | cut -d'"' -f2|tail -n +4|awk '{print "https://depot.galaxyproject.org/singularity/"$0}' > bio_image_list
# 搜索bwa
$ cat bio_image_list|grep -i bwa
https://depot.galaxyproject.org/singularity/
这里有绝大部分常用生信软件的singularity镜像，可直接下载使用，以bwa为例
# 找到需要的软件镜像，右键"复制链接地址"，wget下载
$ wget --no-check-certificate https://depot.galaxyproject.org/singularity/bwa%3A0.7.17--h7132678_9
# 里面含有冒号: ，对linux路径不友好，重命名换成下划线 _；以sif结尾，表示是个singularity镜像；--后面的部分可以去掉
$ mv bwa%3A0.7.17--h7132678_9 bwa_0.7.17.sif
# 使用
$ singularity exec bwa_0.7.17.sif bwa
Program: bwa (alignment via Burrows-Wheeler transformation)
Version: 0.7.17-r1188
Contact: Heng Li <lh3@sanger.ac.uk>
Usage: bwa <command> [options]
Command: index index sequences in the FASTA format
mem BWA-MEM algorithm
fastmap identify super-maximal exact matches
pemerge merge overlapping paired ends (EXPERIMENTAL)
aln gapped/ungapped alignment
samse generate alignment (single ended)
sampe generate alignment (paired ended)
bwasw BWA-SW for long queries
shm manage indices in shared memory
fa2pac convert FASTA to PAC format
pac2bwt generate BWT from PAC
pac2bwtgen alternative algorithm for generating BWT
bwtupdate update .bwt to the new format
bwt2sa generate SA from BWT and Occ
Note: To use BWA, you need to first index the genome with `bwa index'.
There are three alignment algorithms in BWA: `mem', `bwasw', and
`aln/samse/sampe'. If you are not sure which to use, try `bwa mem'
first. Please `man ./bwa.1' for the manual.
使用国内docker hub 镜像站点¶
Warning
2024.6.21 所有镜像测试可用
# 速度较慢
$ singularity pull docker://m.daocloud.io/docker.io/library/debian:latest
$ singularity pull docker://m.daocloud.io/docker.io/rnakato/juicer:latest
# 速度较快
$ singularity pull docker://docker.hpcloud.cloud/rnakato/juicer:latest
$ singularity pull docker://hub.uuuadc.top/rnakato/juicer:latest
$ singularity pull docker://docker.anyhub.us.kg/rnakato/juicer:latest
$ singularity pull docker://dockerhub.jobcher.com/rnakato/juicer:latest
$ singularity pull docker://dockerhub.icu/rnakato/juicer:latest
$ singularity pull docker://docker.ckyl.me/rnakato/juicer:latest
$ singularity pull docker://docker.awsl9527.cn/rnakato/juicer:latest
PS：library是一个特殊的命名空间，它代表的是官方镜像。如果是某个用户的镜像就把library替换为镜像的用户名。
集群singularity镜像列表¶
| 软件名称 | 使用 | 文档/网址 |
|---|---|---|
| IntaRNA | singularity exec $IMAGE/IntaRNA/3.3.1.sif IntaRNA -h | https://github.com/BackofenLab/IntaRNA |
| EDTA | singularity exec $IMAGE/EDTA/2.0.0.sif EDTA.pl -h | https://github.com/oushujun/EDTA |
| busco | singularity exec $IMAGE/busco/5.1.3_cv1.sif busco -h | 使用busco的singularity镜像 |
| alphafold | 使用alphafold镜像 | |
| NVIDIA深度学习包 | NVIDIA官方构建的深度学习镜像，有速度加成。 | 使用NVIDIA深度学习镜像 |
| Trinity | singularity exec -e $IMAGE/Trinity/2.12.0.sif Trinity -h | Trinity |
| QTLtools | singularity exec -e $IMAGE/QTLtools/1.3.1.sif QTLtools --help | QTLtools |
| qiime2 | singularity exec -e $IMAGE/qiime2/amplicon_2023.9.sif qiime2 | QIIME 2 |
| subphaser | subphaser镜像使用 | |
| STAR-Fusion | singularity exec $IMAGE/STAR-Fusion/1.13.0.sif STAR-Fusion -h | STAR-Fusion |
| antismash | singularity exec $IMAGE/antismash/7.1.0.sif antismash -h | antiSMASH Documentation |
| smcpp | singularity exec $IMAGE/smcpp/1.15.4.sif -h | smcpp |
| ensembl-vep | singularity exec $IMAGE/ensembl-vep/111.0.sif vep --help | ensembl-vep |
参考：
超算平台 Singularity 容器运行简介-中科大.pdf
Singularity Definition 文件¶
将Dockerfile转成Singularityfile
pip install spython
spython recipe Dockerfile &> Singularityfile
#创建镜像
singularity build xxx.sif Singularityfile
singularity安装¶
环境为CentOS7
源码编译安装¶
$ wget https://dl.google.com/go/go1.20.1.linux-amd64.tar.gz
$ tar xf go1.20.1.linux-amd64.tar.gz
$ mv go/* /opt/go/1.20.1
# 设置环境变量
$ export PATH="/opt/go/1.20.1/bin/:$PATH"
$ wget https://github.com/libfuse/libfuse/releases/download/fuse-3.3.0/fuse-3.3.0.tar.xz
$ tar xf fuse-3.3.0.tar.xz
$ cd fuse-3.3.0/
$ mkdir build; cd build
$ module load meson/0.61.5 ninja/1.10.1
$ meson setup --prefix=/opt/fuse/3.3.0 ..
$ ninja
$ ninja install
# 设置环境变量
$ export PKG_CONFIG_PATH="/opt/fuse/3.3.0/lib/pkgconfig:$PKG_CONFIG_PATH"
$ wget https://github.com/plougher/squashfs-tools/archive/refs/tags/4.6.1.tar.gz
$ mv 4.6.1.tar.gz squashfs-tools-4.6.1.tar.gz
$ tar xf squashfs-tools-4.6.1.tar.gz
$ cd squashfs-tools-4.6.1/squashfs-tools/
# 修改安装位置
# 将Makefile文件中的 INSTALL_PREFIX = /usr/local 改为 INSTALL_PREFIX = /opt/squashfs-tools/4.6.1/
$ make && make install
$ module load glib/2.40.2
$ export VERSION=4.1.2
$ wget https://github.com/sylabs/singularity/releases/download/v${VERSION}/singularity-ce-${VERSION}.tar.gz
$ tar xf singularity-ce-4.1.2.tar.gz
$ cd singularity-ce-4.1.2/
$ ./mconfig --prefix=/opt/singularity/4.1.2/
$ make -C builddir
$ sudo make install -C builddir
# 更改 /opt/singularity/4.1.2/etc/singularity/singularity.conf 文件
# 将 mksquashfs path = /usr/sbin/mksquashfs 更改为 mksquashfs path = /opt/bio/software/squashfs-tools/4.6.1/bin/
yum+rpm快速安装¶
yum install -y autoconf automake cryptsetup fuse3-devel git glib2-devel libseccomp-devel libtool runc wget zlib-devel
# centos7 yum 安装的squashfs-tools版本低于4.5，singularity 4.1要求squashfs-tools 版本不低于4.5，因此选择从源码编译安装
$ wget https://github.com/plougher/squashfs-tools/archive/refs/tags/4.6.1.tar.gz
$ mv 4.6.1.tar.gz squashfs-tools-4.6.1.tar.gz
$ tar xf squashfs-tools-4.6.1.tar.gz
$ cd squashfs-tools-4.6.1/squashfs-tools/
$ make && make install
$ export VERSION=4.1.2
$ wget https://github.com/hpcng/singularity/releases/download/v${VERSION}/singularity-${VERSION}.tar.gz
$ rpmbuild -tb singularity-${VERSION}.tar.gz
$ rpm -ivh ~/rpmbuild/RPMS/x86_64/singularity-${VERSION}-1.el7.x86_64.rpm
$ rm -rf rpmbuild
docker 镜像转 singularity 镜像¶
查找 Docker 镜像 ID¶
在运行 Docker 的主机上，使用命令 docker images 查找存储在本地注册表中的 Docker 镜像的镜像 ID (通常是 /var/lib/docker )：
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
quay.io/biocontainers/samtools 1.17--hd87286a_1 c6ab05d10f7f 6 weeks ago 66.7MB
hello-world latest 9c7a54a9a43c 2 months ago 13.3kB
创建 Docker 镜像的 tarball 文件¶
对于想移植到其它主机上的 Docker 镜像，例如，biobakery/lefse，镜像ID为 c6ab05d10f7f，使用 docker save 命令创建一个 tarball：
$ docker save c6ab05d10f7f -o samtools.tar
将 tarball 转换为 Singularity 镜像¶
如果 tarball 在当前工作目录中，执行:
$ singularity build --sandbox samtools docker-archive://samtools.tar
如果 tarball 文件不在当前工作目录中，需指定路径，例如 /tmp：
$ singularity build --sandbox samtools docker-archive:///tmp/samtools.tar
运行 Singularity 沙箱镜像，例如：
$ singularity shell samtools
$ singularity exec samtools samtools help
$ singularity run samtools
参考¶
https://mp.weixin.qq.com/s/1ysA1A8WnyXNh_6VzL7aJw
https://mp.weixin.qq.com/s/2_Qt04skLhPSrHCwzGWgHg
https://mp.weixin.qq.com/s/NewJUg8LcCHjWEdQK3CODQ
https://mp.weixin.qq.com/s/TPqfn3yJcQwR5o3sBKXpXg
https://mp.weixin.qq.com/s/6hB7NBGccsqINOBIe-Q2Uw
https://zhuanlan.zhihu.com/p/138797794
https://www.jianshu.com/p/b46ee066806b
https://itoc.sjtu.edu.cn/wp-content/uploads/2020/11/Chengshenggan.pdf
https://gist.github.com/diyism/4b892a4339f35561dd2ec48158a8c75d
https://www.cnblogs.com/newblg/p/17724951.html
https://www.dzbioinformatics.com/2021/04/02/singularity-%E7%BB%83%E4%B9%A0/
perl编译安装¶
wget http://www.cpan.org/src/5.0/perl-5.26.1.tar.gz
tar -xzf perl-5.26.1.tar.gz
cd perl-5.26.1
./Configure -des -Dusethreads -Dprefix=$HOME/localperl #-Dusethreads 以免出现This Perl not built to support threads的报错
make
make test
make install
dist/IO/poll.h：将 #include<poll.h> 修改为 #include<sys/poll.h>。
如果出现This Perl not built to support threads的报错，可以按上面的方式重新编译安装perl或将所有的Threads模块改成forks模块。
error-using-thread-module-this-perl-not-built-to-support-threads
use threads; -> use forks;
使用集群预装的perl及模块¶
服务器上预装了多个版本的perl，可以根据需要自行载入，如，
module load Perl/5.26.1
同时也预装了不少常用的perl模块，可直接使用。
在自己的目录下安装perl模块¶
可能有时候自己需要使用的包系统上没有装，此时需要在自己的目录下安装，推荐使用cpanm来装，首先需要载入Perl，
module load Perl/5.26.1
使用cpanm安装perl包，第一次使用时，需要运行一下以下命令，
cpanm --local-lib=~/perl5 local::lib && eval $(perl -I ~/perl5/lib/perl5/ -Mlocal::lib)
perl包安装的默认位置为~/perl5目录内。之后，可直接运行cpanm module来安装perl包，如安装SVG包。
cpanm SVG
可以使用 perl -e "require SVG" 或 perldoc SVG 来检测SVG包是否正常安装，另外使用 perldoc perllocal 命令可以查看当前环境下可以使用的Perl模块。
perl -e "require SVG"
perldoc SVG
perldoc perllocal
集群R 使用¶
Warning
集群上R最新的主线版本为 R/4.0.0，此版本内安装了大量可用R包，如代码或R包无较高R版本需求，建议优先使用此版本。
集群上安装了多个版本的R，3.3, 3.6, 4.0, 4.2等，可使用module av R 查看。用户可以根据需要，通过module load 命令调用需要的R。
module load R/4.0.0
在R/4.0.0 中，安装了许多常用的R包，部分R包安装运行时会依赖高版本GCC、库文件等，具体见本文后面的表格，使用这些R包需要先载入对应的软件。
对于集群中没有安装的R包，用户可以在自己的账号中安装。调用集群中的R安装R包时候，R包会装在默认位置~/R/x86_64-pc-linux-gnu-library/x.x 目录中，如使用R/4.0.0 ，R包默认安装目录为 ~/R/x86_64-pc-linux-gnu-library/4.0 。
各种R包安装方式见 R包安装。
如果不是安装在默认位置，可以在~/.bashrc 目录内写入R_LIBS变量来指定R包安装的位置以方便调用。
export R_LIBS=~/R_libs
Rstudio¶
为方便画图等，可以调用集群中安装的Rstudio，具体见RStudio。
Rstudio运行在计算节点，由于计算节点没有联网，因此不能直接安装R包。处理方式为：
- 自行安装
在登录节点上，使用集群公共R R/4.2.0 安装R包到指定目录，然后在Rstudio中使用安装的这个包。
$ module load R/4.2.0
# 确保 ~/R/rstudio/4.2/ 目录存在，否则自行创建
$ R
# install.packages包安装，使用lib参数指定安装位置
$ > install.packages("ggplot2", lib="~/R/rstudio/4.2/")
# Bioconductor包安装
# 先指定安装位置，然后再安装
$ > .libPaths(c("~/R/rstudio/4.2/", .libPaths()))
$ > BiocManager::install("methylKit")
- 使用预装包
# 添加包路径 $ > .libPaths(c('/public/home/software/opt/bio/software/rstudio/4.2/library',.libPaths())) # 如使用装好的 monocle3 $ > library(monocle3)
R 依赖库¶
| R包 | 集群R版本 | 依赖库 |
|---|---|---|
| LPmerge | 4.0.0 | module load glpk/5.0 |
| raster | 4.0.0 | module load GDAL/3.1.0 SQLite/3.23.1 PROJ/6.3.2 GEOS/3.7.1 |
| xcms | 4.0.0 | module load netCDF/4.5.0 Szip/2.1.1 |
| scFunctions | 4.0.0 | module load GEOS/3.7.1 GCC/5.4.0-2.26 |
| Seurat(4.3.0) | 4.0.0 | module load GEOS/3.7.1 GCC/5.4.0-2.26 libpng/1.6.24 |
| Seurat(5.0.1) | 4.2.0 | module load GEOS/3.7.1 GCC/7.2.0-2.29 libpng/1.6.24 glpk/5.0 |
| SimBu | 4.0.0 | module load GCC/5.4.0-2.26 |
| RNetCDF | 3.6.0 | module load netCDF/4.7.4 |
| Nebulosa | 4.0.0 | module load GEOS/3.7.1 GCC/5.4.0-2.26 |
| BioEnricher | 4.3.2 | module load GCC/7.2.0-2.29 libpng/1.6.24 |
| MEGENA | 4.2.0 | module load GCC/7.2.0-2.29 glpk/5.0 |
| devtools | 4.2.0/4.3.2 | module load GCC/9.4.0 |
| monocle3 | 4.2.0 | module load GCC/7.2.0-2.29 glpk/5.0 PROJ/6.3.2 GDAL/3.1.0 GEOS/3.7.1 |
| DESeq2 | 4.2.0 | module load GCC/5.4.0-2.26 libpng/1.6.24 glpk/5.0 |
| GenomicFeatures | 4.2.0 | module load GCC/5.4.0-2.26 libpng/1.6.24 |
其它库缺失可以加载对应的库，见 常用库缺失解决办法
'GLIBC_x.xx' not found 报错解决办法，见 'GLIBC_x.xx' not found
R 源码编译及部分复杂包安装¶
4.2.0¶
devtools¶
$ module load R/4.2.0 GCC/9.4.0 freetype/2.6.5 harfbuzz/1.7.5 fribidi/1.0.13
$ Rscript -e 'install.packages(c("devtools"), repos="http://cran.us.r-project.org")'
scRNA 镜像¶
igraph¶
安装 igraph_2.0.3 时报错，error: ‘isnan’ is already declared in this scope using std::isnan;，可以有三种解决方案：
-
方案1
安装低版本的
igraph，测试安装1.6.0可行。 -
方案2
使用
GCC 7，module load GCC/7.2.0-2.29 -
方案3
更改源码，同时也要加载
GCC 5，module load GCC/5.4.0-2.26。下载源码包，解压，找到这2个源码文件src/vendor/cigraph/src/community/infomap/infomap.cc，src/vendor/cigraph/src/community/walktrap/walktrap.cpp，将其中的using std::isnan;给注释掉，然后再打包，再使用该源码包安装R CMD INSTALL igraph_2.0.3.1.tar.gz。
ggtree¶
ggtree 安装过程中报错 object 'rect_to_poly' not found，根据作者的说法是 rect_to_poly 在 geom_hilight 中有使用，但这个函数有问题，然后在 ggplot2 中被移除了，导致这个报错。作者给的临时解决办法是根据 ggplot2 中新的实现，在 ggtree 中自己实现 rect_to_poly 这个函数，具体见 copy rect_to_poly, #601 。解决办法作者在这里说得不是很详细，翻源码看了一下，做了一番测试，解决方法如下：
下载 ggtree 源码，这里使用的 ggtree_3.6.2.tar.gz，解压，将 R/geom_hilight.R 中第 486 行代码注释，然后添加新的 rect_to_poly 实现，如下所示。
# rect_to_poly <- getFromNamespace("rect_to_poly", "ggplot2")
rect_to_poly <- function(xmin, xmax, ymin, ymax) {
data_frame0(
y = c(ymax, ymax, ymin, ymin, ymax),
x = c(xmin, xmax, xmax, xmin, xmin)
)
}
$ tar -czvf ggtree_3.6.2.1.tar.gz ggtree
$ R CMD INSTALL ggtree_3.6.2.1.tar.gz
R 4.3.2¶
R 编译安装¶
在交互节点安装
$ wget https://mirror.nju.edu.cn/CRAN/src/base/R-4/R-4.3.2.tar.gz
$ tar xf R-4.3.2.tar.gz
$ cd R-4.3.2
$ module load PCRE/10.00
$ ./configure --enable-R-shlib --with-x --with-cairo --prefix=/DIR/
$ make -j12
$ make install
devtools¶
$ module load R/4.3.2 GCC/9.4.0 freetype/2.6.5 harfbuzz/1.7.5 fribidi/1.0.13 git/2.17.0
$ Rscript -e 'install.packages(c("devtools"), repos="http://cran.us.r-project.org")'
部分错误解决¶
-
C++17 standard requested but CXX17 is not defined安装R包的过程中出现报错
C++17 standard requested but CXX17 is not defined，解决办法为加载高版本GCC，然后设置R相关环境变量。$ module load GCC/7.2.0-2.29 $ mkdir -p ~/.R $ echo 'CXX17 = g++ -std=c++17 -fPIC' >> ~/.R/Makevars -
address 0x20, cause 'memory not mapped'R包安装或运行过程中，出现如下报错可以通过重新安装Rcpp解决*** caught segfault *** address 0x20, cause 'memory not mapped'$ >remove.packeages('Rcpp') $ >install.packages('Rcpp')
Warning
仅限校内使用，校外浏览器无法打开rstudio server。
-
载入rstudio
如果没有配置module，请先配置module，见 module。
$ module load RStudio/4.2 -
提交rstudio作业
$ rstudio_submit Job <80178229> is submitted to queue <normal>. -
查看作业输出
作业正常运行后，使用bpeek命令查看作业输出信息。第7行中，login_port为集群登录端口，login_ip为集群登录IP；13, 14行的用户名和密码为网页端rstudio的登录用户名和密码。
$ bpeek 80178229 << output from stdout >> << output from stderr >> 1. SSH tunnel from your workstation using the following command: ssh -p login_port -N -L 0.0.0.0:58093:c03n01:58093 username@login_ip and point your web browser to http://login_ip:58093 2. log in to RStudio Server using the following credentials: user: username password: OyKPU9F/WM+gLWr432mk When done using RStudio Server, terminate the job by: 1. Exit the RStudio Session ("power" button in the top right corner of the RStudio window) 2. Issue the following command on the login node: bkill 80178229 -
端口转发
即上面第7行代码的内容，
-L参数部分每次都不相同。将运行在计算节点的rstudio server服务端口转发至登录节点，以便用户能在个人PC上的浏览器中打开rstudio server。在使用rstudio过程中，需要保持该命令在终端中一直运行；rstudio作业结束后，按ctrc+c组合键结束该命令即可。Warning
该命令需要在登录节点运行，不能在交互节点运行。
$ ssh -p login_port -N -L login_ip:58093:sg59:58093 username@login_ip -
打开rstudio server
在个人PC浏览器中打开链接,
login_ip:58093，其中58093与上面-L参数的login_ip:58093保持一致，打开后分别输入上面的用户名和密码即可。有时可能因为存储压力交大，rstudio server后台启动时间较长，导致浏览器页面打开时间较长，此状况等几分钟即可。用户可在rstudio中自行安装R包，默认安装路径为
${HOME}/R/rstudio/4.2/，不同rstuio版本此路径不同。部分常用R包也可由管理员安装在公共路径中供用户使用。require(ggplot2) data(diamonds) set.seed(42) small <- diamonds[sample(nrow(diamonds), 1000), ] p <- ggplot(data=small, mapping=aes(x=carat, y=price, shape=cut, colour=color)) p+geom_point()
-
注意事项
-
一个浏览器中只能打开一个rstudio页面；
-
rstudio作业被提交在interactive队列，该队列每个用户的作业数有限制，请勿提多个studio作业；
-
每个rstudio作业的时长与interactive上的作业时长一致，一般为24h，超时自动被系统杀掉；
-
请勿在Rstudio中运行使用非常多内存的程序(30G)，否则会被系统杀掉；杀掉之后再启动Rstudio会加载之前的环境和数据，导致Rstudio超内存限制启动失败(Bus error)，解决办法为删除目录
~/.local/share/rstudio
-
集群MySQL数据库使用¶
集群的MySQL数据库server端运行在s005节点，需要使用的同学请联系管理员获取用户名和密码，可在任何节点使用，只需指定host（-h）为s005即可，直接的使用命令为：
mysql -uUSERNAME -pPASSWORD -h s005
载入python¶
集群安装了多个python，如果需要使用Python，用下面的命令载入anaconda或python。
module load Anaconda2/4.0.0
安装python 模块¶
Anaconda自己带了很多常用的python模块，如果有些需要使用模块没有，可以使用pip命令自己安装，如
pip install --user biopython
也可以用 --prefix 参数指定安装位置
pip install --prefix=$PREFIX_PATH biopython
此外可以源码安装，--prefix 参数指定安装位置，安装的目录需要提前建好，如 ~/software/basenji/0.2/，PYTHONPATH 需要的路径也需要提前创建建好，$PREFIX_PATH/lib/python3.6/site-packages/ 或 $PREFIX_PATH/lib/python2.7/site-packages/。
PYTHONPATH=$PREFIX_PATH/lib/python3.6/site-packages/lib/python2.7/site-packages/ python setup.py install --prefix=$PREFIX_PATH
还有另一种源码安装方式，如
git clone https://github.com/madmaze/pytesseract.git
cd pytesseract && pip install .
此时biopypthon被安装到了 ~/.local/lib 目录内。然后可以下面的命令检测是否正常安装
python -c "import Bio"
如果出现无法引用这个安装模块的情况，需要设置一下PYTHONPATH变量，如
PYTHONPATH=$PREFIX_PATH/lib/python3.6/site-packages/lib/python2.7/site-packages/
export $PYTHONPATH
更多python包安装方式见 conda, python包安装。
虚拟环境¶
需要安装大量包时，为了避免干扰，可以单独建立虚拟环境。
# 虚拟环境位置
$ mkdir django
# 创建虚拟环境
$ python -m venv django
$ ls django/
bin include lib lib64 pyvenv.cfg
# 激活虚拟环境
$ source django/bin/activate
(django) $
mamba是一个基于conda的快速包管理器，可以解决conda在处理大型环境时速度较慢的问题。与conda类似，mamba可以帮助用户创建、配置、管理和分享环境和软件包。mamba是一个开源软件，核心部分由C++编写。主要具有以下特点：
-
速度快：相比于conda，mamba在安装和更新软件包时更快，尤其是在处理大型环境时表现更加出色；
-
轻量级：mamba在安装和运行时的内存占用更小，因此可以更快地启动和运行；
-
兼容conda：mamba兼容Conda的所有功能和包，因此可以无缝地切换到mamba，而不需要重新安装或更改现有的环境；
-
高度可定制：mamba提供了一些高级功能，例如并行安装、交互式进度条、缓存下载的包等等，可以通过配置文件进行调整；
-
多线程：mamba支持多线程并行处理软件包，因此在大型环境中更加高效；
mamba尽可能兼容conda，在解析、安装或卸载软件包等方面和conda具有相同的命令。
mamba同时也是一个巨大的包管理生态的一部分。该生态还包含quetz，一种开源的conda软件包的服务端；以及boa，一种快速的conda软件包的生成器。
micromamba是mamba的精简版，由C++编写。其文件非常小，不需要base环境和Python。由于它是静态版本，它可以放置任意位置，并且能良好运行。
官方文档：https://mamba.readthedocs.io/
mamba有2中安装方式 Mambaforge 和 micromamba。
安装¶
micromamba¶
$ mkdir ~/bin/
$ curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xvj bin/micromamba
# 配置环境变量，配置完成之后micromamba安装的软件和创建的环境默认路径为~/micromamba
$ ~/bin/micromamba shell init -s bash -p ~/micromamba
# 放方便使用，可以使用alias将micromamba改为mamba
$ echo "alias mamba=micromamba" >> ~/.bashrc
$ source ~/.bashrc
调用集群micromamba
module load micromamba
Mambaforge¶
从 Miniforge3-23.3.1-0 开始，Miniforge3 和 Mambaforge 完全一样，官方建议使用Miniforge，Mambaforge 后面可能会被废弃。
以下为 Miniforge 的介绍，该项目用于替代 Anaconda。
Miniforge是一款Python环境和包管理工具，相比Anaconda，推荐使用Miniforge的原因主要有以下三个方面。
首先，miniforge集成了Anaconda的核心工具：conda。conda是一个包和环境管理工具，因此，miniforge里面的conda和Anaconda里面的conda完全一样；你能用Anaconda做的安装、升级、删除包等功能，miniforge都能做；你能用Anaconda做的conda虚拟环境管理，miniforge也都能做。
其次，miniforge是由社区主导，用GitHub托管，完全免费，使用 （而且只用）conda-forge 作为（默认）下载channel，避开了Anaconda的repository，从而也就避开了商业使用被Anaconda追责的问题。
最后，Miniforge相比Anaconda更为灵活轻便，安装体积小、运行速度快、支持mamba、支持PyPy等。
$ wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh
# 默认安装目录为 ~/miniforge3/
$ sh Miniforge3-Linux-x86_64.sh -b -f
# 初始化
$ ~/miniforge3/bin/conda init
# 如果不想在账号登录时就启用 base 环境，可以如下设置。集群上建议如此设置
$ ~/miniforge3/bin/conda config --set auto_activate_base false
配置源¶
与conda类似，首次使用时需要配置国内的源以加快软件安装速度。
将以下内容保存到 ~/.mambarc 即可。
channels:
- defaults
show_channel_urls: true
default_channels:
- https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
- https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
- https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
使用¶
# 激活mamba环境
$ mamba activate
(base) $
# 安装软件
(base) $ mamba install -c bioconda bwa
(base) $ which bwa
~/micromamba/bin/bwa
# 创建环境，可以用-p指定创建的环境的路径，默认路径为上面配置的路径~/micromamba/
$ mamba create -n RNASeq
# 激活创建的环境
$ mamba activate RNASeq
(RNASeq) $
# 在RNASeq环境中安装软件
(RNASeq) $ mamba install -c bioconda STAR
(base) $ which STAR
~/micromamba/envs/RNASeq/bin/STAR
# 退出RNASeq环境
(RNASeq) $ mamba deactivate
(base) $
# 创建python版本为3.10的环境，并安装pytorch
$ mamba create -n torch python=3.10
$ mamba activate torch
(torch) micromamba install pytorch
# 删除环境
$ mamba remove -n pytorch --all # 会有目录残留
$ mamba env remove -p pytorch # 无目录残留
# 退出 mamba 环境
(base) $ mamba deactivate
$
脚本中调用¶
$ mamba run -n rna-seq STAR --help
生信流程软件-nextflow¶
当生信分析的内容数据比较多、相关的软件参数以及流程比较成熟时，我们可以采用一些现有的流程管理软件来编写生信分析流程，方便项目管理和后来者接手，相比于自己用perl、python什么的来串分析流程，专用的流程管理软件可以使流程结构更清晰、适应很多不同环境的系统以及一些其它很有用的功能。常用的流程软件有nextflow、snakemake、makefile、bpipe、WDL等，见过用得比较多的是snakemake和nextflow，前者基于python，后者基于java拓展语言。
nextflow对云环境和容器的支持比较好，方便流程迁移，还有例如动态资源申请、错误重试（某个步骤跑出错了，可以自动重跑）、类似于程序断点的resume功能（修改了流程脚本后重跑可以利用之前跑出来的数据只从这一步开始跑）、部署简单、 对系统环境依赖很小（只要求有Java8）、不需要系统API就可以支持PBS、SGE、slurm、LSF等作业调度系统以及本地运行，因此这里选择研究使用nextflow。
研究这个软件的初衷是近期看了一些用户跑callsnp的流程，流程写在一个shell脚本里，因为bwa使用20个核心，因此在申请资源的时候写20核，bwa跑完之后资源也无法释放，占着整个节点跑后面samtools、picad之类的一些单线程的程序，造成集群资源的极大浪费，生信分析里面这种情况很常见。还有一个用户痛点，就是在跑trimommatic、GATK等java程序时，极容易因为内存的原因导致程序运行失败，nextflow的动态资源申请、错误重试功能（每次重跑申请更多内存或者提交到大内存队列）可以有效缓解整个问题。
这个软件发到了NBT上，还是可以的，这篇文章里还比较了一下几种主流流程软件，https://www.nature.com/articles/nbt.3820.epdf
nextflow安装¶
nextflow自己安装，一行命令搞定。如果系统上java版本较低，运行时可能需要安装高版本的java。
安装过程中主要是下载各种java依赖包，依赖包的安装目录为 ~/.nextflow/。
curl -s https://get.nextflow.io | bash
也可以使用集群上安装好的，第一次使用时会自动下载java依赖包。
module load nextflow
nextflow基本概念¶
nextflow与我们平常写的shell、perl、python等脚本，逻辑上不太一样，需要在用的过程中细细体会。
nextflow中有2个核心概念process和channel。
nextflow的主体部分由一个个process组成，process之间相互独立，如果没有channel的关联原则上所有process可以同时并行运行，将任务分发到整个集群上，原则上一个process跑一个软件如bwa、GATK等，可以随便自己写。
process之间由channel沟通，其实channel就是个异步命名管道（asynchronous FIFO queues），负责process的输入与输出，将一个的process的输出channel作为另外一个process的输入channel，实现process之间的先后运行关系。有个特别需要注意的地方是channel在一个process输出后，后面只能被一个process使用，如要被多个process同时使用，可以将整个channel复制成多个不同名字的channel，分别用到不同的channel中。
nextflow中主要内容虽然都是process和channel，但因为各种需要，还是需要写一些脚本的脚本来写能实际使用且功能完善的流程，主要是字符串、变量、数组、maps（perl中hash或python中的字典）正则表达式、条件判断，以及文件操作。细节可以参照https://www.nextflow.io/docs/latest/script.html#pipeline-page
nextflow的脚本语言从一个叫Groovy的东西拓展而来，如果觉得上面那个链接上的东西不够详细，可以参考Groovy的文档 http://groovy-lang.org/syntax.html
process介绍¶
example1
#!/usr/bin/env nextflow
params.str = 'Hello world!'
process splitLetters {
output:
file 'chunk_*' into letters mode flatten
"""
printf '${params.str}' | split -b 6 - chunk_
"""
}
process convertToUpper {
input:
file x from letters
output:
stdout result
"""
cat $x | tr '[a-z]' '[A-Z]'
"""
}
result.subscribe {
println it.trim()}
process是整个nextflow的核心部分，流程的主要执行部分在这里完成，定义形式有点像其它脚本语言里的函数，以process关键字开头，可以看看下面这个example，process内从上到下依次是
各种执行（Directives）、输入channel（Inputs）、输出channel（Outputs）、执行条件（when）、脚本（script）
Directives主要有
afterScript（这个process执行后运行的自定义内容，一般为shell脚本，比如用于删除这一步产生的后面不需要的数据）、
beforeScript（这个process执行前运行的自定义内容，一般为shell脚本，比如载入这个process的运行环境）、
executor（指定process执行方式，比如本地执行（local）、提交到pbs（pbs）、提交到（sge）、提交到k8s（k8s）等）
cpus（这个process申请的核心数，在pbs、sge中比较有用）、
memory（这个process申请的内存）、
queue（指定作业提交的集群队列）、
clusterOptions（一般用于指定特定的集群作业提交参数，比如pbs错误输出文件）
MaxErrors（这个process进行错误重试的次数）、
errorStrategy（process出错后的处理策略，比如重试（retry）、忽略（ingore）、终止process（terminate）等）、
tag（使用变量设置process标签，方便在日志中区分process执行过程，比如某个process跑的bwa，其中有个数据的bwa跑错了，因为设置了标签很容易在nextflow的运行日志中找到是哪个数据跑出了问题）、
container（在docker中执行process）
等，其它的Directives见https://www.nextflow.io/docs/latest/process.html#directives
Input和Output关键字分别定义输入、输出channel，详细用法见https://www.nextflow.io/docs/latest/process.html#inputs
when关键字定义process的执行条件，如这个例子中需要同时满足这个两个条件这个process才能被执行。还有另一个比较用途是在调试nextflow过程中注释process，只需要when:false，这样process就不会被执行。
process find {
input:
file proteins
val type from dbtype
when:
proteins.name =~ /^BB11.*/ && type == 'nr'
script:
""" blastp -query $proteins -db nr """
}
Script中主要写命令、代码等，需要用一对"""包裹起来，默认是shell脚本，如上一个脚本所示，当然也可以是perl、python等，如下所示
process perlStuff {
""" #!/usr/bin/perl
print 'Hi there!' . '\n'; """
}
process pyStuff {
""" #!/usr/bin/python
x = 'Hello' y = 'world!' print "%s - %s" % (x,y) """
}
此外，还可以用于条件控制，如下所示，可以根据输入不同，运行不同的程序
seq_to_align = ...
mode = 'tcoffee'
process align {
input:
file seq_to_aln from sequences
script:
if( mode == 'tcoffee' )
"""
t_coffee -in $seq_to_aln > out_file
"""
else if( mode == 'mafft' )
"""
mafft --anysymbol --parttree --quiet $seq_to_aln > out_file
"""
else if( mode == 'clustalo' )
"""
clustalo -i $seq_to_aln -o out_file
"""
else
error "Invalid alignment mode: ${mode}"
}
channel这东西我也讲不太好，可以结合给的例子和文档看，https://www.nextflow.io/docs/latest/channel.html
config配置文件¶
为了更方便管理，nextflow脚本写好之后尽量不再修改，所有很多参数的修改可以在config文件中进行。如每个process使用的资源，可以根据需要在config（随便命名）文件中修改，如下 所有的process都提到pbs中，Run_bwa这个process申请4个核，Run_GATK这个process申请8个核
params.genome="/public/home/software/test/callsnp/data/Gbarbadense_genome.fasta"
params.read_file="/public/home/software/test/callsnp/data/*_{1,2}.fastq.gz"
process {
executor = 'pbs'
withName: 'Run_bwa' {
cpus = 4
memory = 8.GB
queue = 'batch'
}
withName: 'Run_GATK' {
cpus = 8
queue = 'high'
}
}
使用方法为
nextflow run -c config callsnp.nf
更详细的介绍见 https://www.nextflow.io/docs/latest/config.html
执行nextflow¶
nextflow run
还有一些clean、clone、cloud、log等执行。
run的主要参数有
-c 指定配置文件
-with-trace process执行跟踪文件
-with-timeline process执行时间线，方便看各步骤跑的时间
--，指定输入参数，比如后面的例子中的params.genome这个参数，可以--genome '/public/home/software/test/callsnp/data/Gbarbadense_genome.fasta'这样在运行时指定
more example¶
这个里面有不少常用的流程
https://github.com/nextflow-io/awesome-nextflow/
下面这个是根据集群上一个同学跑的流程改写的一个nextflow脚本，看着有点长，其实逻辑很简单，写了详细的注释，可以参照改写自己的流程
nextflow_example.nf
//结果输出目录
params.output = "/public/home/software/test/callsnp/output"
//参考基因组
params.genome="/public/home/software/test/callsnp/data/Gbarbadense_genome.fasta"
//reads路径
params.read_file="/public/home/software/test/callsnp/data/*_{1,2}.fastq.gz"
//将参考基因组转换成file对象，以便使用getParent、getBaseName方法获取参考基因组所在路径和去掉.fa .fasta后的basename
ref_file=file(params.genome)
ref_dir=ref_file.getParent()
ref_base=ref_file.getBaseName()
//fromFilePairs默认读入一对reads，可以通过size参数设置
Channel.fromFilePairs(params.read_file)
.ifEmpty{error "Cannot find reads $params.read_file"}
.into {reads}
//判断是否已经存在bwa索引文件，存在则将所有索引文件放入index_exi 这个channel；
//否则运行Run_bwa_index这process来建索引，然后输出到名字为index_exi的channel
Run_bwa_index
if(file(params.genome+".amb").exists()){
index_exi = Channel.fromPath("${params.genome}.*")
}else{
process Run_bwa_index {
//申请一个CPU核心
cpus 1
//使用PBS作业调度系统，使用local可在本地跑，也可以支持sge、slurm、lsf等调度系统
executor = 'pbs'
//将output文件复制到ref_dir这个目录，mode还可以选move等
publishDir "ref_dir",mode:'copy'
//输入文件
input:
file genome from ref_file
//输出
output:
file "${genome}.*" into index_exi
//该process运行的条件，bwa index不存在时运行，其实这个地方有点重复
when:
!file(params.genome+".amb").exists()
//两个"""包裹的部分是用户自己的各种脚本，一般用户需要跑的程序都写在这里，默认是shell脚本，还可以是perl、python、R等
"""
module purge
module load BWA
bwa index $genome
"""
}
}
//给后面GATK运行创建genome index
process Run_dict_fai {
cpus 1
executor = 'pbs'
//pbs申请的memory，可以直接定义数字，也可以如下动态定义
//如果这个process运行失败，可以重新开始，每次重新开始申请的内存增加2GB
memory { 2.GB * task.attempt }
//process运行出错时的行为，默认直接退出。因为java作业容易因为内存的原因而运行出错，
//因此这里设置为retry，失败重新运行
//还可以有ignore、finish、terminate
errorStrategy 'retry'
//process运行失败后，重新尝试的次数
maxRetries 3
//这个process的output的内容copy到ref_dir目录
publishDir "ref_dir",mode:'copy'
input:
file genome from ref_file
//将定义的这些文件作为一个整体输出到GATK_index这个channel
output:
set file("${genome}"),file("${genome}.fai"),file("${ref_base}.dict") into GATK_index
//nextflow脚本，这里根据上面memory的值定义了一个内存值给下面的picard使用
script:
picardmem = "${task.memory}".replaceAll(/ GB/,"g")
"""
module purge
module load picard
java -Xmx${picardmem} -jar \${EBROOTPICARD}/picard.jar CreateSequenceDictionary R=${genome} O=${ref_base}.dict
module purge
module load SAMtools/1.8
samtools faidx ${genome} > ${genome}.fai
"""
}
//运行BWA比对
process Run_bwa {
cpus 6
executor = 'pbs'
input:
//从reads中获取read id和两条read序列
set val(id),file(readfile) from reads
//输入bwa index文件，collect方法将这个channel中的所有item集合为一个list
//否则就会一个个文件循环emit，不符合我们的要求
file index from index_exi.collect()
//将read id和生成的Sam文件放入channel bwa_sam中，给后面的process使用
output:
set val("${id}"),file("${id}.sam") into bwa_sam
//process运行条件，true为运行，false为不运行，在此可以不需要这个when条件，仅用于测试
when:
true
//通过输入的bwa_index文件提取bwa build生成的index文件的prefix，注意这里是Gbarbadense_genome.fasta，而不是Gbarbadense_genome
//当然可以通过在前面的bwa build 加-p 指定生成的index文件的prefix为前面提取的ref_base,那么久可以不用这一步，下面bwa mem的index_base改为ref_base即可
script:
index_base = index[0].toString() - ~/.amb/
"""
module purge
module load BWA
bwa mem -M -t ${task.cpus} -R '@RG\\tID:$id\\tLB:HISEQ10X\\tSM:$id' ${index_base} $readfile > ${id}.sam
"""
}
//运行picar，给sam文件排序、去重
process Run_picard {
executor = 'pbs'
cpus 1
//失败重试，动态资源申请
memory { 2.GB * task.attempt }
errorStrategy 'retry'
maxRetries 3
//这2个结果后面的process不会用到，但结果可能有用，可以move到自己指定的目录
publishDir "$params.output/metrics",pattern:"*_metrics.txt",mode:'move'
//删除不需要的文件
afterScript "rm ${samfile};rm ${id}_srt.bam"
input:
//Run_bwa生成的output channel作为这一步的input channel
set val(id),file(samfile) from bwa_sam
//输入参考基因组
file genome from ref_file
output:
//输出排序后的bam
file "${id}_srt.bam" into srtbam
//输出metrics文件
file "${id}_metrics.txt" into metrics
//将id和相应的排序去重后的bam文件输入到2个channel中，因为一个channel只能使用一次，后面有2个process需要用到这个output channel的内容
//所以需要输出2个内容相同、名称不同的channel
set val("${id}"), file("${id}_srt_redup.bam") into samtools_input,GATK_input
//所用同上，调试之用
when:
true
//作用同上，用于给java程序设定内存参数
script:
picardmem = "${task.memory}".replaceAll(/ GB/,"g")
"""
module purge
module load picard
java -Xmx${picardmem} -jar \${EBROOTPICARD}/picard.jar SortSam I=${samfile} O=${id}_srt.bam SORT_ORDER=coordinate
java -Xmx${picardmem} -jar \${EBROOTPICARD}/picard.jar MarkDuplicates INPUT=${id}_srt.bam OUTPUT=${id}_srt_redup.bam CREATE_INDEX=true VALIDATION_STRINGENCY=SILENT METRICS_FILE=${id}_metrics.txt
"""
}
//samtools callsnp
process Run_samtools {
cpus 1
executor = 'pbs'
//output channel中的文件move到指定目录
publishDir "$params.output/samtools",mode:'move'
input:
set val(id),file(bam) from samtools_input
file genome from ref_file
output:
file "${id}.samtools.vcf" into samtoolsvcf
when:
true
"""
module purge
module load SAMtools/1.8
module load BCFtools/1.6
samtools mpileup -t DP -t SP -ugf ${genome} ${bam} |bcftools call --threads ${task.cpus} -mo ${id}.samtools.vcf
"""
}
process Run_GATK {
cpus 4
executor = 'pbs'
memory { 20.GB * task.attempt }
errorStrategy 'retry'
maxRetries 3
publishDir "$params.output/GATK",mode:'move'
input:
//输入bam
set val(id),file(bam) from GATK_input
//输入index
set file(genome),file(fai),file(dict) from GATK_index
//将所有生成文件输出到GATKvcf channel中
output:
file "*" into GATKvcf
when:
true
script:
gatkmem = "${task.memory}".replaceAll(/ GB/,"g")
"""
module purge
module load GATK/3.8-0-Java-1.8.0_92
java -Xmx${gatkmem} -jar \$EBROOTGATK/GenomeAnalysisTK.jar -R ${genome} -T HaplotypeCaller --emitRefConfidence GVCF -I ${bam} -o ${id}.gatk.vcf --variant_index_type LINEAR --variant_index_parameter 128000 -nct ${task.cpus}
"""
}
Spark on cluster¶
随着测序数据量的增长，目前的软件处理这些大批量的数据越来越费时间，因此不少人将大数据相关的技术应用在生物信息行业，以期加速测序数据的处理。早期apache基金会根据google的三篇论文开发了hadoop套件(HDFS集群文件系统、MapReduce数据处理框架、yarn集群作业调度器)利用大量廉价的服务器和网络，以较低的成本满足互联网行业大数据的处理需求。hadoop的数据处理模型只有map和reduce两种，对数据做复杂处理时编程较为复杂，且hadoop运行时需要在磁盘上频繁地来回读写数据（计算中间结果落盘），导致程序运行时间较长，另外hadoop也不适合迭代计算(如机器学习、图计算等)，交互式处理(数据挖掘) 和流式处理(点击日志分析)，因此目前生产上使用较少（单指MapReduce数据处理框架，HDFS和yarn还是用得比较多）。
针对hadoop的这些缺点，加州大学柏克莱分校技术人员开发了基于存储器内运算技术的spark大数据处理框架，所有数据最后落盘之前都在内存中分析运算，大大加快了数据处理速度，相比于hadoop，其速度可提高上100倍。Spark由Scala语言编写，提供了多种数据处理方式（hadoop只有2种），大大降低了复杂任务的编程难度。spark可以使用shell交互运行，方便程序调试，同时也原生支持java、python的API。Spark提供了多个领域的计算解决方案，包括批处理、交互式查询（Spark SQL）、实时流处理（Spark Streaming）、机器学习（Spark MLlib）和图计算（Spark GraphX），因此目前spark是实际项目中使用很频繁的一种大数据框架。
由于spark可脱离HDFS和yarn调度器独立运行，因此spark可运行于普通HPC集群上。重点实验室集群的作业调度系统lsf提供了运行spark集群和程序的相关脚本(lsf-spark-submit.sh,lsf-spark-shell.sh,以及我改写的lsf-spark-app.sh)。GATK4提供了多个工具的spark版本(工具名以spark结尾)，使其可以轻松地运行在spark集群上，相比单机版本其运算速度有了很大的提高。目前集群上划了部分节点放入spark队列，运行spark作业。下面以HaplotypeCallerSpark为例说明，spark作业如何在集群上运行(lsf-spark-app.sh 后面部分都需要在一行，不能用\断行，这里为了排版能看清人为断行了)。
#BSUB -J gatk
#BSUB -n 100
#BSUB -o %J.gatk.out
#BSUB -e %J.gatk.err
#BSUB -R span[ptile=20]
#BSUB -q spark
datadir=/public/home/test/haoliu/work/callsnp/data/
master=`echo $LSB_MCPU_HOSTS|awk '{print $1}'`
echo spark master is $master
echo "gatk HaplotypeCaller"
lsf-spark-app.sh --executor-memory 20g --driver-memory 20g --conf spark.driver.userClassPathFirst=false --conf spark.io.compression.codec=lzf
--conf spark.driver.maxResultSize=0
--conf spark.executor.extraJavaOptions='-DGATK_STACKTRACE_ON_USER_EXCEPTION=true -Dsamjdk.use_async_io_read_samtools=false
-Dsamjdk.use_async_io_write_samtools=false -Dsamjdk.use_async_io_write_tribble=false -Dsamjdk.compression_level=2'
--conf spark.driver.extraJavaOptions='-DGATK_STACKTRACE_ON_USER_EXCEPTION=true -Dsamjdk.use_async_io_read_samtools=false
-Dsamjdk.use_async_io_write_samtools=false -Dsamjdk.use_async_io_write_tribble=false -Dsamjdk.compression_level=2'
--conf spark.kryoserializer.buffer.max=1024m --conf spark.yarn.executor.memoryOverhead=600
/public/home/software/opt/bio/software/GATK/4.1.3.0/gatk-package-4.1.3.0-local.jar HaplotypeCallerSpark
-R ${datadir}/hg38.fa -I ${datadir}/ERR194146_sort_redup.bam -O ${datadir}/ERR194146.vcf --spark-master spark://${master}:6311
测试数据为人30x的全基因组数据，52GB的fq.gz。HaplotypeCallerSpark测试是用了120核，运行时间为2054s；同样的数据HaplotypeCaller，胖节点上使用100核，运行时间138501s。HaplotypeCallerSpark加速了60多倍，加速效果比较明显。
Sentieon(replacing BWA+GATK)¶
Warning
sentieon license 已过期，已无法使用。推荐使用GATK或deepvariant，或使用GPU进行加速的call变异工具 parabricks。
sentieon介绍¶
sentieon是Sentieon公司开发的用于替代GATK进行变异检测的数据分析套件，其一个软件就可以搞定变异检测所需的全部流程，因为其采用的数学模型与GATK相同，sentieon结果与GATK结果的一致性非常高(99.7%)。Sentieon主要有一下几个特点：
- 精度高、重复性好：GATK 采用了downsampling的方式进行取样，即在测序深度非常高的区域进行采样然后检测变异，因为变异检测的精度和重复性不是非常高。sentieon没有downsampling，因此精度和重复性会比GATK稍好，这在医疗领域比较重要；
- 速度快：sentieon改写了BWA，相比原生的BWA，速度提高1倍；同时排序和重复序列标记模块也比GATK模块中的快； sentieon速度的巨大提升主要体现在变异检测这一步，可达20-50倍；从fq->vcf，相比BWA/GATK速度提升至少10倍以上；
- 大样本 joint calling: 可以支持10万个样本同时joint calling，测试使用水稻3200个样本同时跑joint calling，单节点40小时就可以完成；
- 对存储IO要求高：如果是单机运行，建议使用固态盘。作重集群存储带宽基本满足要求。之前测试，400个haplotyper任务同时跑，存储读带宽峰值高达90GB/s。3200个水稻样本单节点36线程joint calling，节点读带宽稳定在3-4GB/s；
- 纯软件解决方案：目前有不少加速GATK的方案，大部分都是采用FPGA专有硬件加速，不仅成本较高而且很难大规模地使用，sentieon采用的纯软件方法，可以直接使用现有的硬件，版本更新也很方便；
- 持续更新：与GATK官方同步更新，一般延迟3个月。基本GATK更新版本中比较有用的工具，sentieon基本也会添加在后续更新的版本中。从2015年发布至今，已有几十个版本的更新；
- 大规模实践检验：从2015年发布第一个版本开始，sentieon不仅在FDA举行的各种比赛中表现优异，且在世界范围内为各大药厂、临床机构、科研机构以及生物公司所采用，基本得到了业界的认可
- 官方支持：在使用过程中如遇到任何问题，均可邮件给sentieon公司，基本一到两天内能收到回复；
官方文档：https://support.sentieon.com/manual/
官方参考脚本：https://github.com/Sentieon/sentieon-scripts
作重集群sentieon使用¶
由于实验室多个课题组有大量的群体项目，其中大部分项目都在使用GATK进行变异检测，耗费的资源和时间都比较长。为提高科研效率，节省大家的时间，作重计算平台已采购了Sentieon部署在集群上免费提供给大家使用。此外杨庆勇老师已在集群用户群内上传的sentieon的相关资料和流程，有需要的可以下载参考学习，该流程已适配了作重集群，因此也可直接使用。集群/public/exercise/sentieon/ 目录内也有测试数据，大家可以练习。
benchmark¶
BWA¶
| software/version | runtime(second) | cputime(second) | maxmem(MB) | speedup |
|---|---|---|---|---|
| BWA/0.7.17 | 7232 | 220916 | 42952 | 1 |
| BWA-MEM2/2.2.1 | 4577 | 111560 | 60952 | 1.6x |
| sentieon-BWA/202010.04 | 5085 | 130644 | 15648 | 1.4x |
| sentieon-BWA/202112 | 3888 | 128449 | 16078 | 1.9x |
#BSUB -J bwa
#BSUB -n 36
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load sentieon/202112
module load sentieon/202010.04
module load BWA/0.7.17
module load BWA-MEM2/2.2.1
module load SAMtools/1.9
# fastq文件路径
fq1=/public/home/software/test/callsnp/data/fastq/BYU21001_1.fastq.gz
fq2=/public/home/software/test/callsnp/data/fastq/BYU21001_2.fastq.gz
# 参考基因组文件
fasta=/public/home/software/test/callsnp/data/Gbarbadense_genome.fasta
#sentieon-BWA
sentieon bwa mem -R "@RG\tID:${i}\tSM:${i}\tPL:PL" -t $LSB_DJOB_NUMPROC -K 10000000 $fasta $fq1 $fq2 | sentieon util sort -r $fasta -o ${i}_sorted.bam -t $LSB_DJOB_NUMPROC --sam2bam -i -
#bwa
bwa mem -t $LSB_DJOB_NUMPROC $fasta $fq1 $fq2 | samtools sort -@${LSB_DJOB_NUMPROC} -o ${i}_sorted.bam -
#bwa-mem2
bwa-mem2.avx512bw mem -t $LSB_DJOB_NUMPROC $fasta $fq1 $fq2 | samtools sort -@${LSB_DJOB_NUMPROC} -o ${i}_sorted.bam -
minimap2¶
| software/version | runtime(second) | cputime(second) | maxmem(MB) | speedup |
|---|---|---|---|---|
| minimap2/v2.17 | 1182 | 23468 | 6291 | 1 |
| sentieon-minimap2/202112 | 961 | 18750 | 8464 | 1.2x |
module load sentieon/202112;sentieon minimap2 -t 20 -ax map-hifi YJSM.prefix1.fa YJSM.hifi_reads.fastq.gz > YJSM.minimap2.2.sentieon.sam
module load minimap2/v2.17;minimap2 -t 20 -ax map-hifi YJSM.prefix1.fa YJSM.hifi_reads.fastq.gz > YJSM.minimap2.2.sentieon.sam
sentieon使用技巧¶
sentieon使用如果有什么问题，可以邮件给官方，如果问题比较普遍，解决后可以联系管理员整理到这里给大家参考。
- 由于sentieon的BWA相比原生的BWA速度提高了一倍，因此即使不是做变异检测，只用使用BWA比对，也同样可以使用sentieon内的BWA模块，以提高计算速度；
- 杨老师给的流程中使用了cram格式保存BWA比对后的文件，相比bam格式，其占用的存储空间更小，大约只有bam的60%。但这会导致bwa和sort步骤变慢，可以根据自己的需求调整；
- 有同学使用的参考基因组有200万以上的contig，导致sentieon运行非常缓慢。官方给出的建议是使用--interval 1,2,3,4,5,6,7,8,9,10,Pt,Mt之类的参数，只分析感兴趣的chromosome；或者将大量的细碎的contig合并成一个contig，中间有N连接，保证原有reference的所有contig都分析到，但是需要对最后的VCF做进一步处理以还原为原有的reference；
- joint calling (sentieon --algo GVCFtyper，即合并多样本的haplotyper运行结果) 之前，建议先用vcfconvert模块压缩所有的gvcf文件并建立索引，
sentieon util vcfconvert input.gvcf output.gvcf.gz，然后再join calling，速度会有几十倍的提高（水稻3200个样本的joint calling时间从800h缩短到40h）； - 全基因组运行haplotyper时，不要--bam_output选项，否则速度会变得很慢，而且可能会出错；
- Haplotyper: Only a single sample is allowed in GVCF emit mode, 在使用--emit_mode GVCF的时候，bam文件只能包含单一sample，不支持多sample，否则会出现这个报错。如果BAM文件不是多sample的话，那就应该是@RG line设置有问题。
- 使用GATK call的gvcf文件，也可以使用sentieon进行joint call。
参考脚本¶
拟南芥 sentieon callsnp 流程脚本
拟南芥NGS的测试文件
/public/exercise/sentieon/tair10_1.fastq.gz
/public/exercise/sentieon/tair10_2.fastq.gz
fasta=/public/exercise/sentieon/reference_Tair10/Arabidopsis_thaliana.TAIR10.dna.toplevel.modified.fa
#BSUB -J Sentieon
#BSUB -n 16
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
# 加载所需软件
# module load sentieon/201808.07
export SENTIEON_LICENSE=mn01:9000
module load SAMtools/1.9
release_dir=/public/home/software/opt/bio/software/Sentieon/201808.07
# 样本名称
i="tair10"
# fastq文件路径
fq1=/public/exercise/sentieon/tair10_1.fastq.gz
fq2=/public/exercise/sentieon/tair10_2.fastq.gz
# 参考基因组文件
fasta=/public/exercise/sentieon/reference_Tair10/Arabidopsis_thaliana.TAIR10.dna.toplevel.modified.fa
# 输出文件路径
workdir=`pwd`/ath50x_result
# 需要使用的核心数
nt=16
# 比对信息
group_prefix="read_group_name"
platform="ILLUMINA"
mq=30
[ ! -d $workdir ] && mkdir -p $workdir
cd $workdir
# 输出文件
rawCram=$i.cram
sortedCram=$i.q$mq.sorted.cram
depCram=$i.deduped.cram
realnCram=$i.realn.cram
outvcf=$i.vcf
exec > $workdir/$i.callVCF.log 2>&1 # call vcf的日志文件
# ******************************************
# 1. 利用 BWA-MEM 进行比对并排序
# ******************************************
( $release_dir/bin/sentieon bwa mem -M -R "@RG\tID:${i}\tSM:${i}\tPL:$platform" \
-t $nt -K 10000000 $fasta $fq1 $fq2 || echo -n 'error' ) | samtools sort -@ $nt --output-fmt CRAM \
--reference $fasta -o $rawCram - && samtools index -@ $nt $rawCram
samtools view -hCS -T $fasta -q $mq -o $sortedCram $rawCram && \
samtools index -@ $nt $sortedCram
samtools flagstat $rawCram > $i.stat.raw.txt && \
samtools flagstat $sortedCram > $i.stat.q$mq.txt &
# ******************************************
# 2. Calculate data metrics
# ******************************************
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $sortedCram --algo MeanQualityByCycle ${i}_mq_metrics.txt \
--algo QualDistribution ${i}_qd_metrics.txt --algo GCBias --summary ${i}_gc_summary.txt ${i}_gc_metrics.txt \
--algo AlignmentStat --adapter_seq '' ${i}_aln_metrics.txt --algo InsertSizeMetricAlgo ${i}_is_metrics.txt
$release_dir/bin/sentieon plot metrics -o ${i}_metrics-report.pdf gc=${i}_gc_metrics.txt \
qd=${i}_qd_metrics.txt mq=${i}_mq_metrics.txt isize=${i}_is_metrics.txt
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $sortedCram --algo LocusCollector --fun score_info ${i}_score.txt
# ******************************************
# 3. 去除 Duplicate Reads
# ******************************************
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $sortedCram --algo Dedup --rmdup --cram_write_options version=3.0 \
--score_info ${i}_score.txt --metrics ${i}_dedup_metrics.txt $depCram && rm -f $sortedCram
# ******************************************
# 4. Indel 重排序 (可选)
# 如果只需要最终的比对结果文件，到这里就可以了，这条命令下面的命令都可以注释掉
# ******************************************
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $depCram --algo Realigner --cram_write_options version=3.0 \
$realnCram && rm -f $depCram
# ******************************************
# 5. Variant calling
# ******************************************
$release_dir/bin/sentieon driver -t $nt -r $fasta -i $realnCram --algo Genotyper $outvcf
#!/bin/sh
# *******************************************
# Update with the fullpath location of your sample fastq
set -x
data_dir="$( cd -P "$( dirname "$0" )" && pwd )" #workdir
fastq_1=/public/exercise/sentieon/tair10_1.fastq.gz
fastq_2=/public/exercise/sentieon/tair10_2.fastq.gz
# Update with the location of the reference data files
fasta=/public/exercise/sentieon/reference_Tair10/Arabidopsis_thaliana.TAIR10.dna.toplevel.modified.fa
# Set SENTIEON_LICENSE if it is not set in the environment
module load SAMtools/1.9
#module load sentieon/201808.07
export SENTIEON_LICENSE=mn01:9000
# Update with the location of the Sentieon software package
SENTIEON_INSTALL_DIR=/public/home/software/opt/bio/software/Sentieon/201808.07
# It is important to assign meaningful names in actual cases.
# It is particularly important to assign different read group names.
sample="tair10"
group="G"
platform="ILLUMINA"
# Other settings
nt=16 #number of threads to use in computation
# ******************************************
# 0. Setup
# ******************************************
workdir=$data_dir/result-tair10
mkdir -p $workdir
logfile=$workdir/run.log
exec >$logfile 2>&1
cd $workdir
#Sentieon proprietary compression
bam_option="--bam_compression 1"
# ******************************************
# 1. Mapping reads with BWA-MEM, sorting
# ******************************************
#The results of this call are dependent on the number of threads used. To have number of threads independent results, add chunk size option -K 10000000
# speed up memory allocation malloc in bwa
export LD_PRELOAD=$SENTIEON_INSTALL_DIR/lib/libjemalloc.so
export MALLOC_CONF=lg_dirty_mult:-1
( $SENTIEON_INSTALL_DIR/bin/sentieon bwa mem -M -R "@RG\tID:$group\tSM:$sample\tPL:$platform" -t $nt -K 10000000 $fasta $fastq_1 $fastq_2 || echo -n 'error' ) | $SENTIEON_INSTALL_DIR/bin/sentieon util sort $bam_option -r $fasta -o sorted.bam -t $nt --sam2bam -i -
# ******************************************
# 2. Metrics
# ******************************************
$SENTIEON_INSTALL_DIR/bin/sentieon driver -r $fasta -t $nt -i sorted.bam --algo MeanQualityByCycle mq_metrics.txt --algo QualDistribution qd_metrics.txt --algo GCBias --summary gc_summary.txt gc_metrics.txt --algo AlignmentStat --adapter_seq '' aln_metrics.txt --algo InsertSizeMetricAlgo is_metrics.txt
$SENTIEON_INSTALL_DIR/bin/sentieon plot GCBias -o gc-report.pdf gc_metrics.txt
$SENTIEON_INSTALL_DIR/bin/sentieon plot QualDistribution -o qd-report.pdf qd_metrics.txt
$SENTIEON_INSTALL_DIR/bin/sentieon plot MeanQualityByCycle -o mq-report.pdf mq_metrics.txt
$SENTIEON_INSTALL_DIR/bin/sentieon plot InsertSizeMetricAlgo -o is-report.pdf is_metrics.txt
# ******************************************
# 3. Remove Duplicate Reads
# To mark duplicate reads only without removing them, remove "--rmdup" in the second command
# ******************************************
$SENTIEON_INSTALL_DIR/bin/sentieon driver -t $nt -i sorted.bam --algo LocusCollector --fun score_info score.txt
$SENTIEON_INSTALL_DIR/bin/sentieon driver -t $nt -i sorted.bam --algo Dedup --rmdup --score_info score.txt --metrics dedup_metrics.txt $bam_option deduped.bam
# ******************************************
# ******************************************
# 5. Base recalibration
# ******************************************
# Perform recalibration
$SENTIEON_INSTALL_DIR/bin/sentieon driver -r $fasta -t $nt -i deduped.bam --algo QualCal recal_data.table
# Perform post-calibration check (optional)
$SENTIEON_INSTALL_DIR/bin/sentieon driver -r $fasta -t $nt -i deduped.bam -q recal_data.table --algo QualCal recal_data.table.post
$SENTIEON_INSTALL_DIR/bin/sentieon driver -t $nt --algo QualCal --plot --before recal_data.table --after recal_data.table.post recal.csv
$SENTIEON_INSTALL_DIR/bin/sentieon plot QualCal -o recal_plots.pdf recal.csv
# ******************************************
# 6. HC Variant caller
# Note: Sentieon default setting matches versions before GATK 3.7.
# Starting GATK v3.7, the default settings have been updated multiple times.
# Below shows commands to match GATK v3.7 - 4.1
# Please change according to your desired behavior.
# ******************************************
# Matching GATK 3.7, 3.8, 4.0
#$SENTIEON_INSTALL_DIR/bin/sentieon driver -r $fasta -t $nt -i deduped.bam -q recal_data.table --algo Haplotyper --emit_conf=10 --call_conf=10 output-hc.vcf.gz
# Matching GATK 4.1
$SENTIEON_INSTALL_DIR/bin/sentieon driver -r $fasta -t $nt -i deduped.bam -q recal_data.table --algo Haplotyper --genotype_model multinomial --emit_conf 30 --call_conf 30 output-hc.vcf.gz
其它sentieon脚本
人类NGS的测试文件
/public/exercise/sentieon/1.fastq.gz
/public/exercise/sentieon/2.fastq.gz
fasta=/public/exercise/sentieon/reference/ucsc.hg19_chr22.fasta
dbsnp=/public/exercise/sentieon/reference/dbsnp_135.hg19_chr22.vcf
known_1000G_indels=/public/exercise/sentieon/reference/1000G_phase1.snps.high_confidence.hg19_chr22.sites.vcf
known_Mills_indels=/public/exercise/sentieon/reference/Mills_and_1000G_gold_standard.indels.hg19_chr22.sites.vcf
#BSUB -J Sentieon
#BSUB -n 16
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
# 加载所需软件
# module load sentieon/201808.07
export SENTIEON_LICENSE=mn01:9000
module load SAMtools/1.9
release_dir=/public/home/software/opt/bio/software/Sentieon/201808.07
# 样本名称
i="Test"
# fastq文件路径
fq1=/public/exercise/sentieon/1.fastq.gz
fq2=/public/exercise/sentieon/2.fastq.gz
# 参考基因组文件
fasta=/public/exercise/sentieon/reference/ucsc.hg19_chr22.fasta
# 输出文件路径
workdir=`pwd`/People_result
# 需要使用的核心数
nt=16
# 相应数据库
dbsnp=/public/exercise/sentieon/reference/dbsnp_135.hg19_chr22.vcf
known_1000G_indels=/public/exercise/sentieon/reference/1000G_phase1.snps.high_confidence.hg19_chr22.sites.vcf
known_Mills_indels=/public/exercise/sentieon/reference/Mills_and_1000G_gold_standard.indels.hg19_chr22.sites.vcf
# 比对信息
group_prefix="read_group_name"
platform="ILLUMINA"
mq=30
[ ! -d $workdir ] && mkdir -p $workdir
cd $workdir
# 输出文件
rawCram=$i.cram
sortedCram=$i.q$mq.sorted.cram
depCram=$i.deduped.cram
realnCram=$i.realn.cram
outvcf=$i.vcf
exec > $workdir/$i.callVCF.log 2>&1 # call vcf的日志文件
# ******************************************
# 1. 利用 BWA-MEM 进行比对并排序
# ******************************************
( $release_dir/bin/sentieon bwa mem -M -R "@RG\tID:${i}\tSM:${i}\tPL:$platform" \
-t $nt -K 10000000 $fasta $fq1 $fq2 || echo -n 'error' ) | samtools sort -@ $nt --output-fmt CRAM \
--reference $fasta -o $rawCram - && samtools index -@ $nt $rawCram
samtools view -hCS -T $fasta -q $mq -o $sortedCram $rawCram && \
samtools index -@ $nt $sortedCram
samtools flagstat $rawCram > $i.stat.raw.txt && \
samtools flagstat $sortedCram > $i.stat.q$mq.txt &
# ******************************************
# 2. Calculate data metrics
# ******************************************
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $sortedCram --algo MeanQualityByCycle ${i}_mq_metrics.txt \
--algo QualDistribution ${i}_qd_metrics.txt --algo GCBias --summary ${i}_gc_summary.txt ${i}_gc_metrics.txt \
--algo AlignmentStat --adapter_seq '' ${i}_aln_metrics.txt --algo InsertSizeMetricAlgo ${i}_is_metrics.txt
$release_dir/bin/sentieon plot metrics -o ${i}_metrics-report.pdf gc=${i}_gc_metrics.txt \
qd=${i}_qd_metrics.txt mq=${i}_mq_metrics.txt isize=${i}_is_metrics.txt
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $sortedCram --algo LocusCollector --fun score_info ${i}_score.txt
# ******************************************
# 3. 去除 Duplicate Reads
# ******************************************
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $sortedCram --algo Dedup --rmdup --cram_write_options version=3.0 \
--score_info ${i}_score.txt --metrics ${i}_dedup_metrics.txt $depCram && rm -f $sortedCram
# ******************************************
# 4. Indel 重排序 (可选)
# 如果只需要最终的比对结果文件，到这里就可以了，这条命令下面的命令都可以注释掉
# ******************************************
$release_dir/bin/sentieon driver -r $fasta -t $nt -i $depCram --algo Realigner -k ${known_1000G_indels} --cram_write_options version=3.0 \
$realnCram && rm -f $depCram
# ******************************************
# 5. Variant calling
# ******************************************
$release_dir/bin/sentieon driver -t $nt -r $fasta -i $realnCram --algo Genotyper -d ${dbsnp} ${outvcf}
#BSUB -J Sentieon_bwa
#BSUB -n 16
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
# 加载所需软件
module load sentieon/201911
nt=$LSB_DJOB_NUMPROC
fasta=/public/home/test/haoliu/work/callsnp/data/hg38.fa
fq1=/public/home/test/haoliu/work/callsnp/data/ERR194146_1.fastq.gz
fq2=/public/home/test/haoliu/work/callsnp/data/ERR194146_2.fastq.gz
i=sample1
sortedBam=ERR194146.sorted.bam
(sentieon bwa mem -M -R "@RG\tID:${i}\tSM:${i}\tPL:$platform" -t $nt -K 10000000 $fasta $fq1 $fq2 || echo -n 'error' ) | sentieon util sort -r $fasta -o $sortedBam -t $nt --sam2bam -i -
参考文档¶
Computational_performance_and_accuracy_of_Sentieon_DNASeq_variant_calling_workflow
Sentieon_DNASeq_Variant_Calling_Workflow_Demonstrates_Strong_Computational_Performance_and_Accuracy
跑bismark的时候需要申请的核心数时设置的程序线程数4倍，因为这个程序会调用4个bowtie同时跑比对，导致节点负载过高，程序运行变慢。
如 --multicore 4，实际运行中会运行总共16线程的bowtie比对，因此注意LSF申请的核心数必须为--multicore 设置线程数的4倍。
bismark2bedGraph 中使用了系统的sort命令，在centos7中，sort命令可以多线程运行，但bismark2bedGraph的sort没有添加多线程选项，可以自己在代码中手动添加一下--parallel=8，使用8线程，另外因为多线程使用sort会比较占内存，bismark2bedGraph可以用--buffer_size 控制一下内存的使用。
else{
my $sort_dir = './'; # there has been a cd into the output_directory already
# my $sort_dir = $output_dir;
# if ($sort_dir eq ''){
# $sort_dir = './';
# }
if ($gazillion){
if ($in =~ /gz$/){
open $ifh, "gunzip -c $in | sort --parallel=8 -S $sort_size -T $sort_dir -k3,3V -k4,4n |" or die "Input file could not be sorted. $!\n";
}
else{
open $ifh, "sort --parallel=8 -S $sort_size -T $sort_dir -k3,3V -k4,4n $in |" or die "Input file could not be sorted. $!\n";
}
### Comment by Volker Brendel, Indiana University
### "The -k3,3V sort option is critical when the sequence names are numbered scaffolds (without left-buffering of zeros). Omit the V, and things go very wrong in the tallying of reads."
}
else{
### this sort command was used previously and sorts according to chromosome in addition to position. Since the files are being sorted according to chromosomes anyway,
### we may drop the -k3,3V option. It has been reported that this will result in a dramatic speed increase
if ($in =~ /gz$/){
open $ifh, "gunzip -c $in | sort --parallel=8 -S $sort_size -T $sort_dir -k4,4n |" or die "Input file could not be sorted. $!\n";
}
else{
open $ifh, "sort --parallel=8 -S $sort_size -T $sort_dir -k4,4n $in |" or die "Input file could not be sorted. $!\n";
}
}
使用建议
-
module 中配好了NR、NT等公共数据库，module load之后按提示使用，可不用自己下载
-
使用diomand可替代blastx blastp，可以极大地提高比对速度，module中有格式化好的nr库可直接使用
-
blastn 如果运行比较慢，建议将query序列分割多个序列，提交多个作业同时跑，可以提高跑的速度，因为blastn的CPU利用率不高，线程数建议设置4或8左右即可
BLAST+ 2.15.0 速度有所改善，见 https://www.ncbi.nlm.nih.gov/books/NBK131777/
基本使用¶
构建索引¶
$ module load BLAST/2.15.0
# 对核酸序列构建索引
$ makeblastdb -in ref.fa -dbtype nucl -parse_seqids
# 对氨基酸序列构建索引
$ makeblastdb -in prot.fa -dbtype prot -parse_seqids
# 生成的索引文件
ref.fa
ref.fa.nhr
ref.fa.nin
ref.fa.nog
ref.fa.nsd
ref.fa.nsi
ref.fa.nsq
blastn¶
一般用法
$ blastn -db ref.fa -outfmt 6 -num_threads 6 -evalue 0.001 -query query.fa -out blast_out
如果 ref.fa 序列比较小，可以不用构建索引，使用 -subject 选项直接比对。
$ blastn -subject ref.fa -outfmt 6 -num_threads 6 -query query.fa -out blast_out
超短序列比对¶
blastn 的query序列默认需要大于50nt，对于query小于50nt的短序列，可使用 -task blastn-short 选项并配合其他选项使用，否则可能没有结果出来。
$ blastn -task blastn-short -outfmt 6 -num_threads 6 -word_size 4 -gapopen 1 -gapextend 1 -db ref.fa -query query.fa -out blast_out
输出格式¶
-outfmt <String> 支持的输出格式
alignment view options:
0 = Pairwise,
1 = Query-anchored showing identities,
2 = Query-anchored no identities,
3 = Flat query-anchored showing identities,
4 = Flat query-anchored no identities,
5 = BLAST XML,
6 = Tabular,
7 = Tabular with comment lines,
8 = Seqalign (Text ASN.1),
9 = Seqalign (Binary ASN.1),
10 = Comma-separated values,
11 = BLAST archive (ASN.1),
12 = Seqalign (JSON),
13 = Multiple-file BLAST JSON,
14 = Multiple-file BLAST XML2,
15 = Single-file BLAST JSON,
16 = Single-file BLAST XML2,
17 = Sequence Alignment/Map (SAM),
18 = Organism Report
outfmt 6，其各列的定义为：
[00] Query id
[01] Subject id
[02] % identity
[03] alignment length
[04] mismatches
[05] gap openings
[06] q. start
[07] q. end
[08] s. start
[09] s. end
[10] e-value
[11] bit score
格式6, 7, 10 支持自定义输出列。
The supported format specifiers for options 6, 7 and 10 are:
qseqid means Query Seq-id
qgi means Query GI
qacc means Query accession
qaccver means Query accession.version
qlen means Query sequence length
sseqid means Subject Seq-id
sallseqid means All subject Seq-id(s), separated by a ';'
sgi means Subject GI
sallgi means All subject GIs
sacc means Subject accession
saccver means Subject accession.version
sallacc means All subject accessions
slen means Subject sequence length
qstart means Start of alignment in query
qend means End of alignment in query
sstart means Start of alignment in subject
send means End of alignment in subject
qseq means Aligned part of query sequence
sseq means Aligned part of subject sequence
evalue means Expect value
bitscore means Bit score
score means Raw score
length means Alignment length
pident means Percentage of identical matches
nident means Number of identical matches
mismatch means Number of mismatches
positive means Number of positive-scoring matches
gapopen means Number of gap openings
gaps means Total number of gaps
ppos means Percentage of positive-scoring matches
frames means Query and subject frames separated by a '/'
qframe means Query frame
sframe means Subject frame
btop means Blast traceback operations (BTOP)
staxid means Subject Taxonomy ID
ssciname means Subject Scientific Name
scomname means Subject Common Name
sblastname means Subject Blast Name
sskingdom means Subject Super Kingdom
staxids means unique Subject Taxonomy ID(s), separated by a ';'
(in numerical order)
sscinames means unique Subject Scientific Name(s), separated by a ';'
scomnames means unique Subject Common Name(s), separated by a ';'
sblastnames means unique Subject Blast Name(s), separated by a ';'
(in alphabetical order)
sskingdoms means unique Subject Super Kingdom(s), separated by a ';'
(in alphabetical order)
stitle means Subject Title
salltitles means All Subject Title(s), separated by a '<>'
sstrand means Subject Strand
qcovs means Query Coverage Per Subject
qcovhsp means Query Coverage Per HSP
qcovus means Query Coverage Per Unique Subject (blastn only)
When not provided, the default value is:
'qaccver saccver pident length mismatch gapopen qstart qend sstart send
evalue bitscore', which is equivalent to the keyword 'std'
The supported format specifier for option 17 is:
SQ means Include Sequence Data
SR means Subject as Reference Seq
Biopython解析blast结果¶
blast结果中，outfmt 5 生成的XML结果较为丰富，适合用Biopython解析并提取自己想要的结果，需要先安装一下 pip install biopython。
from Bio.Blast import NCBIXML
# 读取 BLAST XML 文件
result_handle = open(blast_output)
blast_records = NCBIXML.parse(result_handle)
data = []
for blast_record in blast_records:
for alignment in blast_record.alignments:
for hsp in alignment.hsps:
align_item = hsp.query + "\n" + hsp.match + "\n" + hsp.sbjct
row_data = {
'col1': blast_record.query,
'col2': alignment.hit_id,
'col4': hsp.identities,
'col5': hsp.align_length,
'col6': hsp.query_start,
'col7': hsp.query_end,
'col8': hsp.sbjct_start,
'col9': hsp.sbjct_end,
'col10': align_item
}
data.append(row_data)
nt_core¶
Interested in faster nucleotide BLAST searches with more focused search results? As previously announced, NCBI has been re-evaluating the BLAST nucleotide database (nt) to make it more compact and more efficient. Thanks to your feedback, NCBI’s BLAST is excited to introduce the core nucleotide database (core_nt), an alternative to the default nt database that contains better-defined content and is less than half the size.
Benefits of BLAST core_nt over nt¶
- Enables faster searches
- Returns similar top results for most searches
- Reduces redundancy for some highly represented organisms
- Allows easier download and requires less storage space for database download for standalone BLAST
What is core_nt?¶
Core_nt contains the same eukaryotic transcript and gene-related sequences as nt. The core_nt database is nt without most eukaryotic chromosome sequences. Most nucleotide BLAST searches with core_nt will be similar to the nt database. However, core_nt is better than nt for accomplishing your most common BLAST search goals, such as identifying gene-related sequences like transcript sequences and complete bacterial chromosomes. This is because, in recent years, nt has acquired more low-relevance, non-annotated, and non-gene content.
参考¶
Info
由于集群计算节点没有联网，因此需要使用离线模式运行，在登录节点下载需要的数据库，然后提交busco作业到计算节点。
介绍¶
Benchmarking Universal Single-Copy Orthologs (BUSCO)是用于评估基因组组装和注释的完整性的工具。 通过与已有单拷贝直系同源数据库的比较，得到有多少比例的数据库能够有比对，比例越高代表基因组完整度越好。
可以评估三种数据类型：
- 组装的基因组；
- 转录组；
- 注释到的基因对应的氨基酸序列。
使用需要评估的生物类别所属的数据库（从busco数据库下载）比对，得出比对上数据库的完整性比例的信息。
BUSCO官网：https://busco.ezlab.org
BUSCO v5数据库：https://busco-data.ezlab.org/v5/data/lineages/
参考：
https://mp.weixin.qq.com/s/_UXP9qHZnFNqjS56KGzylA
https://mdnice.com/writing/2ab9d001c1ab4bfebaab60d743a09390
https://www.jianshu.com/p/ffda8e3a58e8
下载安装¶
busco安装需要不少依赖，可以直接使用singularity镜像。
基本使用¶
以水稻基因组(真核生物)为例，此过程会自动下载相关的数据库，如本例中的 embryophyta_odb10 库，下载的数据默认在当前目录下的busco_downloads 目录内。
$ singularity exec -e $IMAGE/busco/5.5.0_cv1.sif busco -i MH63.fa -l embryophyta_odb10 -o out -m genome -c 30
-
-i 为输入文件，一般为核酸或蛋白序列
-
-o 输出目录
-
-m 分析默认，genome 或 transcriptome 或 proteins
-
-l 数据库
-
-c 程序运行线程数
植物相关的数据库有：
| 类群 | 数据库 | BUSCO groups数量 |
|---|---|---|
| 真核生物 | eukaryota_odb10 | 255 |
| 绿色植物 | viridiplantae_odb10 | 425 |
| 有胚植物 | embryophyta_odb10 | 1614 |
| 真双子叶植物 | eudicots_odb10 | 2326 |
| 豆目 | fabales_odb10.2020-08-05.tar.gz | 5366 |
离线使用¶
下载数据库¶
新版的busco有个 --download 选项，可下载指定的数据库到本地，如 embryophyta_odb10，也可批量下载 all, prokaryota, eukaryota, virus。下载的数据默认在当前目录下的 busco_downloads 目录内。
$ module load Singularity/3.7.3
$ singularity exec $IMAGE/busco/5.5.0_cv1.sif busco --download embryophyta_odb10
$ tree -L 3 busco_downloads/
busco_downloads/
├── file_versions.tsv
└── lineages
└── embryophyta_odb10
├── ancestral
├── ancestral_variants
├── dataset.cfg
├── hmms
├── info
├── lengths_cutoff
├── links_to_ODB10.txt
├── prfl
├── refseq_db.faa.gz
└── scores_cutoff
busco --list-datasets 可以查看所有数据库。
运行¶
$ singularity exec -e $IMAGE/busco/5.5.0_cv1.sif busco -i MH63.fa -l ./busco_downloads/lineages/embryophyta_odb10 -o out -m genome -c 30 --offline
2023-10-17 10:13:22 INFO:
---------------------------------------------------
|Results from dataset embryophyta_odb10 |
---------------------------------------------------
|C:92.8%[S:90.8%,D:2.0%],F:1.4%,M:5.8%,n:1614 |
|1499 Complete BUSCOs (C) |
|1466 Complete and single-copy BUSCOs (S) |
|33 Complete and duplicated BUSCOs (D) |
|22 Fragmented BUSCOs (F) |
|93 Missing BUSCOs (M) |
|1614 Total BUSCO groups searched |
---------------------------------------------------
2023-10-17 10:13:22 INFO: BUSCO analysis done. Total running time: 1724 seconds
结果解释¶
结果文件在 out/short_summary.specific.embryophyta_odb10.out.txt 中。
$ cat out/short_summary.specific.embryophyta_odb10.out.txt
# BUSCO version is: 5.5.0
# The lineage dataset is: embryophyta_odb10 (Creation date: 2020-09-10, number of genomes: 50, number of BUSCOs: 1614)
# Summarized benchmarking in BUSCO notation for file MH63.fa
# BUSCO was run in mode: euk_genome_met
# Gene predictor used: metaeuk
***** Results: *****
C:92.8%[S:90.8%,D:2.0%],F:1.4%,M:5.8%,n:1614
1499 Complete BUSCOs (C)
1466 Complete and single-copy BUSCOs (S)
33 Complete and duplicated BUSCOs (D)
22 Fragmented BUSCOs (F)
93 Missing BUSCOs (M)
1614 Total BUSCO groups searched
Assembly Statistics:
14 Number of scaffolds
181 Number of contigs
359939322 Total length
0.005% Percent gaps
29 MB Scaffold N50
3 MB Contigs N50
Dependencies and versions:
hmmsearch: 3.1
bbtools: 39.01
metaeuk: 6.a5d39d9
busco: 5.5.0
通常用完整比对上的占总共的BUSCO groups的比例作为BUSCO的重要结果，越高越好，这里是92.9%=1499/1614。
选项¶
$ busco -i [SEQUENCE_FILE] -l [LINEAGE] -o [OUTPUT_NAME] -m [MODE] [OTHER OPTIONS]
-
-i SEQUENCE_FILE, --in SEQUENCE_FILE, 输入FASTA格式的序列文件。可以是组装的基因组或转录组（DNA），也可以是注释基因集的蛋白质序列。还可以使用包含多个输入文件的目录路径
-
-o OUTPUT, --out OUTPUT, 为您的分析运行提供一个可识别的简短名称。输出文件夹和文件将以此名称标记。输出文件夹的路径由--out_path设置
-
-m MODE, --mode MODE, 指定要运行的BUSCO分析模式，有三个有效的模式：
- geno或genome，用于基因组组装（DNA）
- tran或transcriptome，用于转录组组装（DNA）
- prot或proteins，用于注释的基因集（蛋白质）
-
-l LINEAGE, --lineage_dataset LINEAGE, 指定要使用的BUSCO谱系名称
-
--augustus, 对真核生物运行使用Augustus基因预测器
-
--augustus_parameters --PARAM1=VALUE1,--PARAM2=VALUE2
向Augustus传递额外的参数。所有参数应该包含在一个没有空格的字符串中，每个参数之间用逗号分隔
-
--augustus_species AUGUSTUS_SPECIES, 指定Augustus训练的物种
-
--auto-lineage, 运行自动谱系以找到最佳的谱系路径
-
--auto-lineage-euk, 仅在真核生物树上运行自动定位，以找到最佳的谱系路径
-
--auto-lineage-prok, 仅在非真核生物树上运行自动定位，以找到最佳的谱系路径
-
-c N, --cpu N, 指定要使用的线程/核心数（N为整数）
-
--config CONFIG_FILE, 提供一个配置文件
-
--contig_break n, 表示在连续的N之间有多少个断点来分隔contig, 默认值为n=10
-
--datasets_version DATASETS_VERSION, 指定BUSCO数据集的版本，例如odb10
-
--download [dataset [dataset ...]]
下载数据集。可能的值是特定的数据集名称，"all"，"prokaryota"，"eukaryota"或"virus"。如果与其他命令行参数一起使用，请确保将其放在最后
-
--download_base_url DOWNLOAD_BASE_URL, 设置远程BUSCO数据集位置的URL
-
--download_path DOWNLOAD_PATH , 指定用于存储BUSCO数据集下载的本地文件路径。
-
-e N, --evalue N, BLAST搜索的E-value阈值。允许的格式为0.001或1e-03（默认值：1e-03）
-
-f, --force, 强制覆盖现有文件。必须在已存在具有提供的名称的输出文件时使用
-
-h, --help, 显示帮助信息并退出
-
--limit N, 每个BUSCO要考虑的候选区域（contig或transcript）的数量（默认值：3）
-
--list-datasets, 打印可用的BUSCO数据集列表。
-
--long, 优化Augustus自训练模式（默认值：关闭）；这将显著增加运行时间，但对于某些非模式生物可以改善结果。
-
--metaeuk_parameters "--PARAM1=VALUE1,--PARAM2=VALUE2"
向Metaeuk传递额外的参数，用于第一次运行。所有参数应该包含在一个没有空格的字符串中，每个参数之间用逗号分隔。
-
--metaeuk_rerun_parameters "--PARAM1=VALUE1,--PARAM2=VALUE2"
向Metaeuk传递额外的参数，用于第二次运行。所有参数应该包含在一个没有空格的字符串中，每个参数之间用逗号分隔。
-
--miniprot, 对真核生物运行使用Miniprot基因预测器。
-
--offline, 表示BUSCO无法尝试下载文件。
-
--out_path OUTPUT_PATH, 结果文件夹的可选位置，不包括结果文件夹名称。默认为当前工作目录。
-
-q, --quiet, 禁用信息日志，仅显示错误。
-
-r, --restart, 继续已经部分完成的运行。
-
--scaffold_composition, 将每个scaffold的ACGTN内容写入文件scaffold_composition.txt。
-
--tar, 压缩某些包含大量文件的子目录以节省空间。
-
--update-data, 下载并替换所有谱系数据集和必要文件的最新版本。
canu在运行过程中各个不同的阶段需要消耗的资源不同（如下所示），
On LSF detected memory is requested in MBB
--
--
-- (tag)Threads
-- (tag)Memory |
-- (tag) | | algorithm
-- ------- ------ -------- -----------------------------
-- Grid: meryl 31 GB 6 CPUs (k-mer counting)
-- Grid: hap 16 GB 18 CPUs (read-to-haplotype assignment)
-- Grid: cormhap 19 GB 4 CPUs (overlap detection with mhap)
-- Grid: obtovl 24 GB 6 CPUs (overlap detection)
-- Grid: utgovl 24 GB 6 CPUs (overlap detection)
-- Grid: cor 24 GB 4 CPUs (read correction)
-- Grid: ovb 4 GB 1 CPU (overlap store bucketizer)
-- Grid: ovs 32 GB 1 CPU (overlap store sorting)
-- Grid: red 38 GB 6 CPUs (read error detection)
-- Grid: oea 8 GB 1 CPU (overlap error adjustment)
-- Grid: bat 150 GB 20 CPUs (contig construction with bogart)
-- Grid: cns --- GB 8 CPUs (consensus)
-- Grid: gfa 64 GB 20 CPUs (GFA alignment and processing)
canu 使用集群模式运行时，可能会出现资源设置不合理导致大量作业挂起甚至将节点卡死的情况，结合本集群的情况，探索了一些canu的资源设置选项如下： 在ovs中，会提交大量的单核心、每个作业需要的内存较大的作业，很容易出现多个作业聚集在一个节点上，过程中节点内存很快耗尽导致作业被挂起或节点卡死，因此可以使用rusage设置LSF的内存预留情况，避免多个作业挤在一个节点。具体设置如下：
gridEngineResourceOption="-n THREADS " (1.8及以上)
将
setGlobalIfUndef("gridEngineResourceOption", "-n THREADS -M MEMORY");
更改为
setGlobalIfUndef("gridEngineResourceOption", " -n THREADS ");
集群module中 v1.7.1 v1.8 v1.9 2.0 2.2 的代码都做了相应的修改，可以不用上述选项，如果使用自己安装的canu可根据自己的需要添加选项或修改代码。
bat过程消耗内存较大，可以放到high队列，如下：
gridOptionsBAT="-q high"
minThreads 选项设置单个作业使用更多的核心，以避免作业因超内存而挂掉。
#BSUB -J canu
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load canu/2.2
canu -p project -d project_out genomeSize=2000m minThreads=6 gridOptionsBAT="-q high" -pacbio subreads.fq.gz
#BSUB -J canu
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
canu -p project -d project_out genomeSize=2000m minThreads=6 gridOptionsBAT="-q high" gridEngineResourceOption="-n THREADS " -pacbio subreads.fq.gz
cnvnator默认用整个节点的CPU核去跑, 需要在lsf脚本里加一个这个，控制程序使用的线程数
export MKL_NUM_THREADS=1;export OMP_NUM_THREADS=1
或
export MKL_NUM_THREADS=LSB_DJOB_NUMPROC;export OMP_NUM_THREADS=LSB_DJOB_NUMPROC
目前tophat+cufflinks的流程逐渐被淘汰，建议使用hisat2替代tophat2，stringtie替代cufflinks，速度会有大幅提升
fastlmmc 使用 -maxThreads 选项设置多线程运行时，运行速度相比单线程运行速度要慢很多，建议不要使用该选项设置多线程，默认单线程运行即可。
# 6150 CPU @ 2.70GHz
$ time ./fastlmmc -bfile all_chr_296_filter_snps -pheno res_1_5000.txt -bfileSim all_chr_296_filter_snps -pheno-name LOC_Os01g01330 -out LOC_Os01g01330_result.txt -maxThreads 20
real 4112.41
user 79598.59
sys 98.64
mem 32545440
# 6150 CPU @ 2.70GHz
$ time ./fastlmmc -bfile all_chr_296_filter_snps -pheno res_1_5000.txt -bfileSim all_chr_296_filter_snps -pheno-name LOC_Os01g01330 -out LOC_Os01g01330_result.txt
real 2208.58
user 2166.45
sys 36.50
mem 32494552
Warning
由于GTX.ZIP开发公司的软件开放政策发生了变化，其压缩功能有了比较大的限制，不再建议使用。
GTX.Zip（简称GTZ）是面向基因行业，结合行业数据特征，对基因测序数据进行定向优化，支持所有文件格式的高倍无损压缩系统。该系统具有业界最高无损压缩倍率和速度，能以1100MB/s的极致速度，将基因测序数据压缩至原大小的2%。该系统可对测序数据文件及文件目录进行高倍率快速压缩和打包，赋能用户对海量基因数据进行方便快捷的存储、传输、分发和提取。
项目地址：https://github.com/Genetalks/gtz
使用范围
主要用于压缩fq、bam文件
载入
module load GTZ/3.0.2
压缩fastq（添加参考基因组参数，获得高压缩率）
gtz ERR194146_1.fastq --ref hg38.fa --cache-path /public/home/test/ -p 4
直接压缩fastq.gz（添加参考基因组参数，获得高压缩率）
gtz ERR194146_1.fastq.gz --ref hg38.fa --cache-path /public/home/test/ -p 4
解压成fastq
gtz -d ERR194146_1.fastq.gz.gtz --cache-path /public/home/test/ -p 4
解压成fastq.gz
gtz -d -z ERR194146_1.fastq.gz.gtz --cache-path /public/home/test/ -p 4
压缩bam（测试功能，需要参考基因组）
gtz ERR194146.bam --ref hg38.fa --cache-path /public/home/test/ -p 4
解压bam
gtz -d ERR194146.bam.gtz --cache-path /public/home/test/ -p 4
fq测试数据
耗时可以接受，压缩效果比较好
#人，相比gz压缩到1/2
-rw-rw-r-- 1 software software 53G Jan 19 2019 ERR194146_2.fastq.gz
-rw-rw-r-- 1 software software 52G Jan 19 2019 ERR194146_1.fastq.gz
-rw-r--r-- 1 software software 30G Oct 13 20:35 ERR194146_2.fastq.gtz
-rw-r--r-- 1 software software 29G Oct 13 22:27 ERR194146_1.fastq.gtz
#油菜，相比gz压缩到1/3
-rwxr-xr-x 1 software software 15G Oct 23 16:43 ZS11_1.fq.gz
-rwxr-xr-x 1 software software 17G Oct 23 16:43 ZS11_2.fq.gz
-rw-r--r-- 1 software software 4.5G Oct 25 00:10 ZS11_1.fq.gz.gtz
-rw-r--r-- 1 software software 6.0G Oct 25 00:16 ZS11_2.fq.gz.gtz
#玉米，相比gz压缩到1/3
-rwxr-xr-x 1 software software 9.4G Oct 23 16:32 Q114_1.trimed.fq.gz
-rwxr-xr-x 1 software software 11G Oct 23 16:33 Q114_2.trimed.fq.gz
-rw-r--r-- 1 software software 3.3G Oct 25 00:18 Q114_1.trimed.fq.gz.gtz
-rw-r--r-- 1 software software 4.0G Oct 25 00:21 Q114_2.trimed.fq.gz.gtz
#棉花，相比gz压缩到1/4
-rw-r--r-- 1 software software 35G Oct 23 16:36 L1_1.clean.fq.gz
-rw-r--r-- 1 software software 37G Oct 23 16:37 L1_2.clean.fq.gz
-rw-r--r-- 1 software software 7.7G Oct 25 01:07 L1_1.clean.fq.gz.gtz
-rw-r--r-- 1 software software 8.7G Oct 25 01:07 L1_2.clean.fq.gz.gtz
压缩时间比较长，结果相比cram(压缩至bam的⅔)稍好，建议bam文件还是转cram，毕竟samtools等很多下游工具支持直接使用cram格式
棉花，相比bam压缩到1/2
-rw-rw-r-- 1 software software 23G Sep 16 2019 BYU21001.sorted.bam
-rw-rw-r-- 1 software software 10G Oct 26 17:16 BYU21001.sorted.bam.gtz
HiC-Pro软件可以在安装时根据作业调度系统配置成集群模式，目前集群中的HiC-Pro/2.11.14 已做了集群模式配置。大致使用如下。
准备好输入文件，编辑 config-hicpro.txt 配置文件，填写 JOB_NAME、N_CPU、输入文件、结果输出路径 等，配置文件内所有输入文件和目录均填写绝对路径。
生成作业脚本，以下命令会在 out 目录内生成2个lsf作业脚本 HiCPro_step1_JOB_NAME.sh，HiCPro_step2_JOB_NAME.sh
HiC-Pro -c config-hicpro.txt -i rawdata -o out -p
这2个脚本不能直接提交，需要进行以下修改。
将以下几行注释或者删掉
#BSUB -M
#BSUB -W
#BSUB -N
#BSUB -u
#BSUB -q
添加
module load HiC-Pro/2.11.4
#BSUB -J HiCpro_s1_triticum_aestivum[1-5]
#BSUB -e HiCpro_s1_triticum_aestivum.%J.e
#BSUB -o HiCpro_s1_triticum_aestivum.%J.o
#BSUB -n 36
#BSUB -J HiCpro_s1_triticum_aestivum[1-5]
module load HiC-Pro/2.11.4
FASTQFILE=inputfiles_triticum_aestivum.txt; export FASTQFILE
make --file /public/home/software/opt/bio/software/HiC-Pro/2.11.14/HiC-Pro_2.11.4/scripts/Makefile CONFIG_FILE=/public/home/username/work/hic_wheat/hicpro_ERR23561/config-hicpro.txt CONFIG_SYS=/public/home/software/opt/bio/software/HiC-Pro/2.11.14/HiC-Pro_2.11.4/config-system.txt all_sub 2>&1
修改完成后，先提交step1
bsub < HiCPro_step1_triticum_aestivum.sh
正常运行结束后，提交 step2，step2 不需要多核运行，因此可以将HiCPro_step2_triticum_aestivum.sh 脚本中 -n 36 改成 -n 1。
bsub < HiCPro_step2_triticum_aestivum.sh
运行完成后查看日志，如果出现错误直接重新提交这个脚本即可，直至运行成功、日志无报错。
介绍¶
maker是一个比较强大的基因组注释pipeline软件，其可以整合多种数据库、软件对基因组进行注释。
maker使用MPI库编写软件，能最大限度利用集群所有计算资源，极大地缩减了基因组注释所需的时间。
使用maker，测试了水稻MH63的11号染色体(MH63 Chr11)，32MB左右，申请资源20*6核心，大约4小时就可以跑完。
https://github.com/Yandell-Lab/maker
软件运行¶
载入maker，如果没有特殊需求，建议载入最新的版本。
module load maker/3.01.03
如果是第一次使用，需要先运行maker -CTL生成配置文件，然后在maker_opts.ctl中添加对应的genome、protein、est文件等。
LSF并行环境下运行，申请100核(-n 100)，每个节点20核(-R "span[ptile=20]")，同时使用5个节点(100/20)，这种模式必须使用parallel队列(需要向管理员申请开通队列使用权限)。
#BSUB -J maker
#BSUB -q parallel
#BSUB -n 100
#BSUB -R "span[ptile=20]"
#BSUB -o stdout_%J.out
#BSUB -e stderr_%J.err
module purge
module load maker/3.01.03
mpirun -np $LSB_DJOB_NUMPROC maker -base round1 maker_bopts.ctl maker_exe.ctl maker_opts.ctl 2>&1
注意事项¶
资源申请¶
maker运行时一次申请核数过多会导致排队时间较长，对于一般基因组，建议申请100核即可。
资源非常紧张时，建议将染色体拆分，每个染色体跑一个maker作业，每个作业申请几十核，最后再合并结果。parallel队列每人只能使用120核。
使用自训练augustus模型¶
见 augustus
错误处理¶
maker运行过程中会出现FAILED的情况，如下所示。这种情况作业不会停下，但软件处于空跑状态，没有结果更新。
因此在跑maker的过程中需要及时关注prefix_round1_master_datastore_index.log运行日志的输出，以免因程序运行出错导致浪费太多资源和时间。
出现FAILED的情况时，对于小基因组，建议杀掉作业直接重跑，或者调整参数再重跑；对于大基因组，建议将出错的染色体单独重跑，然后再合并结果。
$ cat round1.maker.output/round1_master_datastore_index.log
Chr01 round1_datastore/D0/AB/Chr01/ STARTED
Chr02 round1_datastore/D6/BF/Chr02/ STARTED
Chr03 round1_datastore/FC/43/Chr03/ STARTED
Chr04 round1_datastore/AB/6D/Chr04/ STARTED
Chr05 round1_datastore/2A/B2/Chr05/ STARTED
Chr06 round1_datastore/94/77/Chr06/ STARTED
Chr07 round1_datastore/20/25/Chr07/ STARTED
Chr08 round1_datastore/45/CE/Chr08/ STARTED
Chr09 round1_datastore/F1/4B/Chr09/ STARTED
Chr10 round1_datastore/7C/72/Chr10/ STARTED
Chr11 round1_datastore/1E/AA/Chr11/ STARTED
Chr12 round1_datastore/1B/FA/Chr12/ STARTED
Chr12 round1_datastore/1B/FA/Chr12/ FAILED
Chr09 round1_datastore/F1/4B/Chr09/ FAILED
Chr03 round1_datastore/FC/43/Chr03/ FINISHED
Chr10 round1_datastore/7C/72/Chr10/ FINISHED
Chr04 round1_datastore/AB/6D/Chr04/ FINISHED
Chr05 round1_datastore/2A/B2/Chr05/ FINISHED
Chr07 round1_datastore/20/25/Chr07/ FINISHED
Chr02 round1_datastore/D6/BF/Chr02/ FINISHED
Chr08 round1_datastore/45/CE/Chr08/ FINISHED
Chr11 round1_datastore/1E/AA/Chr11/ FINISHED
Chr01 round1_datastore/D0/AB/Chr01/ FAILED
Chr06 round1_datastore/94/77/Chr06/ FINISHED
参考¶
MAKER Tutorial for WGS Assembly and Annotation Winter School 2018
基因注释：基于SNAP+Augustus+GeneMark的maker3 pipeline
necat集群模式运行配置
#BSUB -J necat
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load NECAT/20200803
date
necat.pl correct oleracea_config.txt
necat.pl assemble oleracea_config.txt
necat.pl bridge oleracea_config.txt
date
PROJECT=oleracea
ONT_READ_LIST=read_list.txt
GENOME_SIZE=630000000
THREADS=8
MIN_READ_LENGTH=3000
OVLP_FAST_OPTIONS="-n 500 -z 20 -b 2000 -e 0.5 -j 0 -u 1 -a 1000"
OVLP_SENSITIVE_OPTIONS="-n 500 -z 10 -e 0.5 -j 0 -u 1 -a 1000"
CNS_FAST_OPTIONS="-a 2000 -x 4 -y 12 -l 1000 -e 0.5 -p 0.8 -u 0"
CNS_SENSITIVE_OPTIONS="-a 2000 -x 4 -y 12 -l 1000 -e 0.5 -p 0.8 -u 0"
TRIM_OVLP_OPTIONS="-n 100 -z 10 -b 2000 -e 0.5 -j 1 -u 1 -a 400"
ASM_OVLP_OPTIONS="-n 100 -z 10 -b 2000 -e 0.5 -j 1 -u 0 -a 400"
NUM_ITER=2
CNS_OUTPUT_COVERAGE=45
CLEANUP=0
USE_GRID=true
GRID_NODE=80
FSA_OL_FILTER_OPTIONS="--max_overhang=-1 --min_identity=-1 --coverage=40"
FSA_ASSEMBLE_OPTIONS=""
FSA_CTG_BRIDGE_OPTIONS="--dump --read2ctg_min_identity=80 --read2ctg_min_coverage=4 --read2ctg_max_overhang=500 --read_min_length=5000 --ctg_min_length=1000 --read2ctg_min_aligned_length=5000 --select_branch=best"
https://github.com/Nextomics/NextDenovo
NextDenovo支持中断重跑，运行过程中可能某些步骤因各种原因跑出错，导致整体运行没有结果产生，可以尝试重新提交作业，程序不需要添加其它参数即可从失败的地方重新开始运行，节省时间。
run_NextDenovo.lsf
#BSUB -J NextDenovo
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load NextDenovo/2.5.2
nextDenovo run_NextDenovo.cfg
配置文件 run_NextDenovo.cfg
[General]
job_type = lsf
job_prefix = nextDenovo
task = all # 'all', 'correct', 'assemble'
rewrite = yes # yes/no
deltmp = yes
rerun = 3
parallel_jobs = 200
input_type = raw
input_fofn = input.fofn
workdir = 01_rundir
cluster_options = -R span[hosts=1] -q normal -n {cpu}
[correct_option]
read_cutoff = 1k
seed_cutoff = 35607
blocksize = 3g
pa_correction = 250
seed_cutfiles = 20
sort_options = -m 20g -t 8 -k 40
minimap2_options_raw = -x ava-ont -t 8
#-dbuf 选项不能去掉，否则这一步每个作业会占用大量内存，导致节点卡死
correction_options = -p 8 -dbuf
[assemble_option]
random_round = 20
minimap2_options_cns = -x ava-ont -t 8 -k17 -w17
nextgraph_options = -a 1
nd.asm.fasta 为最后组装好的基因组文件
./01_rundir/
├── 01.raw_align
│ ├── 01.db_stat.sh
│ ├── 01.db_stat.sh.done
│ ├── 01.db_stat.sh.work
│ ├── 02.db_split.sh
│ ├── 02.db_split.sh.done
│ ├── 02.db_split.sh.work
│ ├── 03.raw_align.sh
│ ├── 03.raw_align.sh.done
│ ├── 03.raw_align.sh.work
│ ├── 04.sort_align.sh
│ ├── 04.sort_align.sh.done
│ ├── 04.sort_align.sh.work
│ ├── input.part.001.2bit
│ ├── input.part.002.2bit
│ ├── input.part.003.2bit
│ ├── input.part.004.2bit
│ ├── input.part.005.2bit
│ ├── input.part.006.2bit
│ ├── input.part.007.2bit
│ ├── input.part.008.2bit
│ ├── input.reads.stat
│ ├── input.seed.001.2bit
│ ├── input.seed.002.2bit
│ └── input.seed.003.2bit
├── 02.cns_align
│ ├── 01.seed_cns.input.idxs
│ ├── 01.seed_cns.sh
│ ├── 01.seed_cns.sh.done
│ ├── 01.seed_cns.sh.work
│ ├── 02.cns_align.sh
│ ├── 02.cns_align.sh.done
│ └── 02.cns_align.sh.work
└── 03.ctg_graph
├── 01.ctg_graph.input.ovls
├── 01.ctg_graph.input.seqs
├── 01.ctg_graph.sh
├── 01.ctg_graph.sh.done
├── 01.ctg_graph.sh.work
├── 02.ctg_align.sh
├── 02.ctg_align.sh.done
├── 02.ctg_align.sh.work
├── 03.ctg_cns.input.bams
├── 03.ctg_cns.sh
├── 03.ctg_cns.sh.done
├── 03.ctg_cns.sh.work
├── nd.asm.fasta
└── nd.asm.fasta.stat
#BSUB -J pbassembly
#BSUB -n 1
#BSUB -o %J.pbassembly.out
#BSUB -e %J.pbassembly.err
#BSUB -R span[hosts=1]
#BSUB -q "normal"
source activate pb-assembly
fc_run.py ./run.cfg
run.cfg 文件
[General]
input_fofn=all.raw.reads
input_type=raw
pa_fasta_filter_option=streamed-median
target=assembly
skip_checks=False
LA4Falcon_preload=false
pa_DBsplit_option=-x500 -s400
ovlp_DBsplit_option=-s400
pa_HPCTANmask_option=
#no-op repmask param set
pa_REPmask_code=0,300;0,300;0,300
# adjust to your genome size
genome_size = 2000000000
seed_coverage = 30
length_cutoff = -1
pa_HPCdaligner_option=-v -B128 -M36
#对于大基因组，如大于1GB，添加-T8，让每个daligner使用8线程，默认4线程，
#避免多个daligner可能挤在一个节点，导致节点内存耗尽，作业被挂起，同时也可以加速daligner的速度
pa_daligner_option= -k18 -e0.80 -l1000 -h256 -w8 -s100 -T8
falcon_sense_option=--output-multi --min-idt 0.70 --min-cov 4 --max-n-read 200 --n_core 1
falcon_sense_greedy=False
ovlp_HPCdaligner_option=-v -B128 -M36
#对于大基因组，如大于1GB，添加-T8，让每个daligner使用8线程，默认4线程，
#避免多个daligner可能挤在一个节点，导致节点内存耗尽，作业被挂起，同时也可以加速daligner的速度
ovlp_daligner_option= -k24 -e.92 -l1800 -h1024 -s100 -T8
length_cutoff_pr=1000
overlap_filtering_setting=--max-diff 100 --max-cov 100 --min-cov 2 --n_core 24
fc_ovlp_to_graph_option=
[job.defaults]
job_type=lsf
pwatcher_type=blocking
JOB_QUEUE=normal
MB=32768
NPROC=8
njobs=240
submit = bsub -K -n ${NPROC} -q ${JOB_QUEUE} -J ${JOB_NAME} -o ${JOB_STDOUT} -e ${JOB_STDERR} ${JOB_SCRIPT}
[job.step.da]
NPROC=8
MB=32000
njobs=240
[job.step.la]
NPROC=8
MB=32000
njobs=240
[job.step.cns]
NPROC=8
MB=4096
njobs=400
[job.step.pda]
NPROC=8
MB=32000
njobs=240
[job.step.pla]
NPROC=8
MB=32000
njobs=240
[job.step.asm]
JOB_QUEUE=smp
NPROC=24
MB=240000
njobs=1
RepeatModeler 在运行过程中，会调用多个rmblastn同时运行，RepeatModeler的-pa 参数设置同时运行的rmblastn个数。每个rmblastn运行时会使用4个线程，因此RepeatModeler设置-pa 多线程参数时，程序实际使用的线程数为设置数的4倍，如 -pa 5，实际会使用20个线程，因此需要在作业脚本中申请20核，否则会出现节点负载过高，导致作业挂起。
下载最新的Trinity singularity镜像
https://data.broadinstitute.org/Trinity/TRINITY_SINGULARITY/
或者使用已下载好的，/share/Singularity/Trinity/2.12.0.sif
运行
$ bsub -o trinity.log -n 30 -q smp -J trinity "module purge;module load Singularity/3.1.1; singularity exec $IMAGE/Trinity/2.12.0.sif Trinity --seqType fq --max_memory 400G --samples_file samples_file --CPU 30 --SS_lib_type RF --output trinity_out "
$ singularity exec $IMAGE/Trinity/2.12.0.sif /usr/local/bin/util/align_and_estimate_abundance.pl
paragraph在运行过程中，每个vcf位点会生成 vcf.gz、vcf.gz.csi、vcf.gz.json 三个文件，默认存放在节点的/tmp目录（所在盘为系统盘）下，程序运行完成之后不会删除，久而久之，会在/tmp目录下积累大量的文件，最终导致系统被塞满，节点挂掉。因此在集群上运行paragraph时建议如下处理：
- 拆分vcf文件，vcf超过10万行建议拆分，以加快临时文件的生成和删除速度；
- 在normal队列运行，normal队列的系统盘为ssd，对于大量小文件的读写速度远远高于机械盘；容量也相对较大，不容易写满；
- 单个作业建议申请10核，使用10线程运行，以免单个节点运行太多paragraph作业，减轻系统盘IO压力；
- 按如下要求编写作业脚本，以便在paragraph运行完成之后及时删除临时文件
#BSUB -J paragraph
#BSUB -n 10
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load Paragrpah/2.4a
tmpn=`mktemp -u paragraph_XXXXX`
tmpd="/tmp/${tmpn}"
mkdir ${tmpd}
echo ${tmpd}
export TMP=${tmpd}
multigrmpy.py -i genome_pacbio_for_paragraph.vcf -m SRR5965451.txt -r TM-1.genome.fa --threads $LSB_DJOB_NUMPROC --scratch-dir ${tmpd} -M 100 -o out
#清理临时文件
rm -r ${tmpd}
基本使用¶
创建索引¶
$ module load hisat2/2.2.1
$ hisat2-build -p 15 ref.fa ref
运行比对¶
#BSUB -J hisat2
#BSUB -n 36
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load hisat2/2.2.1
module load SAMtools/1.16
nt=36
hisat2 -p ${nt} -x ref -1 sample_1.clean.fq.gz -2 sample_2.clean.fq.gz | samtools sort -@${nt} -o sample.sorted.bam
注意事项¶
hisat2运行时容易出现无法找到索引文件的报错，但程序不会自动退出，会让人误以为程序还在正常运行。
提交作业后注意用bpeek查看作业输出，以及比对结果，观察是否有异常。如有异常需及时杀掉作业，调整参数，重新投递作业。
$ bpeek 42220369
<< output from stdout >>
<< output from stderr >>
(ERR): "/public/home/username/ncbi/public/Araport/inx/TAIR10" does not exist
Exiting now ...
$
本文档由朱成诚同学提供
SqueezeMeta第六步使用06.lca.pl进行taxonomic assignment of genes运行非常的慢，速度大概只有8kb/s，在github上提问作者，作者回答第六步是比较吃io的一步，但这么慢的速度完全不能理解。并且很多大集群的用户都反馈了这一步近乎0的速度，可能是数据库放在了慢速远程分区，
尝试数据库放到指定胖节点的/tmp目录下，经测试，第六步运行速度变得非常快，2分钟跑了之前2天的数据量。
如果第一次在集群上使用SqueezeMeta，可以使用胖结点s001 /tmp/squeezemeta/db 这一数据库地址(数据库下载时间较长，在集群 /share/database/squeezemeta/db/ 中放了一份)，同时运行软件时指定计算结点s001。
databases
如果在已经运行了该软件，可以在结果文件夹中找到配置文件SqueezeMeta_conf.pl，将里面的数据库地址指向胖节点s001 /tmp/squeezemeta/db 。然后使用软件自带的restart.pl脚本继续跑数据。
附代码:
#BSUB -J db_cp
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o db_cp.out
#BSUB -e db_cp.err
#BSUB -q smp
#BSUB -m s001
##### copy the databases
cp -r /public/home/username/db/SqueezeMeta/db/squeezemeta/db/ /tmp
##### check the databases
cd /tmp/squeezemeta/db
ll >> /public/home/username/db/SqueezeMeta/db/squeezemeta/1.txt
_______________________________________________________________
##### config rewrite
vim SqueezeMeta_conf.pl
_______________________________________________________________
#BSUB -J restart
#BSUB -n 32
#BSUB -R span[hosts=1]
#BSUB -o restart.out
#BSUB -e restart.err
#BSUB -q smp
#BSUB -m s001
restart.pl TB_reset
BS-Seeker2在运行过程中会产生大量中间临时文件，默认写入的位置为系统目录/tmp，很容易将/tmp写满。
$ lsload c07n01
HOST_NAME status r15s r1m r15m ut pg ls it tmp swp mem
c07n01 ok 4.2 4.0 7.3 11% 0.0 1 0 0M 2.4G 164G
$ du -sh /tmp/*
0 /tmp/46242617.tmpdir
37G /tmp/bs_seeker2_HP301-rep1.bsseeker2.pe.bam_-bowtie2-local-TMP-V72bZD
70G /tmp/bs_seeker2_HP301_rep3_S3.bsseeker2.pe.bam_-bowtie2-local-TMP-exeKfc
33G /tmp/bs_seeker2_IL14H_rep1_S4.bsseeker2.pe.bam_-bowtie2-local-TMP-73XO7p
69G /tmp/bs_seeker2_IL14H_rep2_S4.bsseeker2.pe.bam_-bowtie2-local-TMP-uUI9K7
29G /tmp/bs_seeker2_Ki11-rep1-reseq.bsseeker2.pe.bam_-bowtie2-local-TMP-0kc54M
38G /tmp/bs_seeker2_Ki11_rep1_S3.bsseeker2.pe.bam_-bowtie2-local-TMP-ol3mRa
57G /tmp/bs_seeker2_Ki11_rep2_S3.bsseeker2.pe.bam_-bowtie2-local-TMP-Qu2rUy
31G /tmp/bs_seeker2_Ki3_rep1_S3.bsseeker2.pe.bam_-bowtie2-local-TMP-26VhnT
71G /tmp/bs_seeker2_Ki3-rep2.bsseeker2.pe.bam_-bowtie2-local-TMP-YFwwHB
#BSUB -J BS-Seeker2
#BSUB -n 10
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
mkdir tmp
bs_seeker2-align.py -1 sample.R1.fq -1 sample.R2.fq -o sample.bam -g genome.fa --temp_dir=./tmp
- 准备mysql账号和密码
orthomcl在使用过程中会用到mysql数据库，集群mysql使用参考 mysql，mysql数据库的用户名和密码可从管理员处获取，下面以username和password代称。
- 载入orthomcl-pipeline
$ module load orthomcl-pipeline/2.0.9
- 在当前目录下生成配置文件
这一步会在mysql中创建一个数据库，数据库建议命名为 orthomcl_username，username为个人集群账号，以免与其他用户的数据库冲突
$ orthomcl-setup-database.pl --user username --password password --host s004 --database orthomcl_username --outfile orthomcl.conf
Connecting to mysql and creating database orthomcl_username on host s004 with user username ...
OK
database orthomcl_username created ...OK
Config file orthomcl.conf created.
- 运行orthomcl-pipeline
#BSUB -J orthomcl
#BSUB -n 20
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load orthomcl-pipeline/2.0.9
orthomcl-pipeline -i pep/ -o out -m orthomcl.conf --nocompliant -s $LSB_DJOB_NUMPROC --yes
- 清理mysql数据库
orthomcl运行完成后，如果不再使用，请及时登录mysql数据库，删除上面步骤中创建的mysql数据库。
- 参考
cellranger count¶
cellranger count在数据量较多时运行时间较长，可以通过如下2种方式大幅降低运行时间。以拟南芥数据SRR8485805为例，可将运行时间从8h减少为2h。
运行加速¶
输出结果到计算节点本地磁盘¶
将cellranger count的结果输出到计算节点的/tmp目录，这种方式需要指定结果文件消耗的最大磁盘空间(-R "rusage[tmp=70G]")，以免出现/tmp目录写满导致作业挂掉。经验值为输入fq.gz文件的2倍，如输入fq.gz文件为35G，预计消耗的最大磁盘空间为70G。
#BSUB -J cellranger
#BSUB -n 20
#BSUB -R "rusage[tmp=70G]"
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load cellranger/7.0.0
# 工作目录，cellranger count运行完成之后，将结果文件移动到该目录中。可根据实际情况调整
workdir=`pwd`
# 在/tmp中创建运行目录
tmpn=`mktemp -u cellranger_XXXXX`
tmpd="/tmp/${tmpn}"
mkdir ${tmpd}
echo ${tmpd}
# 切换运行目录到计算节点/tmp 上，$LSB_DJOB_NUMPROC 为核心数，根据BSUB -n 而变化。
cd ${tmpd}
cellranger count --id=SRR8485805_output --transcriptome=/public/home/software/test/scRNA/Arabidopsis_thaliana/ref --fastqs=/public/home/software/test/scRNA/Arabidopsis_thaliana/data/ --sample=SRR8485805 --force-cells=8000 --localcores $LSB_DJOB_NUMPROC
# 将结果文件目录移动到home目录中
mv SRR8485805_output/ ${workdir}
不输出bam文件¶
如果后续分析流程中，不需要bam文件，可以添加--no-bam选项，不生成bam文件，也可大幅加速运行速度。一般的标准分析只需要表达矩阵无需bam文件，RNA速率分析需要bam文件。
#BSUB -J cellranger
#BSUB -n 20
#BSUB -R "rusage[tmp=70G]"
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load cellranger/7.0.0
# $LSB_DJOB_NUMPROC 为核心数，根据BSUB -n 而变化。
cellranger count --id=SRR8485805_output --transcriptome=ref --fastqs=data --sample=SRR8485805 --force-cells=8000 --localcores $LSB_DJOB_NUMPROC
运行速度比较¶
拟南芥数据 SRR8485805
| 运行时间(min) | 加速倍数 | |
|---|---|---|
| 默认情况 | 480 | 1 |
| 输出到/tmp | 110 | 4.3 |
| 不输出bam | 145 | 3.3 |
https://lpantano.github.io/post/2019/2019-07-12-cellranger-efficiency-in-hpc-copy/
EDTA依赖较多，一般使用conda安装或者使用其docker、singularity镜像，为方便大家使用，公共软件中下载了其singularity镜像，使用如下：
# 载入Singularity
$ module load Singularity/3.7.3
# 使用EDTA
$ singularity exec $IMAGE/EDTA/2.0.0.sif EDTA.pl -h
# 查看其它EDTA版本
$ ls $IMAGE
GTX.CAT是一组计算高效、性能卓越、与工业标准高度一致的生物信息二级分析软件工具集，集成了DNA序列比对、BAM预处理、BAM数据质控、变异检测等功能模块，完全遵循行业接受度最高的BWA-GATK最佳实践流程，提供了一套基因组数据分析全流程的完整解决方案。
Warning
试用版license 2022年7月16号到期
介绍¶
官网：http://www.gtxlab.com/product/cat
官方文档：http://doc.gtxlab.com/cat/zh/
GTX.CAT™工具集提供参考基因组索引构建，序列比对，排序，标重，突变检测等全基因组/外显子测序数据分析。GTX.CAT™的主程序为 gtx 。下表中列出了 gtx 支持的所有子命令，用途以及与之功能等价的BWA-GATK工具，详细的介绍可以在官方文档中查看。
| 子命令 | 典型用途 | 功能等价BWA-GATK工具 |
|---|---|---|
| index | 构建参考基因组索引 | BWA |
| align | 序列比对、排序及标重 | BWA-MEM/BWA-MEM2 & Samtools sort & Picard MarkDuplicates |
| bqsr | 碱基质量值校正 | GATK BaseRecalibrator & PrintReads |
| vc | 胚系SNV/INDEL检测 | GATK HaplotypeCaller |
| wgs | 胚系SNV/INDEL检测全流程 | BWA-GATK Best practice pipeline |
| qc | NGS BAM数据质控 | Picard Metrics Collectors |
| gi | 群体GVCFs导入GenomicsDB数据库 | GATK GenomicDBImport |
| genotype_gvcfs | 群体联合分型 | GATK GenotypeGVCFs |
| joint | 一步法联合分型 | GATK GenomicDBImport & GATK GenotypeGVCFs |
| mutect2 | 肿瘤体细胞SNV/INDEL检测 | GATK Mutect2 |
| pon | 构建正常样本panel | GATK CreateSomanticPanelOfNormals |
| gps | 生成污染计算所需pileup统计表 | GATK GetPileupSummaries |
| calc | 计算样本间交叉污染 | GATK CalculateContamination |
| learn | 学习测序方向偏好性模型 | GATK LearnReadOrientationModel |
| filter | 过滤体细胞SNV/INDEL突变 | GATK FilterMutectCalls |
使用举例¶
#BSUB -J gtxcat
#BSUB -n 36
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load gtxcat
thread=$LSB_DJOB_NUMPROC
# 建索引
gtx index hg38.fa
# 运行fq->vcf 全流程，输出排序去重后的bam文件和vcf文件
gtx wgs -t $thread -o ERR194146.vcf -b ERR194146.bam -R '@RG\tID:S1\tSM:S1' hg38.fa \
../ERR194146_1.fastq.gz ../ERR194146_2.fastq.gz
性能测试¶
使用数据为人30x WGS样本数据，单节点36核。
| 软件 | 时间(h) | 最大内存(GB) |
|---|---|---|
| bwa+GATK | 32 | 124 |
| sentieon | 4.1 | 32 |
| gtxcat | 3.1 | 103 |
AlphaFold2 基于深度神经网络预测蛋白质形态，能够快速生成高精确度的蛋白质 3D 模型。以往花费几周时间预测的蛋白质结构，AlphaFold2 在几小时内就能完成。
项目地址: https://github.com/deepmind/alphafold
alphafold它的基本原理是：
alphafold首先将蛋白质序列转换为一个HMM（隐马尔可夫模型），并利用多序列比对和进化信息来计算每个残基对之间的距离和角度。
alphafold然后使用一个神经网络来预测蛋白质的三维结构，根据残基对之间的距离和角度约束来优化结构的能量和一致性。
alphafold最后可以选择是否对预测的结构进行松弛（relaxed），即使用分子动力学模拟来调整结构的局部细节，使其更符合物理规律。
relaxed和unrelaxed的区别主要在于：
relaxed的结构经过了松弛处理，因此更接近于实验观测到的结构，也更适合进行结构分析和功能预测。
unrelaxed的结构没有经过松弛处理，因此可能存在一些原子间的冲突或不合理的键角，也更容易受到预测误差的影响。
relaxed的结构需要更多的计算时间和资源，因此在某些情况下，unrelaxed的结构可能更快速或更方便地获得。
自行安装¶
安装文档¶
参考 https://github.com/kalininalab/alphafold_non_docker
使用¶
#BSUB -J alphafold
#BSUB -n 1
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
cd alphafold-2.2.0
source activate alphafold
bash run_alphafold.sh -d /share/database/alphafold_data -o alphafold_out -f test.fa -t 2021-11-01 -n 20 -m monomer
使用镜像¶
可按下面的lsf作业模板使用，一般需要的更改的参数只有--fasta_paths和--output_dir，分别是输入文件和结果输出目录。
因为GPU资源较少，如果数据量较少、GPU资源紧张时，也可以将alphafold作业提交到非GPU队列，下面为GPU队列作业模板和非GPU队列作业模板。
GPU队列¶
默认情况下，用户无GPU队列使用权限，若需要使用请参照 GPU节点使用。
gpu02节点因为GPU卡型号较老，测试中发现alphafold未能在该节点运行成功。下面模板中将作业交到了gpu01节点。
#BSUB -J alphafold
#BSUB -n 1
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
module load Singularity/3.7.3
singularity exec --nv --bind /share/database/:/mnt/ $IMAGE/alphafold/2.2.2.sif python /app/alphafold/run_alphafold.py \
--data_dir=/mnt/alphafold_data \
--bfd_database_path=/mnt/alphafold_data/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt \
--uniclust30_database_path=/mnt/alphafold_data/uniclust30/uniclust30_2018_08/uniclust30_2018_08 \
--uniref90_database_path=/mnt/alphafold_data/uniref90/uniref90.fasta \
--mgnify_database_path=/mnt/alphafold_data/mgnify/mgy_clusters_2018_12.fa \
--pdb70_database_path=/mnt/alphafold_data/pdb70/pdb70 \
--template_mmcif_dir=/mnt/alphafold_data/pdb_mmcif/mmcif_files \
--obsolete_pdbs_path=/mnt/alphafold_data/pdb_mmcif/obsolete.dat \
--output_dir=alpha_out \
--fasta_paths=test.fa \
--max_template_date=2021-11-01 \
--model_preset=monomer
非GPU队列¶
#BSUB -J alphafold
#BSUB -n 1
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load Singularity/3.7.3
singularity exec --nv --bind /share/database/:/mnt/:ro $IMAGE/alphafold/2.2.2.sif python /app/alphafold/run_alphafold.py \
--data_dir=/mnt/alphafold_data \
--bfd_database_path=/mnt/alphafold_data/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt \
--uniclust30_database_path=/mnt/alphafold_data/uniclust30/uniclust30_2018_08/uniclust30_2018_08 \
--uniref90_database_path=/mnt/alphafold_data/uniref90/uniref90.fasta \
--mgnify_database_path=/mnt/alphafold_data/mgnify/mgy_clusters_2018_12.fa \
--pdb70_database_path=/mnt/alphafold_data/pdb70/pdb70 \
--template_mmcif_dir=/mnt/alphafold_data/pdb_mmcif/mmcif_files \
--obsolete_pdbs_path=/mnt/alphafold_data/pdb_mmcif/obsolete.dat \
--output_dir=alpha_out \
--fasta_paths=test.fa \
--max_template_date=2021-11-01 \
--model_preset=monomer
benchmark¶
一条蛋白序列，大约250bp。
>ghd7
MSMGPAAGEGCGLCGADGGGCCSRHRHDDDGFPFVFPPSACQGIGAPAPPVHEFQFFGNDGGGDDGESVAWLFDDYPPPSPVAAAAGMHHRQPPYDGVVAPPSLFRRNTGAGGLTFDVSLGERPDLDAGLGLGGGGGRHAEAAASATIMSYCGSTFTDAASSMPKEMVAAMADDGESLNPNTVVGAMVEREAKLMRYKEKRKKRCYEKQIRYASRKAYAEMRPRVRGRFAKEPDQEAVAPPSTYVDPSRLELGQWFR
| 队列 | 运行时间(s) | 最大内存(MB) |
|---|---|---|
| gpu | 4523 | 13711 |
| normal | 32305 | 15024 |
深入学习¶
Alphafold2: 如何应用AI预测蛋白质三维结构 视频报告
colabfold¶
ColabFold 是 Sergey Ovchinnikov 等人开发的快速蛋白结构预测软件，使用 MMseqs2 替代 MSA，能够快速精准预测包含复合体在内的蛋白结构。项目地址：https://github.com/sokrypton/ColabFold
具体使用见集群文档 colabfold。
RoseTTAFold¶
RoseTTAFold使用三轨神经网络预测蛋白的结构和相互作用，相对于AlphaFold，RoseTTAFold的精度虽有所降低，但其运行所需的内存和运行时间大大降低。
具体使用见集群文档 RoseTTAFold。
intel open-omics-alphafold¶
open-omics-alphafold为intel官方在intel xeon cpu上优化过的alphafold，推理过程基于intel第4代可扩展处理器(sapphire rapids)AVX512 FP32 和 AMX-BF16，加速效果堪比NVIDIA A100。
具体安装使用见集群文档 open-omics-alphafold。
与原版alphafold2比较
| 软件 | 硬件 | 运行时间(s) | 最大内存(MB) |
|---|---|---|---|
| alphafold2 | CPU(intel 6150) | 232305 | 15024 |
| alphafold2 | GPU(P100) | 4523 | 13711 |
| open-omics-alphafold | CPU(intel 6150) | 4996 | 21668 |
ColabFold 是 Sergey Ovchinnikov 等人开发的快速蛋白结构预测软件，使用 MMseqs2 替代 MSA，能够快速精准预测包含复合体在内的蛋白结构。项目地址：https://github.com/sokrypton/ColabFold
GPU队列¶
默认情况下，用户无GPU队列使用权限，若需要使用请参照 GPU节点使用。
gpu02节点因为GPU卡型号较老，测试中发现alphafold未能在该节点运行成功。下面模板中将作业交到了gpu01节点。使用GPU队列时设置 --use_gpu_relax。
#BSUB -J colabfold
#BSUB -n 1
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
module load colabfold
colabfold_batch --amber --use-gpu-relax --num-recycle 1 test.fa colabfold_output
非GPU队列¶
使用非GPU队列时设置 --cpu。
#BSUB -J colabfold
#BSUB -n 1
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load colabfold
colabfold_batch --amber --cpu --num-recycle 1 test.fa colabfold_output
benchmark¶
一条蛋白序列，大约250bp。
>ghd7
MSMGPAAGEGCGLCGADGGGCCSRHRHDDDGFPFVFPPSACQGIGAPAPPVHEFQFFGNDGGGDDGESVAWLFDDYPPPSPVAAAAGMHHRQPPYDGVVAPPSLFRRNTGAGGLTFDVSLGERPDLDAGLGLGGGGGRHAEAAASATIMSYCGSTFTDAASSMPKEMVAAMADDGESLNPNTVVGAMVEREAKLMRYKEKRKKRCYEKQIRYASRKAYAEMRPRVRGRFAKEPDQEAVAPPSTYVDPSRLELGQWFR
| 队列 | 运行时间(s) | 最大内存(MB) |
|---|---|---|
| gpu | 503 | 3117 |
| normal | 5185 | 4930 |
本文档由杨磊同学提供
RoseTTAFold使用三轨神经网络预测蛋白的结构和相互作用，相对于AlphaFold，RoseTTAFold的精度虽有所降低，但其运行所需的内存和运行时间大大降低。
下载RoseTTAFold¶
git clone https://github.com/RosettaCommons/RoseTTAFold.git
cd RoseTTAFold
利用软件给的conda配置环境进行依赖项的部署，因为集群默认使用的是cuda11.4，所以我们使用默认的cuda11版本进行部署
conda env create -f RoseTTAFold-linux.yml
下载权重¶
wget https://files.ipd.uw.edu/pub/RoseTTAFold/weights.tar.gz
tar xfz weights.tar.gz
下载数据库¶
数据库已存放在/share/database/RosettaFold，大家可以使用软链接将数据链接到自己的安装目录中，因为RoseTTAFold默认数据在自己的安装目录
使用方法¶
# 单体预测
#BSUB -J RoseTTAFold
#BSUB -n 1
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
conda activate RoseTTAFold
cd example
../run_e2e_ver.sh input.fa .
#复合物预测请参照example中的complex_modeling/complex_2track目录。
如果要使用PyRosetta，需要使用以下命令进行另一个环境的创建，并且需要下载PyRosetta的许可证并安装到该新环境中才能使用
conda env create -f folding-linux.yml
#单体预测
cd example
../run_pyrosetta_ver.sh input.fa .
预计结果¶
使用run_e2e_ver.sh 会获得一个最优的PDB文件，类似于 *_.e2e.pdb ；使用run_pyrosetta_ver.sh 则会获得5个结构文件。
载入集群预装的augustus
module load augustus/3.3.3
AUGUSTUS_CONFIG_PATH
$ echo $AUGUSTUS_CONFIG_PATH
如果需要使用自己的训练模型，可以将AUGUSTUS_CONFIG_PATH指定到自己放置模型的路径
# 这行可以写入~/.bashrc文件或者lsf脚本中
export AUGUSTUS_CONFIG_PATH=$HOME/augustus_config
软件地址: PASApipeline
config文件¶
alignAssembly.config，数据库这里使用sqlite，相对mysql更方便，使用时sqlite路径写绝对路径。
## templated variables to be replaced exist as <__var_name__>
# SQLite settings
DATABASE=/public/home/software/test/PASA/pasa.sqlite
#######################################################
# Parameters to specify to specific scripts in pipeline
# create a key = "script_name" + ":" + "parameter"
# assign a value as done above.
#script validate_alignments_in_db.dbi
validate_alignments_in_db.dbi:--MIN_PERCENT_ALIGNED=75
validate_alignments_in_db.dbi:--MIN_AVG_PER_ID=95
validate_alignments_in_db.dbi:--NUM_BP_PERFECT_SPLICE_BOUNDARY=0
#script subcluster_builder.dbi
subcluster_builder.dbi:-m=50
运行¶
#BSUB -J pasa
#BSUB -n 20
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
module load PASA/2.5.2
Launch_PASA_pipeline.pl -c alignAssembly.config -C -r -R --ALT_SPLICE -g genome.fa -t all.fa.clean -T -u all.fa -f accession.txt --TDN TCN.acc --transcribed_is_aligned_orient --ALIGNERS blat,gmap --CPU 20
参考¶
Parabricks is a software suite for performing secondary analysis of next generation sequencing (NGS) DNA and RNA data. It delivers results at blazing fast speeds and low cost. Clara Parabricks can analyze 30x WGS (whole human genome) data in about 25 minutes, instead of 30 hours for other methods. Its output matches commonly used software, making it fairly simple to verify the accuracy of the output.Parabricks achieves this performance through tight integration with GPUs, which excel at performing data-parallel computation much more effectively than traditional CPU-based solutions.
介绍¶
Clara Parabricks是英伟达基于GPU卡开发用于加速call变异的工具套件，支持GATK haplotypecaller和deepvariant 2种call 变异的方式，相比原版速度有大幅提升。
从v4.0开始，学术机构用户可免费使用。
官网：https://www.nvidia.com/en-us/clara/genomics/
官方文档：https://docs.nvidia.com/clara/parabricks/
官方论坛：https://forums.developer.nvidia.com/c/healthcare/parabricks/290
镜像地址：https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/clara-parabricks
支持的工具组件
| Tool | Details |
|---|---|
| applybqsr | Apply BQSR report to a BAM file and generate new BAM file |
| bam2fq | Convert a BAM file to FASTQ |
| bammetrics | Collect WGS Metrics on a BAM file |
| bamsort | Sort a BAM file |
| bqsr | Collect BQSR report on a BAM file |
| collectmultiplemetrics | Collect multiple classes of metrics on a BAM file |
| dbsnp | Annotate variants based on a dbSNP |
| deepvariant | Run GPU-DeepVariant for calling germline variants |
| fq2bam | Run bwa mem, coordinate sorting, marking duplicates, and Base Quality Score Recalibration |
| genotypegvcf | Convert a GVCF to VCF |
| haplotypecaller | Run GPU-HaplotypeCaller for calling germline variants |
| indexgvcf | Index a GVCF file |
| mutectcaller | Run GPU-Mutect2 for tumor-normal analysis |
| postpon | Generate the final VCF output of doing mutect PON |
| prepon | Build an index for a PON file, which is the prerequisite to performing mutect PON |
| rna_fq2bam | Run RNA-seq data through the fq2bam pipeline |
| starfusion | Identify candidate fusion transcripts supported by Illumina reads |
使用举例¶
基本使用¶
fq2bam 输入fq文件、输出排序去重后的bam文件。
haplotypecaller 输入bam文件、输出vcf或gvcf文件。
#BSUB -J parabricks
#BSUB -n 5
#BSUB -R span[hosts=1]
#BSUB -gpu "num=1:gmem=12G"
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
module load Singularity/3.7.3
# fq2bam, bwa mem->sort->dep, 输出排序去重后的bam文件
singularity exec --nv $IMAGE/clara-parabricks/4.0.1-1.sif pbrun fq2bam --ref hg38.fa --in-fq ../ERR194146_1.fastq.gz ../ERR194146_2.fastq.gz --out-bam ERR194146.deduped.bam
# haplotypecaller, bam->vcf
singularity exec --nv $IMAGE/clara-parabricks/4.0.1-1.sif pbrun haplotypecaller --ref hg38.fa --in-bam ERR194146.deduped.bam --out-variants ERR194146.vcf.gz --tmp-dir pbruntmp --logfile pbrun_ERR194146.log
# 多样本call gvcf
# haplotypecaller, bam->gvcf
singularity exec --nv $IMAGE/clara-parabricks/4.0.1-1.sif pbrun haplotypecaller --ref hg38.fa --in-bam ERR194146.deduped.bam --out-variants ERR194146.g.vcf.gz --gvcf --tmp-dir pbruntmp --logfile pbrun_ERR194146.log
分染色体运行¶
部分基因组较大或深度较深的数据，运行 pbrun haplotypecaller 时可能会出现显存不够的报错 Out of memory，此时可以分染色体来跑，最后再合并。以人的样本为例：
# 制作bed文件
$ cat hg38.fa.fai |awk '{print $1"\t0\t"$2}' > hg38_all.bed
# 将大染色体分别分到单独的bed文件中，零碎的contig分到一个bed文件中
$ for i in {1..22};do cat hg38_all.bed |grep -w chr${i} > hg38_chr${i}.bed ;done
$ cat hg38_all.bed |grep -e _ -e chrX -e chrY > hg38_other.bed
lsf脚本
#BSUB -J parabricks
#BSUB -n 5
#BSUB -R span[hosts=1]
#BSUB -gpu "num=1:gmem=12G"
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
module load Singularity/3.7.3
module load GATK/4.5.0.0
# 分染色体运行
# walltime 7151s, mem 20G
for i in {chr{1..22},other};do
singularity exec --nv $IMAGE/clara-parabricks/4.0.1-1.sif pbrun haplotypecaller --interval-file hg38_${i}.bed --ref hg38.fa --in-bam ERR194146.deduped.bam --out-variants ERR194146_${i}.g.vcf.gz --tmp-dir pbruntmp --logfile pbrun_ERR194146_${i}.log
done
# 将各个染色体的vcf合并
# walltime 1442s，mem 1.2G
gatk CombineGVCFs -R hg38.fa $(ls ERR194146*.g.vcf*gz|xargs -i echo "--variant {}") -O ERR194146.g.vcf.gz
错误处理¶
-
gatk CombineGVCFs出现报错Key END found in VariantContext field INFO at Chr1:5436 but this key isn't defined in the VCFHeader. We require all VCFs to have complete VCF headers by defaultparabricks 运行时输出了 vcf 文件，没有使用
--gvcf选项，输出 gvcf文件。
性能测试¶
使用数据为人30x WGS样本数据，单节点36核，2张P100 GPU卡。
| 软件 | 时间(h) | 最大内存(GB) | 加速倍数 |
|---|---|---|---|
| bwa+GATK | 32 | 124 | 1 |
| sentieon | 4.1 | 32 | 7.8 |
| gtxcat | 3.1 | 103 | 10.3 |
| parabricks haplotypecaller | 2.9 | 93G | 11 |
不同硬件，call变异时间(haplotypecaller)，使用数据为人30x WGS样本数据。
| 硬件 | 时间 | 最大内存(GB) |
|---|---|---|
| 2张P100 | 24min | 32G |
| 1张4090 | 19min | - |
| 2张3090 | 21min | - |
最佳实践¶
鉴于计算平台GPU数量较少，大批量的群体数据，不建议跑call变异的全流程都在GPU上跑运行(约3h)，建议前面比对(bwa-mem2)和去重部分在普通节点上进行，最后call变异的步骤在GPU上运行(约20min)，可以提高计算通量。
由于parabricks没有合并gvcf的功能，因此对于群体gvcf数据，可以使用glnexus来合并，具体使用见 glnexus。
DeepVariant是由Google Brain开发的一个开源软件，用于对基因组序列进行变异检测。它利用深度学习技术来实现高质量、高准确性的变异检测，能够在人类基因组的全长上实现高达99％的准确率。
DeepVariant使用卷积神经网络（CNN）来对原始DNA测序数据进行分析，并识别基因组中的单核苷酸变异（SNP）和插入/缺失（indel）。它还能够检测复杂的变异形式，如基因重排和基因剪接变异。DeepVariant能够处理各种类型的测序数据，包括Illumina、PacBio和Nanopore等平台产生的数据。
DeepVariant运行过程中有三个核心步骤，分别用于生成变异候选位点、对候选位点进行筛选和重新分类，并将筛选后的位点转换为VCF格式输出。以下是这三个步骤的具体作用：
-
make_examples：这个步骤用于从原始的测序数据中生成变异候选位点。具体地，make_examples会将原始测序数据划分成许多小片段，然后对每个小片段进行特征提取，得到一组特征向量。接着，make_examples会将特征向量输入卷积神经网络模型，模型会输出该小片段中可能存在的变异候选位点。
-
call_variants：在make_examples步骤生成的变异候选位点中，有许多可能是假阳性（False Positive）或假阴性（False Negative），因此需要对这些位点进行筛选和重新分类。call_variants步骤会对make_examples生成的变异候选位点进行重评估，并根据一些额外的过滤条件对位点进行过滤。这个步骤使用的是支持向量机（Support Vector Machine）模型，对候选位点进行打分和筛选。
-
postprocess_variants：在经过call_variants筛选后，最后的变异位点需要进行重新分类，并输出为VCF格式的文件。这个步骤会使用一些额外的过滤条件，如深度、质量值等，来对最终的变异位点进行重新分类，并将结果输出为VCF文件。
需要注意的是，这三个步骤并不是独立的，而是互相依赖的。make_examples生成的变异候选位点是call_variants和postprocess_variants的输入，而call_variants生成的筛选结果是postprocess_variants的输入。这三个步骤通常会一起运行，形成一个完整的DeepVariant工作流。
安装¶
$ module load Singularity/3.7.3
# CPU版
$ singularity pull docker://google/deepvariant:latest
# 查看版本号
$ singularity exec deepvariant_latest.sif run_deepvariant --version
DeepVariant version 1.6.0
# GPU版
$ singularity pull docker://google/deepvariant:latest-gpu
使用¶
deepvariant 具有CPU和GPU两个版本，在GPU版本中call_variants可使用GPU加速，make_examples和postprocess_variants只能使用CPU。
CPU¶
#BSUB -J deepvariant
#BSUB -n 36
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
thread=$LSB_DJOB_NUMPROC
wdr="/public/home/software/test/human_callsnp/"
module load Singularity/3.7.3
time singularity exec $/deepvariant/1.4.0.sif run_deepvariant --model_type=WGS \
--ref=${wdr}/hg38.fa \
--reads=${wdr}/ERR194146_sort_redup.bam \
--output_vcf=${wdr}/deepvariant/ERR194146.vcf \
--output_gvcf=${wdr}/deepvariant/ERR194146.gvcf \
--num_shards=${thread}
| 步骤 | 时间 | 最大内存(GB) |
|---|---|---|
| make_examples | 83m52 | 17 |
| call_variants | 1256m16 | 4 GPU版77m31 |
| postprocess_variants | 23m32 | 17 |
| total | 1363m46 | - |
CPU+GPU¶
鉴于上面的步骤，可以将deepvariant分开运行，make_examples和postprocess_variants在普通CPU节点上运行，call_variants在GPU节点运行。这样可以最大化利用少量的GPU资源加速运行群体多样本数据。
- 单个样本运行
单个样本分3个脚本运行
#BSUB -J make_examples
#BSUB -n 36
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q normal
thread=$LSB_DJOB_NUMPROC
steps=$((${thread}-1))
wdr="/public/home/software/test/human_callsnp/"
id=ERR194146
module load Singularity/3.7.3
module load parallel/20180222
mkdir tmp/${id}
mkdir output/${id}
time seq 0 ${steps} | parallel -q --halt 2 --line-buffer singularity exec /share/Singularity/deepvariant/1.4.0.sif make_examples --mode calling --ref "/public/home/software/test/human_callsnp//hg38.fa" --reads "/public/home/software/test/human_callsnp//${id}_sort_redup.bam" --examples "tmp/${id}/make_examples.tfrecord@${thread}.gz" --channels "insert_size" --gvcf "tmp/${id}/gvcf.tfrecord@${thread}.gz" --task {}
#BSUB -J call_variants
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
thread=$LSB_DJOB_NUMPROC
steps=$((${thread}-1))
wdr="/public/home/software/test/human_callsnp/"
id=ERR194146
module load Singularity/3.7.3
module load parallel/20180222
time singularity exec /share/Singularity/deepvariant/1.4.0-gpu.sif call_variants --outfile "output/${id}/call_variants_output.tfrecord.gz" --examples "tmp/${id}/make_examples.tfrecord@36.gz" --checkpoint "/opt/models/wgs/model.ckpt"
#BSUB -J call_variants
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
thread=$LSB_DJOB_NUMPROC
steps=$((${thread}-1))
wdr="/public/home/software/test/human_callsnp/"
id=ERR194146
module load Singularity/3.7.3
module load parallel/20180222
time singularity exec /share/Singularity/deepvariant/1.4.0.sif postprocess_variants --ref "/public/home/software/test/human_callsnp//hg38.fa" --infile "output/${id}/call_variants_output.tfrecord.gz" --outfile "output/${id}/${id}.vcf.gz"
- 多样本运行
多个样本可以使用这个脚本
#BSUB -J deepvariant
#BSUB -n 1
#BSUB -R span[hosts=1]
#BSUB -o %J.out
#BSUB -e %J.err
#BSUB -q gpu
#BSUB -m gpu01
thread=36
steps=$((${thread}-1))
wdr="/public/home/software/test/human_callsnp/"
for id in $(cat list.txt)
do
time singularity exec /share/Singularity/deepvariant/1.4.0.sif postprocess_variants --ref "/public/home/software/test/human_callsnp//hg38.fa" --infile "output/${id}/call_variants_output.tfrecord.gz" --outfile "output/${id}/${id}.vcf.gz"
bsub -K -J make_examples_${id} -n ${thread} -o %J.make_examples_${id}.out -e %J.make_examples_${id}.err -R span[hosts=1] "module load Singularity/3.7.3;module load parallel/20180222;time seq 0 ${steps} | parallel -q --halt 2 --line-buffer singularity exec /share/Singularity/deepvariant/1.4.0.sif make_examples --mode calling --ref "/public/home/software/test/human_callsnp//hg38.fa" --reads "/public/home/software/test/human_callsnp//${id}_sort_redup.bam" --examples "tmp/${id}/make_examples.tfrecord@${thread}.gz" --channels "insert_size" --gvcf "tmp/${id}/gvcf.tfrecord@${thread}.gz" --task {}"
bsub -K -J call_variants_${id} -n 1 -o %J.call_variants_${id}.out -e %J.call_variants_${id}.err -q gpu -m gpu01 -R span[hosts=1] "module load Singularity/3.7.3;module load parallel/20180222;time singularity exec /share/Singularity/deepvariant/1.4.0-gpu.sif call_variants --outfile "output/${id}/call_variants_output.tfrecord.gz" --examples "tmp/${id}/make_examples.tfrecord@${thread}.gz" --checkpoint "/opt/models/wgs/model.ckpt""
bsub -K -J make_examples_${id} -n 1 -o %J.make_examples_${id}.out -e %J.make_examples_${id}.err -R span[hosts=1] "module load Singularity/3.7.3;time singularity exec /share/Singularity/deepvariant/1.4.0.sif postprocess_variants --ref "/public/home/software/test/human_callsnp//hg38.fa" --infile "output/${id}/call_variants_output.tfrecord.gz" --outfile "output/${id}/${id}.vcf.gz""
done
| 步骤 | 时间 | 最大内存(GB) |
|---|---|---|
| make_examples | 119m18 | 16 |
| call_variants | 77m31 | 4 |
| postprocess_variants | 19m3 | 17 |
| total | 216m6 | - |
| 软件流程 | 时间 | 内存 | 其它 |
|---|---|---|---|
| bwa-mem2 samtools sort | 342min | 153G | - |
| bwa samtools sort | 391min | 123G | - |
| bwa-mem2 | 528min | 132G | - |
| bwa-mem2 samblaster samtools | 211min | 131G | - |
time bwa-mem2 mem -t $thread -R '@RG\tID:test146\tPL:illumina\tLB:library\tSM:humen146' hg38.fa ../ERR194146_1.fastq.gz ../ERR194146_2.fastq.gz |samtools sort -@ $thread -o ERR194146_srt.bam
time bwa mem -t $thread -R '@RG\tID:test146\tPL:illumina\tLB:library\tSM:humen146' ../hg38.fa ../ERR194146_1.fastq.gz ../ERR194146_2.fastq.gz |samtools sort -@ $thread -o ERR194146_srt2.bam
# sambamba --tmpdir=TMPDIR
time bwa-mem2 mem -t $thread -R '@RG\tID:test146\tPL:illumina\tLB:library\tSM:humen146' ./hg38.fa ../ERR194146_1.fastq.gz ../ERR194146_2.fastq.gz | sambamba view -t $thread -S -f bam /dev/stdin |sambamba sort /dev/stdin -t $thread -o ERR194146_srt3.bam
# samblaster
time bwa-mem2 mem -t $thread -R '@RG\tID:test146\tPL:illumina\tLB:library\tSM:humen146' ./hg38.fa ../ERR194146_1.fastq.gz ../ERR194146_2.fastq.gz | samblaster | samtools view -@ $thread -Sb - ERR194146_srt4.bam
snakemake是一款功能强大的生物信息学流程软件，支持自动化工作流和数据分析。
snakemake可自动解决分析流程之间的步骤依赖、使各步骤按定义好的顺序运行，同时支持所有样本同时并行提交运行，极大地提高了跑分析流程的效率；
snakemake中各流程和软件版本固定之后，可反复重跑，使数据分析具有良好的可重复性；同时通过相关参数设置可以监控流程中的资源使用；
snakemake具有类似于断点续跑的功能，流程跑出错之后，解决问题后继续跑可以自动跳过已经正常跑完的步骤；
snakemake流程写好之后，无需改动即可在本地、云环境、各种集群(slurm/lsf/sge/pbs等)上运行；
snakemake使用python3编写，可在Snakefile文件中直接编写python代码，解决复杂的功能需求；
官方文档：