Question

首先，我的问题有一些背景知识。
我是一名生物信息学家，这意味着我要进行信息学治疗以试图回答一个生物学问题。在我的问题中，我必须操作一个名为FASTA文件的文件，该文件如下所示：

>Header 1  
ATGACTGATCGNTGACTGACTGTAGCTAGC  
>Header 2  
ATGCATGCTAGCTGACTGATCGTAGCTAGC  
ATCGATCGTAGCT

因此，FASTA文件基本上只是一个头，后跟一个'>'字符，然后是一个或多个由核苷酸组成的行上的序列。核苷酸是可以采用5种可能值的字符：A，T，C，G或N。

我想做的是计算每种核苷酸类型出现的次数，因此，如果我们考虑这个虚拟FASTA文件：

>Header 1  
ATTCGN

因此，我应该拥有：
A:1 T:2 C:1 G:1 N:1

这是我到目前为止得到的：

ifstream sequence_file(input_file.c_str());
string line;
string sequence = "";
map<char, double> nucleotide_counts;

while(getline(sequence_file, line)) {
    if(line[0] != '>') {
        sequence += line;
    }
    else {
        nucleotide_counts['A'] = boost::count(sequence, 'A');
        nucleotide_counts['T'] = boost::count(sequence, 'T');
        nucleotide_counts['C'] = boost::count(sequence, 'C');
        nucleotide_counts['G'] = boost::count(sequence, 'G');
        nucleotide_counts['N'] = boost::count(sequence, 'N');
        sequence = "";
    }
}

因此，它逐行读取文件，如果遇到“>”作为该行的第一个字符，它将知道序列已完成并开始计数。现在我面临的问题是我有数以百万计的序列，总共有数十亿个核苷酸。我可以看到我的方法没有经过优化，因为我在同一序列上调用了boost::count五次。

我尝试过的其他方法：

解析序列以增加每种核苷酸类型的计数器。我尝试使用map<char, double>来将每个核苷酸映射到一个值，但这比Boost解决方案要慢。
使用算法库的std::count，但这也太慢了。

我在互联网上搜索了解决方案，但是如果序列数很少，我发现的每个解决方案都是好的，这不是我的情况。您有什么想法可以帮助我加快速度吗？

编辑1 ：我也尝试过此版本，但它比增强版本慢2倍：

ifstream sequence_file(input_file.c_str());
string line;
string sequence = "";
map<char, double> nucleotide_counts;

while(getline(sequence_file, line)) {
    if(line[0] != '>') {
        sequence += line;
    }
    else {
        for(int i = 0; i < sequence.size(); i++) {
           nucleotide_counts[sequence[i]]++;
        }
        sequence = "";
    }
}

编辑2 ：多亏了该线程中的每个人，与boost原始解决方案相比，我能够获得大约30倍的加速。这是代码：

#include <map> // std::array
#include <fstream> // std::ifstream
#include <string> // std::string  

void count_nucleotides(std::array<double, 26> &nucleotide_counts, std::string sequence) {
    for(unsigned int i = 0; i < sequence.size(); i++) {
        ++nucleotide_counts[sequence[i] - 'A'];
    }
}  

std::ifstream sequence_file(input_file.c_str());
std::string line;
std::string sequence = "";
std::array<double, 26> nucleotide_counts;

while(getline(sequence_file, line)) {
    if(line[0] != '>') {
        sequence += line;
    }
    else {
        count_nucleotides(nucleotide_counts, sequence);
        sequence = "";
    }
}

Answer 1

按重要性顺序：

此任务的好代码将100％被 I / O绑定。您的处理器可以计算字符的速度比磁盘将字符泵到CPU的速度快得多。因此，对我来说，第一个问题是：您的存储介质的吞吐量是多少？您理想的RAM和缓存吞吐量是多少？这些是上限。如果您遇到了这些问题，那么进一步查看您的代码没有什么意义。您的增强解决方案可能已经存在。
std::map查找相对昂贵。是的，它是O(log(N))，但是您的N=5很小且恒定，所以这什么也没告诉您。对于5个值，对于每次查找，映射都必须追逐大约三个指针（更不用说对于分支预测变量而言这是不可能的）。您的count解决方案对每个字符串进行5次映射查找和5次遍历，而您的手动解决方案对每个核苷酸进行映射查找（但仅对字符串进行一次遍历）。

严重的建议：对每个计数器使用局部变量。这些几乎肯定会放入CPU寄存器中，因此基本上是免费的。与map，unordered_map，vector等不同，您永远不会那样用计数器污染缓存。
像这样通过重复替换抽象通常不是一个好主意，但是在这种情况下，您将几乎不需要更多的计数器是非常不可思议的，因此可伸缩性不是问题。
考虑 std::string_view （这将需要另一种读取文件的方法）以避免创建数据副本。您将整个数据从磁盘加载到内存中，然后针对每个序列进行复制。这并不是真正必要的，并且（取决于编译器的智能程度）会使您陷入困境。尤其是因为您一直将字符串追加到下一个标头（这是不必要的复制-您只需在每一行之后计数）即可。
如果由于某种原因您没有达到理论吞吐量，请考虑使用多线程和/或向量化。但是我无法想象这是必要的。

顺便说一下，boost::count是std::count至少in this version周围的薄包装。

尽管如此，我认为您在做正确的事情：编写良好且易读的代码，然后将其识别为性能瓶颈，并检查是否可以使其运行得更快（可能会使它运行起来更加难看）。

Answer 2

之所以这么慢，是因为您始终可以间接访问或对同一字符串进行5次扫描。

您不需要映射，可以使用5个整数，然后分别递增。然后，它应该比boost::count版本更快，因为您不会遍历字符串5次，并且它将比map或unordered_map增量更快，因为您不会n次间接访问。

所以使用类似的东西：

switch(char)
{
case 'A':
    ++a;
    break;
case 'G':
    ++g;
    break;
}
...

Answer 3

就像有人在评论中建议的那样，尝试做某事

enum eNucleotide {
    NucleotideA = 0,
    NucleotideT,
    NucleotideC,
    NucleotideG,
    NucleotideN,
    Size,
};

void countSequence(std::string line)
{
    long nucleotide_counts[eNucleotide::Size] = { 0 };

    if(line[0] != '>') {
        for(int i = 0; i < line.size(); ++i) 
        {
           switch (line[i])
           {
               case 'A':
                   ++nucleotide_counts[NucleotideA];
                   break;
               case 'T':
                   ++nucleotide_counts[NucleotideT];
                   break;                   
               case 'C':
                   ++nucleotide_counts[NucleotideC];
                   break;                   
               case 'G':
                   ++nucleotide_counts[NucleotideC];
                   break;                   
               case 'N':
                   ++nucleotide_counts[NucleotideN];
                   break;                   
               default : 
                   /// error condition
                   break;
           }     
        }

    /// print results
    std::cout << "A: " << nucleotide_counts[NucleotideA];
    std::cout << "T: " << nucleotide_counts[NucleotideT];
    std::cout << "C: " << nucleotide_counts[NucleotideC];
    std::cout << "G: " << nucleotide_counts[NucleotideG];
    std::cout << "N: " << nucleotide_counts[NucleotideN] << std::endl;
    }
}

并针对每行内容调用此函数。（未经测试的代码。）

Answer 4

如果这是您必须执行的主要任务，则您可能对awk解决方案感兴趣。使用awk可以轻松解决FASTA文件的各种问题：

awk '/^>/ && c { for(i in a) if (i ~ /[A-Z]/) printf i":"a[i]" "; print "" ; delete a }
    /^>/ {print; c++; next}
    { for(i=1;i<=length($0);++i) a[substr($0,i,1)]++ }
    END{ for(i in a) if (i ~ /[A-Z]/) printf i":"a[i]" "; print "" }' fastafile

这在您的示例中输出：

>Header 1  
N:1 A:7 C:6 G:8 T:8 
>Header 2  
A:10 C:10 G:11 T:12

注意：我知道这不是C ++，但是显示其他方法来实现同一目标通常很有用。

awk基准：

测试文件：http://hgdownload.cse.ucsc.edu/goldenPath/hg38/bigZips/hg38.fa.gz
未压缩大小：2.3G
总记录：5502947
总行数：

脚本0：（运行时间：太长） 。第一个提到的脚本非常慢。仅在小文件上使用

脚本1：（运行时间：484.31秒） 。这是我们执行目标计数的优化版本：

/^>/ && f { for(i in c) printf i":"c[i]" "; print "" ; delete c }
/^>/ {print; f++; next}
{   s=$0
    c["A"]+=gsub(/[aA]/,"",s)
    c["C"]+=gsub(/[cC]/,"",s)
    c["G"]+=gsub(/[gG]/,"",s)
    c["T"]+=gsub(/[tT]/,"",s)
    c["N"]+=gsub(/[nN]/,"",s)
}
END { for(i in c) printf i":"c[i]" "; print "" ; delete c }

更新2：（运行时间：416.43秒） ：将所有子序列合并为一个序列，仅计算一个：

function count() {
    c["A"]+=gsub(/[aA]/,"",s)
    c["C"]+=gsub(/[cC]/,"",s)
    c["G"]+=gsub(/[gG]/,"",s)
    c["T"]+=gsub(/[tT]/,"",s)
    c["N"]+=gsub(/[nN]/,"",s)
}
/^>/ && f { count(); for(i in c) printf i":"c[i]" "; print "" ; delete c; string=""}
/^>/ {print; f++; next}
{ string=string $0 }
END { count(); for(i in c) printf i":"c[i]" "; print "" }

更新3：（运行时间：396.12秒） 。完善awk如何查找其记录和字段，并一次性使用。

function count() {
    c["A"]+=gsub(/[aA]/,"",string)
    c["C"]+=gsub(/[cC]/,"",string)
    c["G"]+=gsub(/[gG]/,"",string)
    c["T"]+=gsub(/[tT]/,"",string)
    c["N"]+=gsub(/[nN]/,"",string)
}
BEGIN{RS="\n>"; FS="\n"}
{
  print $1
  string=substr($0,length($1)); count()
  for(i in c) printf i":"c[i]" "; print ""
  delete c; string=""
}

更新4：（运行时间：259.69秒） 。更新gsub中的正则表达式搜索。这样可以提高速度：

function count() {
    n=length(string);
    gsub(/[aA]+/,"",string); m=length(string); c["A"]+=n-m; n=m
    gsub(/[cC]+/,"",string); m=length(string); c["C"]+=n-m; n=m
    gsub(/[gG]+/,"",string); m=length(string); c["G"]+=n-m; n=m
    gsub(/[tT]+/,"",string); m=length(string); c["T"]+=n-m; n=m
    gsub(/[nN]+/,"",string); m=length(string); c["N"]+=n-m; n=m
}
BEGIN{RS="\n>"; FS="\n"}
{
  print ">"$1
  string=substr($0,length($1)); count()
  for(i in c) printf i":"c[i]" "; print ""
  delete c; string=""
}

Answer 5

如果您想提高速度并且可以使用数组，请不要使用地图。另外，std::getline可以使用自定义定界符（而不是\n）。

ifstream sequence_file(input_file.c_str());
string sequence = "";
std::array<int, 26> nucleotide_counts;

// For one sequence
getline(sequence_file, sequence, '>');
for(auto&& c : sequence) {
    ++nucleotide_counts[c-'A'];
}

// nucleotide_counts['X'-'A'] contains the count of nucleotide X in the sequence

Demo

快速计数大量序列中的核苷酸类型

5 个答案: