1.1 购买海外服务器

海外服务器比较有名的是RackNerd，在多个主机论坛里都有相关测评对比。主打一个价格便宜，KVM虚拟，纯SSD raid10阵列，solusvm面板，自带一个IPV4，1Gbps带宽，多个机房可选。

年费超过14美元才可以选洛杉矶的机房，洛杉矶和纽约都是美国服务器主要的节点，几乎所有国外服务器商在这两个地方都有节点。对于国内而言，洛杉矶机房在地理位置上更近，意味着网络延迟（ping值）较小。

说的太多有打广告的嫌疑，具体可以在RackNerd官网查看：RackNerd - Introducing Infrastructure Stability

顺便提一下在RackNerd购买的服务器72小时内可以更换一次ipv4，之后再次更换需要收3美刀。因为我搭建这个节点是为了访问谷歌学术，如果ip被封了会提示：

Your client does not have permission to get URL

连人机验证都没有，说明以前有人用这个ip干过爬虫一类的被谷歌学术直接封了。这个时候就要赶紧提工单换ip，或者申请ipv6（RackNerd似乎没有免费提供ipv6），谷歌学术一般封的是ipv4，这是后话。

购买的VPS可以通过SolusVM面板进行控制，邮件中有用户名和密码：https://nerdvm.racknerd.com/

1.2 测试服务器性能

这一步不是必要的，毕竟你在选配置的时候信息对性能也有个预估。这里就简单记几个测试的脚本：

VPS规格测试：

1
2

# 测试linux系统信息、IO读写和全球下载速度
curl -Lso- bench.sh | bash

GB6跑分：

1
2

# 和上面类似
curl -sL yabs.sh | bash

三网和教育网测速：

1

bash <(curl -sL bash.icu/speedtest)

回程路由：

1

wget -qO- git.io/besttrace | bash

流媒体解锁：

1

bash <(curl -L -s media.ispvps.com)

其他测试：

1
2
3
4
5

# ping测试
https://ping.pe

# 硬盘测试
wget -q https://github.com/Aniverse/A/raw/i/a && bash a

虽然直接用nginx就可以实现http正向代理的过程（https代理需要安装插件），但是为了数据安全，以及防止被墙检测，还是用更成熟的代理软件更为合适。常用的代理软件一个是clash，另一个就是V2Ray。clash的配置比较灵活，支持规则、代理组和混淆等功能；V2Ray配置相对简单（我觉得），更适合我这种小白。

V2Ray有非常详细的中文部署文档和白话文教程：新手上路 · Project V 官方网站 (v2ray.com)

没有必要重复造轮子了，只是提一下客户端（自己的电脑）和服务端（海外服务器）部署的时候需要注意的地方

1. 客户端和服务端时区可以不同，但是转换时区后的时间差要小于90秒

2. https://install.direct/go.sh这个linux一键安装脚本已经不能用了，需要运行如下命令安装和更新V2Ray：

   1	bash <(curl -L https://raw.githubusercontent.com/v2fly/fhs-install-v2ray/master/install-release.sh)

3. 服务端设置完成之后记得放行对应的防火墙端口，并重载防火墙使其生效，常用的相关命令：

   1 2 3 4 5 6 7 8 9 10

   # 放行16823端口： firewall-cmd --add-port=16823/tcp --zone=public --permanent # 重载防火墙： systemctl restart firewalld # 查看放行的端口： firewall-cmd --list-port # 查看进程： ps -ef | grep v2ray # 启动v2ray： systemctl start v2ray

4. 客户端和服务端的"alterId"都设置为0，用户手册说可以指定额外ID数量，但是我这里不为0的话流量只能走直连，写的其他规则全都无法生效（不知道算不算bug）。

5. 用户ID使用的是UUID格式，不推荐手打！可能会引发未知错误，推荐工具Online UUID Generator Tool

以我的配置简单做个示范。

服务端配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

{
  "inbounds": [
    {
      "port": 16823, // 服务器监听端口
      "protocol": "vmess",    // 主传入协议，vmess是v2ray特有的协议
      "settings": {
        "clients": [
          {
            "id": "********-****-****-****-************",  // 用户 ID，客户端与服务器必须相同
            "alterId": 0
          }
        ]
      }
    }
  ],
  "outbounds": [
    {
      "protocol": "freedom",  // 主传出协议
      "settings": {}
    }
  ]
}

客户端配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

{
  "log": {
    "loglevel": "warning"
  },

  "inbounds": [{
    "port": 1080,
    "listen": "127.0.0.1",
    "tag": "http-inbound",
    "protocol": "http",
    "settings": {
      "auth": "noauth",
      "udp": false,
      "ip": "127.0.0.1"
    },
    "sniffing": {
      "enabled": true,
      "destOverride": ["http", "tls"]
    }
  }],

  "outbounds": [{
    "protocol": "vmess",
    "settings": {
      "vnext": [{
        "address": "***.***.***.***",// 服务器ip
        "port": 16823,
        "users": [{
          "id": "********-****-****-****-************",// 用户ID，与服务端匹配
          "alterId": 0
        }]
      }]
    },
    "tag": "rule"
  },{
    "protocol": "blackhole",
    "settings": {},
    "tag": "blocked"
  },{
    "protocol": "freedom",
    "settings": {},
    "tag": "direct"
  }],

  "routing": {
    "domainStrategy": "IPOnDemand",
    "rules":[
      {
        "type": "field",
        "ip": ["geoip:private"],
        "outboundTag": "blocked"
      },{
        "type": "field",
        "domain": ["geosite:category-ads"],
        "outboundTag": "blocked"
      },{
        "type": "field",
        "domain": ["geosite:cn"],
        "outboundTag": "direct"
      },{
        "type": "field",
        "outboundTag": "direct",
        "ip": [
          "geoip:private",
          "geoip:cn"
        ]
      },{
        "type": "field",
        "outboundTag": "direct",
        "domain": [
          "domain:taobao.com",
          "domain:jd.com",
          "domain:baidu.com"
        ]
      }
    ]
  },

  "dns": {
    "hosts": {
      "domain:v2ray.com": "www.vicemc.net",
      "domain:github.io": "pages.github.com",
      "domain:wikipedia.org": "www.wikimedia.org",
      "domain:shadowsocks.org": "electronicsrealm.com"
    },
    "servers": [
      "1.1.1.1",
      {
        "address": "114.114.114.114",
        "port": 53,
        "domains": [
          "geosite:cn"
        ]
      },
      "8.8.8.8",
      "localhost"
    ]
  },

  "policy": {
    "levels": {
      "0": {
        "uplinkOnly": 0,
        "downlinkOnly": 0
      }
    },
    "system": {
      "statsInboundUplink": false,
      "statsInboundDownlink": false,
      "statsOutboundUplink": false,
      "statsOutboundDownlink": false
    }
  },

  "other": {}
}

官网给的客户端例子是走的socks协议，只有火狐(firefox)浏览器才可以设置socks协议代理，其他浏览器像是edge、chrome都是直接跳转计算机中的代理设置（不用插件的话）。因此直接在客户端的inbound设置http协议，然后在客户端直接设置代理地址127.0.0.1，端口1080即可。

把服务端和客户端的V2Ray都设置好之后，就可以在客户端运行v2ray.exe，正常浏览谷歌学术了（ip没被封的话）。

细心的你可能会发现，现在浏览网页的速度非常慢，完全不像是刚开始给VPS做三网测速的速度好吗喂！

在测速网站测试一下代理速度：https://www.speedtest.net/

这个下载速度有点过于绝望了，别说浏览网页，下载个文献都费劲。

另外，TCP连接本身不提供数据加密，传输的数据在网络上可能会被窃听或篡改。这里介绍下主流的V2Ray优化方案：WebSocket + TLS + Nginx（Web） + cloudflare（CDN）

总的来说，WebSocket监听服务端V2Ray的inbounds端口，转发流量到HTTP服务器（同一个服务器），再由HTTP服务器经过TLS加密传数据到cloudflare CDN服务器。隐蔽性比直接tcp连接更高，cloudflare加速也十分给力。

3.1 cloudflare

cloudflare要求有域名。我是在阿里云注册了一个.com的域名，先在域名注册商那里解析域名到服务器ip地址。

在cloudflare官网右侧点击ADD a site，输入注册的二级域名，点击不要钱的那个plan。之后会让你在域名注册商那里修改DNS服务器（Name Server），注意有两个DNS服务器。

修改好之后回到cloudflare，就会发现之前添加的二级域名状态变成了activate，并且两条DNS解析记录也被提取了出来（没有两条可以自己手动添加，一条www，一条二级域名）。

这个时候就可以在自己电脑上ping域名，可以ping成功说明设置没有问题。

在DNS里先关闭代理状态（橙色的云改成灰色的云）。

3.2 nginx

用其他的web服务软件比如apache之类的都是可以的，我的博客服务器用的apache，这里稍微折腾下nginx，以后就都有经验了，嗯。

在nginx官网下载稳定版本，这里以1.25.5为例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 解压，编译，安装nginx，一定要装ssl模块！除非你不用TLS
tar -xvf nginx-1.25.5.tar.gz
cd nginx-1.25.5/
./configure --prefix=/usr/soft/nginx --with-http_ssl_module
make
make install

# 开启80端口，443端口（ssl经常用的端口，也可以指定别的）
firewall-cmd --add-port=80/tcp --zone=public --permanent
firewall-cmd --add-port=443/tcp --zone=public --permanent
systemctl restart firewalld

#启动nginx
/usr/soft/nginx/sbin/nginx

这个时候访问ip:80端口就可以成功访问到nginx的初始界面了。

因为我们后面要改nginx的配置，所以这里先关掉….

1
2
3
4

# 查找80端口被什么进程占用，这里nginx默认使用80端口
netstat -nlp |grep :80
# kill对应的进程，进程号改成自己的
kill 16242

3.3 TLS证书（SSL）

这部分和我之前再apache服务器申请SSL证书一模一样….TLS是SSL的继任者，理解成一个意思就行。

3.3.1 zerossl证书

1
2
3
4
5
6
7

# 安装一些软件包和脚本，刷新环境变量
yum install socat
curl https://get.acme.sh | sh
source ~/.bashrc

# 注册zerossl账号
acme.sh --register-account  -m 你的Email地址 --server zerossl

回到cloudflare，搜索API界面，点击生成全局的cloudflare API key：

1
2
3
4
5
6

# 添加环境变量
export CF_Key="你的API key"
export CF_Email="你的Email地址"

# 生成TLS证书
acme.sh --server zerossl --issue -d 你的域名 --dns dns_cf

以上操作会在/root/.acme.sh/路径下生成TLS证书，安装证书换一个方便自己找的地方。

1
2

# 安装证书，自定义证书的路径和名称
acme.sh --installcert -d 你的域名 --fullchainpath /etc/crt/你的域名.crt --keypath /etc/crt/你的域名.key

zerossl证书有效期是90天，不过acme会创建一个cronjob自动更新证书，还是挺省心的（据说zerossl不支持免费ssl证书更换了，为了避免未来可能存在的问题，我还是用了下面方法）。

3.3.2 cloudflare证书

还有种比较简单的证书，就是cloudflare自己的Orign CA，证书免费，周期15年。

回到cloudflare，搜索SSL/TLS界面，选择Create Certificate，直接创建并上传到服务器就可以了。

不管用哪种方式申请的证书，需要在SSL/TLS界面将加密模式修改为Full或者Full(strict)，这个时候再在DNS设置中打开代理状态（灰色的云改成橙色的云）。

这样修改后你的服务器到CDN服务器之间也采用了ssl/tls加密的方式传输数据，更不容易被检测。

3.4 修改nginx配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# 修改nginx.conf内容
# 前面自定义了nginx安装位置，我这里是/usr/soft/nginx/conf目录下
# 只展示需要修改的80和443端口
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       80;
        server_name  你的域名;
        location / {
            proxy_redirect off;
            proxy_pass http://127.0.0.1:16823; # v2ray服务器端口
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $http_host;
        }

    server {
        listen       443 ssl;
        server_name  你的域名;
        ssl_certificate      /etc/crt/你的域名.crt;
        ssl_certificate_key  /etc/crt/你的域名.key;
ssl_ciphers          HIGH:!aNULL:!MD5;
        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;
        ssl_prefer_server_ciphers  on;

        location / {
            proxy_redirect off;
            proxy_pass http://127.0.0.1:16823;# v2ray服务器端口
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

这个时候启动nginx，以你的域名去访问也可以正常显示页面（地址栏没有红锁头），说明TSL就设置成功了。

3.5 修改v2ray设置

服务端修改配置并重启：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

{
  "inbounds": [
    {
      "port": 16823,
      "protocol": "vmess",
  "settings": {
        "clients": [
          {
            "id": "********-****-****-****-************", 
            "alterId": 0
          }
        ]
      },
  "streamSettings": {
"network": "ws",
"wsSettings": {
"path": "/"
}
  }
    }
  ],
  "outbounds": [
    {
      "protocol": "freedom",
      "settings": {}
    }
  ]
}

与前面相比只是多了一个"streamSettings"，设置的是WebSocket转发的规则，注意路径要与nginx中设置的一样。实际运行的时候我这有个小bug，设置别的路径都会报错404，只有"/"可以正常代理。

客户端只需要在原来的基础上，在"outbounds"添加"streamSettings"相关内容，以及修改"settings"端口和域名地址，如下（只展示部分）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

"outbounds": [{
  "protocol": "vmess",
  "streamSettings": {
    "network": "ws",
    "security": "tls",
    "wsSettings": {
      "path": "/"
    }
  },
  "settings": {
    "vnext": [{
      "address": "你的域名",
      "port": 443,
      "users": [{
        "id": "********-****-****-****-************",
        "alterId": 0
      }]
    }]
  },

客户端运行时记得打开计算机代理！

3.6 优化后的下载速度对比

不管是从数据安全性还是下载速度上，优化后的比之前纯v2ray搭建的节点要强很多。

我这里校园网带宽只有20Mbps，测不到这个节点的下载速度上限；开了手机热点，测的等效带宽是50Mbps，比之前3Mbps提高了20倍，实际上还没有测到上限。这下下载文献是没问题了。

snakemake的一些特点：

1. 声明式工作流描述: 使用Python风格的语法编写工作流规则，描述数据处理步骤和依赖关系。也可以在Snakefile中直接编写python代码，解决复杂的功能需求。
2. 自动化任务调度: Snakemake可以自动解决任务之间的依赖关系，并根据需要并行运行任务，以最大程度地提高效率。
3. 灵活性: Snakemake支持复杂的工作流设计，包括并行处理、条件执行、动态文件生成等功能，使用户能够灵活地定制数据处理流程。
4. 集成性: Snakemake可以与常见的集群调度系统（如SLURM）集成，方便在计算集群上运行工作流。
5. 报告生成: Snakemake可以生成详细的报告，展示工作流执行的结果和性能指标，有助于用户进行结果分析和优化。

官方给出的文档中有非常详细的操作，包括如何安装，以及如何执行和定义一个工作流。官方还有个代码库，存放了大量的生信分析的工作流代码和文件供我们参考。

官方文档：Snakemake | Snakemake 8.10.6 documentation

工作流库：Snakemake-Workflows (github.com)，Snakemake workflow catalog

这里记录下我对snakemake的学习过程，以官方文档的例子为主初步理解和学习这个软件的基本用法，再用自己的服务器跑一跑简单的流程。

官方推荐使用Conda/Mamba进行安装，因为这两个包管理软件可以很好处理snakemake的软件依赖关系。也可以使用python的pip工具安装，但需要手动解决一些依赖问题。

由于学校集群至今没能联网（对学校这方面的管理非常非常不满，一个集群没有专人管理，出问题找不到管理员解决，也没有用户手册，没有后台监测，导致一些用户乱用登录节点资源。真的推荐向华农学习学习，南疆最大的集群管理如此混乱，说出去真的不好意思），源码安装需要解决的依赖太多，所以暂时不做集群中的演示了，以我的服务器为例跑一跑流程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 先安装mamba(base环境下)
conda install -n base -c conda-forge mamba

# 下载示例数据
mkdir snakemake-tutorial
cd snakemake-tutorial
curl -L https://api.github.com/repos/snakemake/snakemake-tutorial-data/tarball -o snakemake-tutorial-data.tar.gz

# 使用mamba安装snakemake，创建虚拟环境（需要在conda的base环境下）
## --wildcards通配符模式，-xf解压缩并提取文件，--strip 1只提取压缩文件中的子目录和文件，而不包含顶层目录
tar --wildcards -xf snakemake-tutorial-data.tar.gz --strip 1 "*/data" "*/environment.yaml"
mamba env create --name snakemake-tutorial --file environment.yaml

# 激活环境，查看帮助（需要重新连接一次激活mamba）
mamba activate snakemake-tutorial
snakemake --help

官方的示例是跑一个bwa比对流程，用samtools转sam文件并排序后，最终使用bcftools进行变异检测，一套标准的call genomic variants流程。

示例数据结构如下：

data文件夹中是工作流需要用到的数据，包括基因组序列.fa及其索引文件，和三个测序数据.fastq文件。

environment.yaml文件是示例中需要用到的软件，我这里pip部分需要改源和手动安装（默认的pip源安装软件会超时报错）。

1

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pysam==0.22

基本用法主要参考官方：Basics: An example workflow | Snakemake 8.10.6 documentation

Snakefile是snakemake默认读取的文件，记录程序运行过程中的数据来源、程序命令、参数、输出目录等等。运行snakemake会自动寻找目录下是否有这个文件，如果你改了这个文件的名字，需要在运行时指定参数 -s。

1
2
3
4
5
6
7
8
9
10
11
12

# 创建Snakefile
vim snakefile

# 编写rule
rule bwa_map:
    input:
        "data/genome.fa",
        "data/samples/A.fastq"
    output:
        "mapped_reads/A.bam"
    shell:
        "bwa mem {input} | samtools view -Sb > {output}"

以上就是snakemake最简单的用法，以下是使用的两个基本点：

• Snakefile基本组成单位是rule，定义一个规则，也就是一个处理步骤。
• 每个rule包含三个基本元素：input、output、shell/run/script。input为输入文件，一个文件一行，注意逗号不能省略，python会连接后续字符串，没有逗号会导致文件读取错误。output定义输出文件，不存在的路径会自动创建。shell/run/script是要在shell中执行的命令，或者要执行的python代码，shell类似于python的subprocess模块创建子进程。

以上Snakefile文件仅支持空格whitespace，不支持缩进写法，tab键无法被识别。当输入输出文件有多行的时候，逗号会将每个文件以一个空格的形式分隔，也就是执行前会将{input}部分替换为data/genome.fa data/samples/A.fastq。

但是shell中不用逗号，可以将两行字符串直接连接，注意每个字符串需要有一个尾随空格（默认是直接连接一起的，两个字符串之间没有空格）。

在运行snakemake前，我们可以伪执行一次检测是否有输入输出文件的错误：

1
2

snakemake -np
# -n是dry-run，伪执行；-p是打印生成的shell命令

没有报错说明这个rule的逻辑没有问题，可以直接执行：

1
2
3
4
5

snakemake --core 1
# 分配一个核执行该snakefile

snakemake --core 1 mapped_reads/A.bam
# 也可以指定输出文件来确定执行的是哪个rule

运行时需要指定整个流程同时最多使用的核心数量，每个rule中可以用threads定义该rule使用的线程数。

Snakemake运行的逻辑是指定输出的文件或者目录，Snakemake为了拿到这个结果文件会一层层往上寻找得到该文件的流程，跳过不需要执行的rule。所以书写的时候每个rule之间的顺序不重要，只是书写代码的时候方便我们阅读。

上面的作业命令在运行结束后，结果文件不会被再次创建（即使你重新运行一遍命令），除非更改文件的时间戳，snakemake仅在输入文件比输出文件更新，或者输入文件被其他作业更改后才可以重新运行作业命令。

实际上一个工作流往往含有多个rule，我们会制定多个rule将工作流中的所有步骤模块化写入，snakemake会自动分析不同rule之间的input和output的依赖关系，从而将这个流程串联起来。

rule all是一个特殊的规则，用于定义工作流中的主要输出文件或目标，也就是指定我们希望整个工作流生成的结果。Snakemake 将根据 rule all中定义的目标来确定需要运行的规则，以确保生成这些目标文件，简化工作流的管理和执行过程。

比如上面的例子，我们希望最终得到mapped_reads/A.bam这个结果，可以加上一个rule all：

1
2
3
4
5
6
7
8
9
10
11
12

rule all:
    input:
        "mapped_reads/A.bam"
        
rule bwa_map:
    input:
        "data/genome.fa",
        "data/samples/A.fastq"
    output:
        "mapped_reads/A.bam"
    shell:
        "bwa mem {input} | samtools view -Sb > {output}"

在复杂一些的流程中会加入这个规则，作为snakemake运行的入口，一般只需要定义input，因为一个流程的最终输出结果是其他rule的output。snakemake会从rule all的input向上一层层回溯，找到最初rule的input文件，也就是我们的原始文件，比如这里的测序文件和基因组文件，从而理清整个流程并依次执行。

如果一个rule的input和output文件不被其他rule依赖，则这个rule不会被执行。

上面的这些操作如果没有在命令行中指定目标文件，且Snakefile中没有定义rule all，将会默认执行第一条规则。

以上例子我们用了具体的文件名作为输入和输出，实际应用时往往有批量的文件需要作为输入或者输出文件，snakemake可以使用通配符进行命名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

SAMPLES = ['A', 'B', 'C']

rule all:
    input:
        expand("mapped_reads/{sample}.bam", sample=SAMPLES),

rule bwa_map:
    input:
        REF="data/genome.fa",
        FQ="data/samples/{sample}.fastq",
    output:
        BAM="mapped_reads/{sample}.bam",
    shell:
        "bwa mem {input.REF} {input.FQ}| samtools view -Sb > {output.BAM}"

以上例子就很形象地体现了snakemake的python特性：

• expand()是snakemake内部函数，用于定义规则的输入、输出或其他需要动态生成文件路径的地方。
• {sample}通配符用来指定由SAMPLES列表生成的文件路径。
• 这里的input和output我们可以看做是python中的字典类型变量，比如input.REF表示访问字典input中的键为REF的值，相当于调用了input这个对象的REF属性，当然也就可以写成input[REF]，这样可以有效区分输入输出的文件及顺序。

当然，说到python也可以用列表推导式来表示输出的文件名：

1
2
3
4
5
6
7
8
9

# 使用列表推导式，省去了SAMPLES列表。替代rule all规则中input对象expand()函数表示的文件名。
## 以下两种方式等效于
expand("mapped_reads/{sample}.bam", sample=SAMPLES),

## 1.格式化输出,比如%s字符串占位，%d整数占位
["mapped_reads/%s.bam" % sample for sample in ["A", "B","C"]],

## 2.format()在字符串对象上调用方法，传入相应的值格式化字符串，{}占位
["mapped_reads/{}.bam".format(sample) for sample in ["A","B","C"]],

如果有多个参数列表，expand()函数也可以对应传入：

1
2
3

expand("mapped_reads/{sample}.{replicate}.bam", sample=SAMPLES, replicate=[0,1])
## 输出["mapped_reads/A.0.bam","mapped_reads/A.1.bam","mapped_reads/B.0.bam","mapped_reads/B.1.bam","mapped_reads/C.0.bam","mapped_reads/C.1.bam"]
## 共6个文件，当然这里并没有6个输出文件，只是个示范

如果样本数多，有一定的规律可循，则可以使用glob_wildcards()函数和使用wildcards对象提取文件名称和路径，这两者都是使用类似shell命令中的通配符访问对象，但是两者在使用方法上有一些区别。

假设我们现在有以下sample的双端测序文件：

1

files = ["fastq/sample1_R1.fastq", "fastq/sample1_R2.fastq", "fastq/sample2_R1.fastq", "fastq/sample2_R2.fastq"]

glob_wildcards()可以接受多个通配符表达式，返回的是一个元组类型数据：

1
2
3
4
5

(SAMPLES, PAIR) = glob_wildcards("fastq/{sample}_{pair}.fastq")

# 返回值，两个列表组成的元组
SAMPLES = ["sample1","sample2"]
PAIR = ["R1","R2"]

wildcards 也就是通配符对象，用来捕获单个文件名中的通配符信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

(SAMPLES, PAIR) = glob_wildcards("fastq/{sample}_{pair}.fastq")

rule all:
    input:
        expand("result/{sample}_{pair}/result.txt", sample=SAMPLES, pair=PAIR)

rule fastq:
    input:
        FQ="fastq/{sample}_{pair}.fastq",
    output:
        RES="result/{sample}_{pair}/result.txt",
    shell:
        """
echo {wildcards.sample} > {output.RES}
echo {wildcards.pair} >> {output.RES}
"""
## 生成的result文件结构如下，每个txt文件中分别记录了sample名和双端测序编号：
result
├── sample1_R1
│   └── result.txt
├── sample1_R2
│   └── result.txt
├── sample2_R1
│   └── result.txt
└── sample2_R2
    └── result.txt

shell中也可以直接用三引号将要运行的shell程序包含进去，shell中不能直接识别通配符{sample}和{pair}。在Snakemake规则中，input和 output可以直接使用通配符（wildcards）的语法，如{sample} 和 {pair}，来引用通配符的值。在 shell部分中，需要使用{wildcards.<通配符名>} 的语法来引用通配符的值，也就是通过wildcards对象访问其属性值。

回到一开始下载的数据，再次提醒glob_wildcards()函数返回的是元组类型，所以当只匹配一个变量的时候，需要添加逗号！否则会找不到文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

(SAMPLES,) = glob_wildcards("data/samples/{sample}.fastq") 

rule all:
    input:
        expand("mapped_reads/{sample}.bam", sample=SAMPLES),

rule bwa_map:
    input:
        REF="data/genome.fa",
        FQ="data/samples/{sample}.fastq",
    output:
        BAM="mapped_reads/{sample}.bam",
    shell:
        "bwa mem {input.REF} {input.FQ}| samtools view -Sb > {output.BAM}"

顺便再提一句，snakemake在格式化shell命令时，使用花括号{}表示通配符引用的内容，如果在shell命令中有使用花括号的命令，需要使用两个花括号进行转义。

1
2
3
4
5
6
7
8
9
10

rule example_rule:
    input:
        "data/samples/A.fastq"
    output:
        "output_file.txt"
    shell:
        """
        # 在这里使用双花括号来转义花括号
        ls data/samples/{{A,B,C}}.fastq > {output}
        """

一般在snakefile文件中，我们会先定义各种变量名，但是当原始数据比较多的时候全都写在一个文件中会比较乱。为了使snakemake脚本更加通用，可以使用配置文件，将分析需要用到的原始数据、参考基因组等写入到配置文件中。

配置文件可以书写成JSON或者YAML格式，读入为python的字典类型对配置参数和值进行定义。

以官方代码仓库中的call SNP流程的部分配置文件为例：

dna-seq-gatk-variant-calling/config/config.yaml at main · snakemake-workflows/dna-seq-gatk-variant-calling (github.com)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

samples: config/samples.tsv
units: config/units.tsv

ref:
  species: homo_sapiens
  release: 98
  build: GRCh38

filtering:
  vqsr: false
  hard:
    snvs:
      "QD < 2.0 || FS > 60.0 || MQ < 40.0 || MQRankSum < -12.5 || ReadPosRankSum < -8.0"
    indels:
      "QD < 2.0 || FS > 200.0 || ReadPosRankSum < -20.0"

在snakefile中调用配置文件参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# common.smk定义了各种需要用的脚本以及配置参数
configfile: "config/config.yaml"

# ref.smk中定义
rule get_genome:
    output:
        "resources/genome.fasta",
    log:
        "logs/get-genome.log",
    params:
        species=config["ref"]["species"],
        datatype="dna",
        build=config["ref"]["build"],
        release=config["ref"]["release"],
    cache: True
    wrapper:
        "0.74.0/bio/reference/ensembl-sequence"

可以看到调用字典key值的方式就可以定义配置参数了，用configfile: "config.yaml"读取成字典，变量名为config。

这个例子定义了很多子模块执行不同的功能，就像搭积木一样，将这些模块搭成一套完整的分析流程。

上面的例子中还有几个其他常用参数顺便也记录下。

6.1 日志 log

在运行的时候我们会发现snakemake的日志是直接输出到屏幕的，我们可以选择保存的位置，使用log参数定义输出的日志。运行出错时，在log里面定义的文件不会被snakemake删掉，而output里面的文件则会被删除。

6.2 规则参数 params

有时在shell中，需要根据不同的样本使用不同的参数，该参数其既不是输入文件，也不是输出文件，如bwa mem -R 参数。如果把这些参数放在input里，则会因为找不到文件而出错。snakemake使用params关键字来设置这些参数。

bwa mem -R 设置reads标头，放到一对引号中，也就是sam文件中的RG部分，同一样品可能包括多个测序结果，来自不同lane，不同文库，或者不同样品的比对结果合并到同一个文件中进行处理，需要通过RG进行标记区分。RG每个标记用冒号分割键和值，不同标记用 ‘\t’ 分隔。例如‘@RG\tID:foo\tSM:bar\tLB:library1’

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

(SAMPLES,) = glob_wildcards("data/samples/{sample}.fastq") 

rule all:
    input:
        expand("mapped_reads/{sample}.bam", sample=SAMPLES),

rule bwa_map:
    input:
        REF="data/genome.fa",
        FQ="data/samples/{sample}.fastq",
    output:
        BAM="mapped_reads/{sample}.bam",
    threads: 8 # threads定义线程数
    params:
        rg="@RG\tID:{sample}\tSM:{sample}"
    shell:
        "bwa mem -R '{params.rg}' -t {threads} {input.REF} {input.FQ}| samtools view -Sb - > {output.BAM}"

6.3 运行时间和内存

在该关键字下的文件会自动记录该规则运行所消耗的时间和内存。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

(SAMPLES,) = glob_wildcards("data/samples/{sample}.fastq") 

rule all:
    input:
        expand("mapped_reads/{sample}.bam", sample=SAMPLES),

rule bwa_map:
    input:
        REF="data/genome.fa",
        FQ="data/samples/{sample}.fastq",
    output:
       protected(BAM="mapped_reads/{sample}.bam"),
    threads: 8
    params:
        rg="@RG\tID:{sample}\tSM:{sample}"
    log:
        "logs/bwa_mem/{sample}.log"
    benchmark:
        "benchmarks/{sample}.bwa.benchmark.txt"
    shell:
        "bwa mem -R '{params.rg}' -t {threads} {input.REF} {input.FQ}| samtools view -Sb - > {output.BAM}"

6.4 wrapper

指定一个包装器（wrapper）脚本，这个包装器脚本可以用来自动化地配置和运行特定软件或工具。使用 wrapper 关键字可以简化规则的编写，尤其是对于需要复杂参数设置或环境配置的软件工具。

具体来说，wrapper 关键字的作用包括：

1. 自动化软件配置：通过指定一个包装器脚本，可以在规则中自动化配置软件的安装路径、参数设置、环境变量等。这样可以简化规则的编写，并确保软件的正确配置。
2. 版本控制：包装器脚本通常会包含特定软件版本的配置信息，这样可以确保在不同环境中使用相同版本的软件，避免版本不一致导致的问题。
3. 参数设置：包装器脚本可以预先设置好软件的参数，使得在规则中调用软件时不需要重复指定参数，减少了重复劳动。
4. 环境隔离：包装器脚本可以帮助实现软件运行环境的隔离，确保规则中调用的软件在一个独立的环境中执行，避免与其他软件或库的冲突。

比如前面的例子用了"0.74.0/bio/reference/ensembl-sequence"这个wrapper值，实际上用的是以下包装好的脚本：

ENSEMBL-SEQUENCE | Snakemake wrappers (snakemake-wrappers.readthedocs.io)

这些打包好的脚本可以在如下的官方网站查找：

The Snakemake Wrappers repository | Snakemake wrappers (snakemake-wrappers.readthedocs.io)

6.5 其他

不一一列举了，放个表格：

运行参数：

1
2
3
4
5
6
7
8
9
10
11
12

# 设置出错后重新运行次数
snakemake --restart-times 3

# 可视化，生成有向无环图
snakemake --dag  | dot -Tsvg > dag.svg
snakemake --dag  | dit -Tpdf > dag.pdf

# 指定snakemake运行的文件
snakemake -s Snakefile

# 伪运行
snakemake -np

生成的有向无环图（也就是这里的流程图）如下：

自己只是简单粗浅地了解了下Snakemake这个工作流软件，越是了解越是发现其便捷和强大之处。之前做生信分析流程东一块代码西一串数据，写的博客也是零零散散，真的很有必要把流程给串起来形成一套方便维护的流程代码，需要学习的东西还有很多。

Snakemake还有非常多的优点这里没有一一体现出来，比如其支持大规模的平行计算（等到学校集群联网了，一定试试怎么投递slurm作业），可移植性强（多种依赖工具的支持，conda环境、singularity、jupyter），分析流程模块化（分解成多个rule，用include调用）。

自己在摸索的时候也看到官方很多工作流示例，国内也有很多质量非常高的进阶教程，都需要我慢慢去理解和动手测试。

Snakemake+RMarkdown定制你的分析流程和报告-腾讯云开发者社区-腾讯云 (tencent.com)

这里先挖个坑，有空把我使用GATK call SNP和INDEL的流程自己写一遍，加深对snakemake的理解，再请教下师兄怎么联合jupter使用snakemake，毕竟写python代码还是jupter用起来比较舒服，测试也比较方便。

基因家族（gene family），是来源于同一个祖先，由一个基因通过基因重复而产生的一组基因，它们在结构和功能上具有明显的相似性，编码相似的蛋白质产物，行使相似的功能。同一个基因家族有着相同的保守结构域（domain），我们可以根据这个特点从蛋白序列中筛选目标基因家族成员。

以我做的WRKY基因家族为例，简单讲讲怎么鉴定候选的基因家族成员，这里只需要用到待分析物种的蛋白序列即可。

将蛋白序列（数量要少于10万条）先在直系同源蛋白注释网站eggNOG-mapper上自动注释一遍：

eggNOG-mapper (embl.de)

这个网站的用法在前面的博客中有写，不罗嗦了。基因组注释（6）——在线版eggNOG-mapper注释功能基因

目的是为了获得结果文件out.emapper.annotations.xls最后一列Pfam数据库的注释（其他列的KEGG和GO注释结果也可以用来做富集分析）。Pfam数据库是个蛋白家族数据库，提供各个基因家族的隐马尔可夫模型(HMM)。

网页版eggNOG-mapper的注释原理就是用hmmer3工具将所有蛋白序列在Pfam数据库搜寻最佳匹配的HMM，再用phmmer工具针对由最佳匹配HMM搜索每个query蛋白及对应的注释，见下面参考文献：

Fast genome-wide functional annotation through orthology assignment by eggNOG-mapper | bioRxiv

相当于网站帮我们做了hmm search，我们只需要筛选最后一列，输入关键词WRKY，删除H列描述（Description）中可能与WRKY无关的基因，可以看到有50个候选的WRKY基因家族成员。这个时候就可以把A列（query）基因名提取出来，查找基因名对应的蛋白序列，复制整理出候选基因家族蛋白序列。

上面的注释结果中不一定有目的基因家族成员，这个时候需要我们直接从Pfam网站下载对应基因家族的HMM模型，或者使用多序列比对构建HMM模型，再进行基于蛋白结构域的比对寻找候选的基因家族成员。

2.1 使用TBtools的Simple HMM Search功能

TBtools这个软件功能还是比较全的，确实可以实现无代码做基因家族分析。但是我觉得还是有必要了解一下原理，毕竟软件是别人做的，过度依赖的话会导致自己处于被动的地位。

首先下载pfam全库的HMM模型：

https://ftp.ebi.ac.uk/pub/databases/Pfam/current_release/Pfam-A.hmm.gz

解压之后大概1.5个G的大小，这里面包含了所有HMM模型！

打开TBtools的Simple HMM Search功能页面：

第一个输入框是物种蛋白序列文件。

第二个输入框是解压之后的pfam全库模型。

第三个输入框是你需要查找的HMM模型编号，比如我这里想要查找编号为PF03106的WRKY基因家族模型，就创建一个文件第一行写入PF03106即可（可以多个模型，一个模型编号一行）。一般通过文献中给出的HMM模型编号（PF号），或者在Pfam数据库直接搜基因家族对应的结构域信息得到模型编号。Search - InterPro (ebi.ac.uk)

第四个输入框指定输出文件位置和名称。

结果文件可以分为Sequence scores和Domain scores两部分，根据自己需要对E-value进行过滤。

也可以看到这个工具就是调用了hmmsearch进行的同源序列搜寻。

如果很不巧你的基因家族在pfam网站没有相关的保守结构域，那就需要进行多序列比对构建自己的HMM模型了。

我在tbtools作者的知乎账号里有看到有使用多序列比对结果进行HMMsearch，但是在最新的2.081版本里没有看到相关功能插件…

插件 | 地表最强 Hmmer Search 界面工具 - 知乎 (zhihu.com)

不过不影响，我们可以直接用HMMER软件包。

2.2 使用HMMER软件包

使用HMMER软件包需要对以下两个主要程序有个大致的理解：

• hmmbuild： 使用多序列比对构建HMM模型
• hmmsearch：使用HMM模型搜索蛋白序列库

还是以WRKY基因家族为例，在pfam网站上直接下载WRKY结构域的HMM模型（搜索PF03106，点击Curation、Download）

1
2
3
4
5
6

hmmsearch --cut_tc --domtblout Ap-WRKY.out PF03106.hmm Ap_rmTE.pep.fa

# --cut_tc使用cut_tc算法对隐马可夫模型进行搜索
## 可选--cut_ga、--cut_nc和--cut_tc，分别是GA gathering、NC noise和trusted cutoffs
# --domtblout保存结构域的名中结果到输出文件
## 可选输出模式--tblout、--domtblout、--pfamtblout

我这里用到的输出格式--domtblout，选择最后一个输出格式就和上面tbtools出来的结果完全一样了。

这里筛选出候选的基因家族成员后，我们还可以进一步的构建自己这个物种的WRKY基因家族HMM模型。对于前面说的，如果pfam网站没有你想要的保守结构域信息，我们也可以找到其他物种的同源蛋白，基于多序列比对结果构建HMM模型。

1
2
3
4
5
6
7
8
9
10
11

grep -v "#" Ap-WRKY.out|awk '($7 + 0) < 1E-20'|cut -f1 -d " "|sort -u > Ap-WRKY-geneid.txt
# 滤掉包含"#"字符的注释行，将第7列转换为数字并检查是否小于1E-20，按空格分隔每行并提取第一个字段，排序并去重，得到基因id

seqkit grep -f Ap-WRKY-geneid.txt Ap_rmTE.pep.fa > Ap-WRKY.fasta
# 提取蛋白序列

mafft --localpair --maxiterate 1000 Ap-WRKY.fasta > WRKY-aln.fas
# mafft多重序列比对，也可以用clustal、muscle等等。保存为fasta格式或者STOCKHOLM格式（.sto）

hmmbuild Ap_WRKY.hmm WRKY-aln.fas
# 构建HMM模型

这一步构建的模型和你从pfam官网下载的HMM模型格式是一样的（这里除了GA/TC/NC参数，下面说），只不过用了我们自己的序列比对结果做为种子，训练多序列比对结果构建HMM模型。接下来使用构建的HMM模型扫描物种的蛋白数据库，进一步寻找候选的基因家族成员。

1
2
3
4
5
6
7
8

hmmsearch --domtblout WRKY.out Ap_WRKY.hmm Ap_rmTE.pep.fa
# 再次对蛋白数据集进行HMM搜索

grep -v "#" WRKY.out|awk '($7 + 0) < 1E-20'|cut -f1 -d " "|sort -u > WRKY-geneid.txt
# 过滤

seqkit grep -f WRKY-geneid.txt Ap_rmTE.pep.fa > WRKY.fasta
# 提取

需要注意一点，如果你用的fa格式的多序列比对结果构建的HMM，是不包含GA、TC和NC参数的。只有用官方推荐的SELEX或者Stockholm格式（PFAM友好的多序列比对格式）才会有上面三个参数，否侧你用--cut_tc这样指定算法是会报错的！

一个可以转换多序列比对格式的网站，需要可以自取：
https://sequenceconversion.bugaco.com/converter/biology/sequences/fasta_to_phylip.php

这种方式找到的候选基因家族数量比上面直接hmmsearch得到的数量多，也是需要自己确定阈值筛选的。

2.3 HMMER补充说明

HMMER软件包功能远不止上面的构建HMM模型和搜寻同源序列，顺便就再介绍下其他功能和操作。

一个蛋白可能有多种结构域，比如说我想确定上面候选的WRKY基因家族成员中还包含了哪些其他结构域该怎么办？这个时候可以用到hmmscan命令，使用蛋白序列搜寻HMM库。

1
2
3
4
5
6
7
8
9

gzip -d Pfam-A.hmm.gz
# 解压pfam全库HMM模型

hmmpress Pfam-A.hmm
# 构建索引

hmmscan -o result.txt --tblout result2.txt --domtblout result3.txt -E 1e-5 Pfam-A.hmm WRKY.fasta
# 以Pfam-A.hmm为参考，注释蛋白结构域信息
## 输出参数还可以用--tblout、--domtblout，这俩输出方式都比-o输出的直观

可以看到前面鉴定的WRKY基因家族成员中还有Plant_zn_clust这个结构域，这也是常见于WRKY基因家族中的一种锌指结构域。

顺便再提一嘴，HMMER也有线上的服务，见phmmer search | HMMER (ebi.ac.uk)

提供了包括前面说的hmmscan和hmmsearch两个功能，不过这两个功能不能指定你自己的蛋白数据集，只能用网上的数据库，比如Reference Proteomes、SwissProt、Ensembl这些。换句话说，如果你的物种比较小众，或者没有注释地比较完整的蛋白库，那你就不能通过这个网站去鉴定基因家族，也没法自建HMM模型。

如果你做的是模式植物，那么恭喜你，选择第一个高置信度的参考蛋白组数据库Reference Proteomes，指定特定的物种名即可。

再顺便说一下另外两个功能：

• phmmer：与blastp类似，使用一个蛋白质序列搜索蛋白质序列库
• jackhmmer：与psiBlast类似，蛋白质序列迭代搜索蛋白质序列库

Jackhmmer是一种基于HMM的迭代搜索算法，可以使用一条或多条蛋白质序列，在蛋白质序列数据库中寻找同源序列。首先用输入序列构建一个初始的HMM模型，在指定的数据库中搜索，将这些匹配的序列，加入到输入序列中（也就是迭代的过程），重新构建一个HMM，并重复搜索过程，直到达到最大迭代次数或没有新的匹配序列为止。优点是可以发现较远的同源序列，提高敏感性和准确性。

官方都有示例数据可以在线跑，操作一遍就能理解了。

我们往往会用多种方法验证基因家族鉴定的结果，常见的是使用blastp。关于怎么使用blastp我就不多说了，可以见我以前的博客blastn & blastp 寻找同源基因

还有在线网站，比如NCBI的CDD数据库Home - Conserved Domains - NCBI (nih.gov)

可以使用Batch CD-Search功能模块，对鉴定的基因家族成员蛋白序列在进行一次结构域预测，结果如下：

一方面可以验证鉴定的基因家族准确性，另一方面还可以用CDD预测的结果画保守结构域图，这个下次再说。

还是要先了解一下概念：顺式作用元件（cis-regulatory element，CRE），是与结构基因串联的一段非编码DNA序列，起到调节邻近基因的转录作用（cis的拉丁语意思就是同一侧，即与调节的基因在同一段DNA序列上）。

顺式作用元件并不是只存在于转录位点的上游！最早的顺式作用模块的定义最初用于描述增强子，可以见下面这篇文献：

A systems biology approach to understanding cis-regulatory module function - ScienceDirect

如今顺式作用元件（或者称顺式作用模块，CRM）定义为具有转录因子结合位点的DNA序列，包括了启动子、增强子、沉默子、绝缘子等等，所以它可以在基因的上游、下游甚至基因内发挥作用！

而现在的基因家族顺式作用元件预测，清一色取基因上游1000 - 2000 bp左右序列，这或多或少有失偏颇。2000 bp的长度只是包括启动子区域（如果是细菌的话，2000 bp甚至可能取到其他基因区域了），而离转录起始位点比较远的，比如增强子就没有办法检测到了。所以我认为真核生物的这2000 bp长度，只能说是启动子区域的顺式作用元件预测。

上面说了这么多，其实就想吐槽一下这样的公式化论文太多……做科研的同时要想想我们这么做的目的是什么，而不是一味套模板

回到正题，我们也取起始密码子上游的2000 bp序列，做基因家族启动子区域的顺式作用元件预测。

使用seqkit软件从fa格式的基因组文件和gtf格式的注释文件中提取起始密码子上游序列：

1
2
3
4
5
6

seqkit subseq --gtf Ap_rmTE.gtf --feature start_codon --up-stream 2000 --only-flank --gtf-tag transcript_id /public/home/wlxie/Genome/Ap.fasta > upstream.fa

# --feature 指定feature
# --up-stream 指定上游序列
# --only-flank 不包括feature
# --gtf-tag 基因名添加gtf文件中的tag名

得到的上游序列格式如图，基因名会在最后加上指定的tag名：

根据tag和自己需要分析的基因名之间的对应关系，可以把自己需要的基因的上游序列挑出来，顺便可以重命名一下。

将挑选的基因启动子区域序列（fasta格式）上传到PlantCARE进行顺式元件预测：

PlantCARE, a database of plant promoters and their cis-acting regulatory elements (ugent.be)

结束后会收到一封邮件，附件中有预测结果，我们只需要plantCARE_output_PlantCARE_5730.tab这种格式的汇总文件，这个文件可以重命名为xls格式，就可以在excel中打开编辑了。

我这里50个基因，预测的启动子区域顺式作用元件有8718个，需要根据自己实验进行数据过滤。举个例子，我想要知道这些启动子区域的顺式元件有哪些功能，我的筛选标准是：

1. 删除CAAT-box和TATA-box，因为这两个是转录起始必须的，在功能上对我的分析内容没有任何帮助
2. 删除第二列没有命名的顺式元件
3. 删除最后一列没有功能注释的顺式元件

这样删除后8718个顺式元件就只剩下了1230个，平均下来一个基因有功能注释的启动子区顺式元件有20个左右，在可以接受的范围。

将最后一列功能注释找个翻译软件翻译一下，一共也就40个左右类型，根据功能描述，将它们进行分类以及最后一列批量替换，如下：

D列是起始位点，E列是顺式元件长度，F列是正负链，G是预测的物种，H是改后的功能名称。

简单来说，我将这些顺势元件的功能分为了光反应相关（light_responsive）、激素响应相关（hormone_responsive）、生长发育相关（development_related）和环境胁迫相关（environmental_stress）共四种类型。

看到有的分析会把顺式元件做个结构图显示出来，比如下面这样的（做两个bed文件，然后在GSDS网站中可视化）：

我个人觉得实在意义不大，这种处理相当于是把这2000 bp序列看作是一个基因序列，每个顺式作用元件相当于外显子给可视化出来。且不说顺式元件只有10 bp不到，所有“外显子”看起来一样大，而且功能分类太多，一个结构图上花花绿绿的各种颜色，无法让人一眼get你想表达什么信息。

我觉得还不如直接统计预测的各种顺式元件是什么功能，上面的四种功能分区分别有多少成员，这种让人一眼可以得到有效信息的统计图更实在。因此，位置信息就没有任何作用了，对表格进一步精简，只保留A列、B列和H列即可，重命名为：cis.classification.tab.xls

我这里对显示的基因有顺序要求，我需要将同一个亚家族的基因放在一起进行比较。因此，需要一个给基因排序的文件order.txt：

就是简单给基因进行手动排序，方便后续AI添加x轴和y轴的分类。作图使用R，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

library(tidyverse)
library(ggplot2)
setwd("D:\\zhuomian\\WRKY\\04.cis-acting")

df <- read_tsv("D:\\zhuomian\\WRKY\\04.cis-acting\\cis.classification.tab.xls",col_names = F)

# 第三列排序
df <- df %>% arrange(X3)

# 第二列和第三列去重，重设因子水平
uniq_level <- df %>% distinct(X2,X3)
df$X2 <- factor(df$X2, levels = uniq_level$X2)

# 整理数据, 按照第一列X1和第二列X2进行分组，对每个组计算数量，并将结果保存在新的列number中，按照数量（降序）进行排序，重新赋值给tidy
tidy <- df %>%
  group_by(X1,X2) %>%
  summarise(number = n()) %>%
  arrange(desc(number))

# 从文件中读取排序顺序(基因家族的亚家族分组)
order <- readLines("order.txt")
tidy$X1 <- factor(tidy$X1, levels = order)
tidy <- tidy[order(tidy$X1), ]

low <- rgb(255,240,235,max = 255)

# ggplot作统计图
ggplot(tidy, aes(x = X2, y = X1, fill = number)) +
  geom_tile(color = 'black') +
  geom_text(aes(label = number),col='black',cex = 3, size = 13) +
  scale_fill_gradient(low = low, high = "red") + 
  scale_x_discrete(position = "top")+
  theme_classic() +
  theme(
    legend.title = element_blank(),
    legend.position = "bottom",
    axis.ticks = element_blank(),
    axis.line = element_blank(),
    axis.text.x = element_text(angle = 90, hjust = 0),
    axis.title = element_blank(),
    axis.text = element_text(size = 13, color = 'black')
)
ggsave("cis_acting_element-1.svg",device = "svg",width = 18,height = 13)

主图出来后，简单用AI添加x轴和y轴的分类即可（x轴顺式元件名称是按照四个功能类型分组的），如下：

同样，还可以做一个堆积柱状图来统计四种功能的顺式元件个数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 重设因子水平，做第二个水平方向的堆积柱状图
uniq_level_1 <- df %>% distinct(X3)
df_1 <- df
df_1$X3 <- factor(df_1$X3, levels = rev(uniq_level_1$X3))

tidy_1 <- df_1 %>%
  group_by(X1,X3) %>%
  summarise(number = n()) %>%
  arrange(desc(number))

# 从文件中读取排序顺序(按照分组)
order <- readLines("order.txt")
tidy_1$X1 <- factor(tidy_1$X1, levels = order)
tidy_1 <- tidy_1[order(tidy_1$X1), ]
# 堆积图的颜色分类
group4 <- rgb(164,255,255,max = 255)
group3 <- rgb(255,240,147,max = 255)
group2 <- rgb(211,190,231,max = 255)
group1 <- rgb(185,255,206,max = 255)
color <- c(group4,group3,group2,group1)

ggplot(tidy_1, aes(x = number, y = X1, fill = X3)) +
  geom_col(position = "stack", width = 0.8) +
  geom_text(aes(label = number), color = 'black', cex = 3, position = position_stack(vjust = 0.5), size = 13) +
  theme_classic() +
  scale_fill_manual(values = color) +
  scale_x_continuous() +
  scale_x_continuous(guide = guide_axis(position = "top"), expand = c(0,0), breaks = seq(0, 35, by = 5))+
  guides(fill = guide_legend(reverse = TRUE)) +
  theme(
    legend.title = element_blank(),
    legend.text = element_text(size = 13),
    axis.text = element_text(size = 13, color = 'black'),
    axis.title = element_blank(),
    #axis.text.y = element_blank(),
    axis.line.y = element_blank(),
    axis.ticks.y = element_blank(),
    axis.ticks.length.x = unit(0.2,'cm'),
    axis.ticks = element_line(size = 0.8),
    axis.line = element_line(size = 0.8)
  )
ggsave("cis_acting_element-2.svg",device = "svg",width = 18,height = 13)

出图如下：

做这种水平的堆积图只是为了方便拼接上面的统计图（因为Y轴基因顺序完全一致），也可以做成正常的堆积柱状图展示，这里就不作多解释了。

Short Time-series Expression Miner (STEM)，翻译过来叫短时间序列表达挖掘，原先开发的时候就是为了做基因表达时序分析的。官方建议的时间点（也就是处理组）不超过8个，因为超过8个组表达趋势会过于零碎和复杂，这种情况下可以做WGCNA分析，暂且不表。

安装STEM需要在windows系统上先安装JAVA。STEM官网如下：

STEM: Short Time-series Expression Miner (cmu.edu)

下载之后，双击stem.jar即可运行，下面是软件的UI：

参数虽然有很多，但是很多都是可以用默认的。

1.1 Expression data info

导入前面取的差异基因并集，比如说我用 |log2(foldchange)| > 1 的标准进行差异基因筛选，就可以整理以下tsv表格：

分别代表4 h和12 h两个时间点相对对照组的差异基因表达倍数变化趋势，如果你有重复组，还可以点Repeat Data按钮进行补充。

导入数据有三种标准化方式，如果你用的是表达量（比如TPM、FPKM），可以使用第一个log2标准化，或者第二个表达量差值的标准化。这两个标准化方式都是以第一个时间点为对照，一个是取表达量差值的log值，一个直接取差值。

如果你和我一样用的是表达量倍数（一般情况下做趋势分析也是关注表达量倍数的变化）就选第三种，也就是不进行标准化，因为我们用的已经是相对对照组的变化倍数了。第三种标准化方式会添加一个表达量为0的虚拟样本，实际上并不存在，可以理解为我这里的0 h对照组。

1.2 Gene info

这一栏主要是做每个模块（cluster）内基因富集注释用的，可以选择官方注释数据库，或者提供基因注释文件。我这个是非模式植物，后续需要手动构建KEGG和GO注释库进行富集分析，这里也暂时不表。

1.3 Options

这一栏是对聚类参数进行调整的，可以选择聚类方法，包括stem的聚类方法或者是K-means聚类方法。

主要的参数是Maximum Number of Model profiles，这个参数决定我们的差异基因最多可以分为几个cluster。不要用默认参数50！我这里相当于有3组，只需要设置8个cluster就足够了，数量太多反而会让趋势碎片，不方便我们进行趋势分析。

Maximum Unit Change in Model Profiles between Time Points这个参数是设置一个cluster模型可以在不同时间点改变的最大单位，改变这个参数会影响最终分组后的p值，这个问题不大，用默认即可。也可以看看用户手册有官网的详细描述。

在Advanced Options设置中可以设置基因的筛选条件、注释文件的细节等等，如果前面选择的聚类方法为K-means的话，也可以点击去调节细节，这里也不赘述了。

1.4 Execute

前面的参数设置完成之后，点击这一栏黄色高亮的Excute即可。

点击每个cluster可以看详细的信息，包括这一个cluster中的基因数量，每一个基因的表达模式，还可以导出每一个cluster的基因信息。

我们可以点击底下黄色高亮的Order Profiles By设置cluster的显示方式，比如可以加上p值（Significance，显著性特征），可以看到这些有颜色的cluster是p值比较低，也就是置信度比较高的。

需要注意，那些p值为1的cluster不代表没有意义的表达趋势，还是要看我们感兴趣的差异基因在哪个模块，或者对我们感兴趣的基因对应地做分析！

上面这种转录组趋势分析图放在10年前可以说比较有亮点，因为STEM软件是2006年开发出来的，至今虽然也有大量的转录组分析文章在用，但是在今天看来，它能展示的信息量还是有点捉襟见肘。

介绍一个中国药科大学的博士师兄做的R包ClusterGVis：

junjunlab/ClusterGVis: One-step to Cluster and Visualize Gene Expression Matrix (github.com)

这个R包可以一步将趋势分析结果与基因的表达量结合一起，并且如果你自己有做每个cluster基因的富集分析的话，还可以把富集结果放在一张图中进行展示。作者在github上展示了这个R包的详细用法，我这里只做个人使用记录，向大佬表示感谢！！！

2.1 准备含有标记基因的基因表达量矩阵

比如我这里的TPM.marker.tsv文件，格式如下：

1
2
3
4
5
6
7
8
9
10
11

0h4h12h
g1068.6220088512.79421660748.90308827
g10710.96566020.07309914111.04575138
g1087.3901515922.88389237916.17186854
g1100.6562150570.0180024740.256361386
g35850.3256077711.397635542.439213784
g36060.6937637191.8254220526.159699021
g36095.4375238682.3687140613.914576455
g36111.680554276.0646174466.313053585
g361837.2204663415.1275186621.1622645
ApWRKY39.83848891547.2981500663.77491512

我这里用的是各个组的差异基因TPM表达量，对于自己感兴趣的基因，重命名为Ap开头的基因，也就是标记基因（比如差异基因里有你感兴趣的基因家族）。当然，如果你没有感兴趣的基因也可以不标记。这个表达量矩阵是做热图用的，也是做cluster聚类的基础。

2.2 cluster聚类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

setwd("D:\\zhuomian\\WRKY\\06.transcriptome\\clustergvis")

# 因为要从github上安装这个R包和依赖，所以设置个代理
install.packages("r.proxy")
library("r.proxy")
r.proxy::proxy()

devtools::install_github("igraph/rigraph")
devtools::install_github("cysouw/qlcMatrix")
devtools::install_github("junjunlab/ClusterGVis")
devtools::install_github("jokergoo/ComplexHeatmap")

library("ClusterGVis")

# 载入数据
a <- read.table(file = "TPM.marker.tsv", header=T, row.names = 1, check.names=F)
head(a,3)

# 计算均方和，确定聚类个数
getClusters(exp = a)

# mfuzz聚类
cm <- clusterData(exp = a,
                  #cluster.method = "kmeans",
                  cluster.method = "mfuzz",
                  cluster.num = 8)

# 绘制折线图（kmeans聚类的话没有颜色映射，因为没有membership信息）
visCluster(object = cm,
           plot.type = "line",
           ms.col = c("green","orange","red"),  # 线条颜色
           add.mline = TRUE  # 中位线
           )

这里可以选择使用K-means或者mfuzz包进行聚类，getcluster函数出图如下，可以帮助你确认聚类个数，我这里选择8：

绘制的聚类折线图如下：

2.3 每个cluster进行富集分析

前面的R代码中，我们把聚类结果保存在了cm变量中，可以点开这个变量看具体的聚类结果：

简单来说，cluster聚类结果在cm[["wide.res"]][cluster]中，同一个cluster中的基因用同一种数字表示。

一个很笨但是有效的方法，把每个cluster的基因名调出来，每个cluster基因都做一遍GO和KEGG富集分析，非模式生物构建方法可见上一篇博客非模式生物的GO和KEGG富集 - 我的小破站 (shelven.com)

我们不需要展示所有富集结果，简单来说，可以将cluster富集结果分别做一个KEGG和GO统计结果表如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 文件cluster.all.GO.tsv（每组取前五富集结果）
groupDescriptionpvalueratio
GO:00045191endonuclease activity4.73E-077.7102804
GO:00045181nuclease activity4.14E-067.7102804
GO:00903051obsolete nucleic acid phosphodiester bond hydrolysis7.53E-067.9439252
.
.
.
GO:00303128external encapsulating structure0.0005777345.5105348
GO:00716698plant-type cell wall organization or biogenesis0.0010348883.0794165
GO:00312268obsolete intrinsic component of plasma membrane0.0013435653.8897893

# 文件cluster.all.KEGG.tsv（每组取前五富集结果）
groupDescriptionpvalueratio
ko040161MAPK signaling pathway - plant0.1811313024.4585987
ko009041Diterpenoid biosynthesis0.1811313021.910828
ko009101Nitrogen metabolism0.1811313021.910828
.
.
.
ko000738Cutin, suberine and wax biosynthesis0.0026698451.8115942
ko040758Plant hormone signal transduction0.1050323174.3478261
ko009108Nitrogen metabolism0.1232640961.4492754

2.4 组合趋势聚类图、表达量热图以及注释结果

就是调参数的问题啦~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

# 添加标记基因（就是判断你要展示的基因是哪些行，这里我是Ap开头的基因）
rows_to_select <- grepl("Ap", rownames(a))
markGenes <- rownames(a)[rows_to_select]
#markGenes = rownames(a)[sample(1:nrow(a),30,replace = F)]

# 绘制热图
visCluster(object = cm,
           plot.type = "heatmap",
           column_names_rot = 45,
           markGenes = markGenes, # 标记基因
           ht.col.list=list(col_range = c(-2, 0, 2),col_color = c("#FC7C5A", "white", "#81C7C1")),
           ctAnno.col = ggsci::pal_npg()(8),  #修改注释条颜色
)

# 富集结果输入（整理的富集结果）
enrich <- read.table("cluster.all.GO.tsv", sep = "\t",header=T)
head(enrich,3)
enrich.KEGG <- read.table("cluster.all.KEGG.tsv",  sep = "\t",header=T)
head(enrich.KEGG,3)

palette = c("Grays","Greens2","Blues2","Blues3","Purples2","Purples3","Reds2","Reds3")

lapply(seq_along(unique(enrich$group)), function(x){
  # GO plot
  tmp <- enrich |> dplyr::filter(group == unique(enrich$group)[x]) |>
    dplyr::arrange(desc(pvalue))
  
  tmp$Description <- factor(tmp$Description,levels = tmp$Description)
  
  # plot
  p <-
    ggplot(tmp) +
    geom_col(aes(x = -log10(pvalue),y = Description,fill = -log10(pvalue)),
             width = 0.75) +
    #geom_line(aes(x = log10(ratio),y = as.numeric(Description)),color = "grey50") +
    geom_point(aes(x = log10(ratio),y = Description),size = 3,color = "coral1") +
    theme_bw() +
    scale_y_discrete(position = "right",
                     labels = function(x) stringr::str_wrap(x, width = 40)) +
    scale_x_continuous(sec.axis = sec_axis(~.,name = "log10(ratio)")) +
    colorspace::scale_fill_binned_sequential(palette = palette[x]) +
    ylab("")
  
  # KEGG plot
  tmp.kg <- enrich.KEGG |> dplyr::filter(group == unique(enrich.KEGG$group)[x]) |>
    dplyr::arrange(desc(pvalue))
  
  tmp.kg$Description <- factor(tmp.kg$Description,levels = tmp.kg$Description)
  
  # plot
  pk <-
    ggplot(tmp.kg) +
    geom_segment(aes(x = 0,xend = -log10(pvalue),y = Description,yend = Description),
                 lty = "dashed",linewidth = 0.75) +
    geom_point(aes(x = -log10(pvalue),y = Description,color = -log10(pvalue)),size = 5) +
    theme_bw() +
    scale_y_discrete(position = "right",
                     labels = function(x) stringr::str_wrap(x, width = 40)) +
    colorspace::scale_color_binned_sequential(palette = palette[x]) +
    ylab("") + xlab("-log10(pvalue)")
  
  # combine
  cb <- cowplot::plot_grid(plotlist = list(p,pk))
  
  return(cb)
}) -> gglist
names(gglist) <- paste("C",1:8,sep = "")

# 组合图
pdf('final_result.pdf',height = 20,width = 20,onefile = F)
visCluster(object = cm,
           plot.type = "both",
           markGenes = markGenes,
           line.side = "left",
           markGenes.side = "right",
           column_names_rot = 45,
           cluster.order = c(1:8),
           ctAnno.col = ggsci::pal_nejm()(8),
           ggplot.panel.arg = c(5,0.5,32,"grey90",NA),
           ht.col.list=list(col_range = c(-2, 0, 2),col_color = c("#81C7C1", "white", "#FC7C5A")),
           gglist = gglist,
           show_row_dend = F)
dev.off()

直接出图结果如下：

这样的出图基本上是不用改的，最多用AI调一调位置，大小。或者在R里调一下表达量热图的三个颜色：

ht.col.list=list(col_range = c(-2, 0, 2),col_color = c("#81C7C1", "white", "#FC7C5A"))

根据自己的数据调整一下就行，这种出图质量直接用于文章是完全没问题的，而且展示的信息量也足够多~

因为我们要做的物种是非模式生物，所有背景基因需要我们亲自注释，这里只推荐eggNOG，速度快，可以本地运行或者在线运行，在线运行有10万条序列的限制。在线网页的介绍可以看我的这篇笔记：基因组注释（6）——在线版eggNOG-mapper注释功能基因 - 我的小破站 (shelven.com)

假设我们已经拿蛋白序列做了注释，在一大堆结果文件中我们只需要out.emapper.annotation。用notepad++打开，去掉带“#”符号的前三行，把表头的query前面的“#”注释也给去掉，这些处理做好后文件如下：

后续都是从这个文件中找到基因名与GO和KEGG号之间的对映关系。

假设我们从基因家族收缩/扩张分析、转录组等等数据已经拿到了我们想要的序列，创建一个新文件，一行一个基因名放入我们要分析的序列，文件命名为gene.txt如下所示：

首先进行GO注释库的构建：

1
2
3
4
5
6
7

# 下载最新的GO库注释
wget http://purl.obolibrary.org/obo/go/go-basic.obo
# 处理注释文件，主要是帮我们找对应关系
grep "^id:" go-basic.obo |awk '{print $2}' > GO.id
grep "^name:" go-basic.obo | awk -F ': ' '{print $2}' > GO.name
grep "^namespace:" go-basic.obo |awk '{print $2}' > GO.class
paste GO.id GO.name GO.class -d "\t" > GO.library

构建的GO注释库如下：

第一列是GO号，第二列是描述（注意要完整的描述，而非一个单词，否则后续因为描述重复而无法富集！），第三列是GO分类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

library(clusterProfiler)
library(dplyr)
library(stringr)

setwd("D:\\zhuomian\\基因家族进化\\GO")# 设置自己的工作目录

## GO注释生成
options(stringsAsFactors = F)
egg <- read.delim("out.emapper.annotations",header = T,sep="\t")
egg[egg==""]<-NA
gterms <- egg %>%
  dplyr::select(query, GOs) %>% na.omit()
gene_ids <- egg$query
eggnog_lines_with_go <- egg$GOs!= ""
eggnog_annoations_go <- str_split(egg[eggnog_lines_with_go,]$GOs, ",")
gene2go <- data.frame(gene = rep(gene_ids[eggnog_lines_with_go],# 一个基因可能有多个GOterm，需要拆分成1：1对应关系
                      times = sapply(eggnog_annoations_go, length)),
                      term = unlist(eggnog_annoations_go))
go2name <- read.delim('GO.library', header = FALSE, stringsAsFactors = FALSE)
names(go2name) <- c('ID', 'Description', 'Ontology')

# GO富集
gene_select <- read.delim(file = 'gene.txt', stringsAsFactors = FALSE,header = F)$V1
go_rich <- enricher(gene = gene_select,
                    TERM2GENE = gene2go[c('term','gene')], # 这两项都要注意顺序
                    TERM2NAME = go2name[c('ID', 'Description')], 
                    pvalueCutoff = 1, 
                    pAdjustMethod = 'BH', 
                    qvalueCutoff = 1
)
tmp <- merge(go_rich, go2name[c('ID', 'Ontology')], by = 'ID')
tmp <- tmp[c(10, 1:9)]
tmp <- tmp[order(tmp$pvalue), ]
write.table(tmp, 'GO_enrichment.xls', sep = '\t', row.names = FALSE, quote = FALSE)

看一下生成的GO_enrichment.xls文件如下：

我们一般拿到这个文件后，根据qvalue值从小到大筛选可信度最高的富集结果，再手动去掉不合理的（比如你做植物，却注释到动物和微生物的）。

做到这一步生成GO富集文件就可以了（再做就不礼貌了），GO富集结果可以在R做可视化，但是我觉得没必要，真的，调参数真的太难受了，而且每个人作图的要求都不一样。我个人比较建议在一些在线网站上手动画，比如这个网站：ChiPlot

网站的开发者在B站传过可视化富集结果的教学视频：【ChiPlot】绘制KEGG/GO富集图_哔哩哔哩_bilibili

省流不看版

根据富集结果，筛选molecular function、biological process和cellular component三个类别中qvalue值前5的GO term，计算第四列的GeneRatio值。

创建一个新的excel表，需要5列内容，如下：

type那一列不需要，只是为了方便展示，id这一列的列名可以随意，Description、Qvalue、Count、GeneRatio四列列名必须要一样，顺序无所谓。

再做一个展示图层的excel，作用是区分GO term属于哪个类型：

传到上面网站的KEGG/GO富集作图的模块，手动调整参数（自己多试一下）再加点AI作图，反正比我R做的好一些：

思路和GO注释是类似的，相比GO，KEGG可选择的物种会多一些，我们这里仍然当作是非模式生物，以第一步eggNOG注释的基因集为背景基因集。

构建KEGG注释库：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 下载KEGG注释库 https://www.genome.jp/kegg-bin/get_htext?ko00001，点击 Download json，下载得到ko00001.json文件

library(clusterProfiler)
library(dplyr)
library(stringr)
library(jsonlite)

setwd("D:\\zhuomian\\基因家族进化\\KEGG")

pathway2name <- tibble(Pathway = character(), Name = character())
ko2pathway <- tibble(Ko = character(), Pathway = character())
kegg <- fromJSON("ko00001.json")

for (a in seq_along(kegg[["children"]][["children"]])) {
  A <- kegg[["children"]][["name"]][[a]]
  for (b in seq_along(kegg[["children"]][["children"]][[a]][["children"]])) {
    B <- kegg[["children"]][["children"]][[a]][["name"]][[b]] 
    for (c in seq_along(kegg[["children"]][["children"]][[a]][["children"]][[b]][["children"]])) {
      pathway_info <- kegg[["children"]][["children"]][[a]][["children"]][[b]][["name"]][[c]]
      pathway_id <- str_match(pathway_info, "ko[0-9]{5}")[1]
      pathway_name <- str_replace(pathway_info, " \\[PATH:ko[0-9]{5}\\]", "") %>% str_replace("[0-9]{5} ", "")
      pathway2name <- rbind(pathway2name, tibble(Pathway = pathway_id, Name = pathway_name))
      kos_info <- kegg[["children"]][["children"]][[a]][["children"]][[b]][["children"]][[c]][["name"]]
      kos <- str_match(kos_info, "K[0-9]*")[,1]
      ko2pathway <- rbind(ko2pathway, tibble(Ko = kos, Pathway = rep(pathway_id, length(kos))))
    }
  }
}
colnames(ko2pathway) <- c("KO","Pathway")

write.table(pathway2name,"KEGG.library",sep="\t",row.names = F)

构建的KEGG注释库如下：

第一列是ko号，第二列是ko号对应的代谢通路描述，同样的，需要注意一个基因可能对应多个ko号，在对映关系上需要做一些处理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

## KEGG注释生成
options(stringsAsFactors = F)
egg <- read.delim("out.emapper.annotations",header = T,sep="\t")
egg[egg==""]<-NA
gene2ko <- egg %>%
  dplyr::select(GID = query, KO = KEGG_ko) %>%
  na.omit()

pathway2name <- read.delim("KEGG.library")
colnames(pathway2name)<-c("Pathway","Name")

ko2gene <- tibble(Ko=character(),GID=character())
for (Query in gene2ko$GID){
  ko_list <- strsplit(gene2ko$KO[which(gene2ko[,1]==Query)],split = ',')
  for (ko in ko_list){
    if (length(which(ko2gene[,1]==ko))==0){
      tmp <- data.frame(Ko=ko,GID=Query)
      ko2gene <- rbind(ko2gene,tmp)
    }
    else{
      old_Query <- ko2gene$GID[which(ko2gene[,1]==ko)]
      ko2gene$GID[which(ko2gene[,1]==ko)] <- paste(old_Query,Query,sep = ',')
    }
  }
}

pathway2gene <- tibble(Pathway = character(), GID = character())

for (ko in ko2pathway$KO){
  pathway_list <- ko2pathway$Pathway[which(ko2pathway[,1]==ko)]
  for (pathway in pathway_list){
    if (paste('ko:',ko,sep='') %in% ko2gene$Ko){
      ko <- paste('ko:',ko,sep='')
      if (length(which(pathway2gene[,1]==pathway))==0 ){
        ko2gene$GID[which(ko2gene[,1]==ko)]
        tmp <- data.frame(pathway=pathway,GID=ko2gene$GID[which(ko2gene[,1]==ko)])
        pathway2gene <- rbind(pathway2gene,tmp)
      }
      else{
        old_Query <- pathway2gene$GID[which(pathway2gene[,1]==pathway)]
        Query <- ko2gene$GID[which(ko2gene[,1]==ko)]
        pathway2gene$GID[which(pathway2gene[,1]==pathway)] <- paste(old_Query,Query,sep=',')
      }
    }
  }
}

new_pathway2gene <- data.frame()# 遍历pathway2gene每一行，拆分gene

for (i in 1:nrow(pathway2gene)) {
  pathway <- pathway2gene$pathway[i]
  genes <- strsplit(as.character(pathway2gene$GID[i]), ",")[[1]]
  for (gene in genes) {
    new_row <- data.frame(pathway = pathway, gene = gene)
    new_pathway2gene <- rbind(new_pathway2gene, new_row)
  }
}

#KEGG富集
gene_select <- read.delim ('gene.txt', stringsAsFactors = FALSE,header = F)$V1
kegg_rich <- enricher (gene = gene_select,
                       TERM2GENE = new_pathway2gene[c ('pathway','gene')], 
                       TERM2NAME = pathway2name[c ('Pathway','Name')], 
                       pvalueCutoff = 1, 
                       pAdjustMethod = 'BH', 
                       qvalueCutoff = 1, 
                       maxGSSize = 500)

write.table (kegg_rich, 'KEGG_enrichment.xls', sep = '\t', row.names = FALSE, quote = FALSE)

最终得到的KEGG富集结果KEGG_enrichment.xls如下：

同样是根据qvalue筛选，剔除不合理的富集通路（比如你做的植物，富集到动物、微生物等代谢通路），作图是和GO富集作图一模一样的，这里不赘述了。

剔除不合理的代谢通路

顺便说一下，KEGG结果中会有不少不合理的地方，比如我注释的植物基因代谢通路，会有挺多注释到非植物相关的KEGG通路……

当然，我们可以一个个在KEGG官网查询富集的通路信息，也可以在R中把KEGG的所有植物代谢通路整理出来。这里需要用到一个R包KEGGREST快速获取KEGG数据库信息，需要注意，通过BiocManager下载的KEGGREST包已经不能正常使用了（2022年6月1日调用API地址发生了变化），需要在github上下载最新版：

1
2
3
4
5

# 国内或许会出现网络问题，需要一点魔法（摊手）
## 不要找别人备份的库，可能也会有问题，认准官方Bioconductor
library(devtools)
devtools::install_github("https://github.com/Bioconductor/KEGGREST")
library(KEGGREST)

参考代码：玩转KEGG (二)——植物富集到了动物通路？难不成咱研究的植物人儿😂 - 知乎 (zhihu.com)

具体思路是用KEGGREST包抓取植物物种信息，获取每个KEGG库中植物的代谢通路，取并集：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

org <- data.frame(keggList("organism"))
plants <- org[grep("Plants", org$phylogeny), ]# 选取植物的物种信息
pathways_tot <- vector()

for (i in 1:length(plants$organism)) {
  try({
    pathways <- keggLink("pathway", plants[i,2])
    pathways <- sub(paste(".*",plants[i,2], sep = ""), "", pathways)
    pathways <- unique(pathways)
    pathways_tot <- append(pathways_tot,pathways)
    pathways_tot <- unique(pathways_tot) })
}

pathways_tot <- paste0("ko", pathways_tot)
writeLines(pathways_tot, "plants.kegg.txt")

每一个物种都要抓取ko号，所以时间会有点慢，大概10分钟左右。

可以看到现在KEGG中一共有152个植物，取代谢通路的并集后，每行输出结果。

最后用我熟悉的python简单处理过滤一下：

1
2
3
4
5
6
7
8
9
10
11

with open('plants.kegg.txt', 'r') as file:
    ko_plant = file.read().splitlines()

with open('KEGG_enrichment.xls','r') as input, open('KEGG_enrichment.filter.xls','w') as output:
    for line in input:
        if line.startswith('ko'):
            id = line.split('\t')[0]
            if id in ko_plant:
                output.write(line)
        else:
            output.write(line)

费这么老大劲功夫不如上KEGG官网把前几个代谢通路搜一下…..（想给自己一嘴巴子）

KEGG PATHWAY: ko03250 (genome.jp)

把网址上的ko改一改，看一下description就行…不过有的描述不是很清楚，这样过滤一遍准确性肯定是提高的。

最后把KEGG富集结果拿到Chiplot上做图即可：

最重要的就是要拿到你想要分析物种的基因组数canX据，做基因家族分析的话蛋白质序列文件、CDS序列文件这两个是必需的。如果要做共线性分析（如MCScan’X），还要有gff文件，以及对组装的基因组有要求，一定是要组装到染色体级别（只有contigs的共线性分析是没有意义的）。