Question

假设我的长序列如下：

5’-AGGGTTTCCC**TGACCT**TCACTGC**AGGTCA**TGCA-3

这个长序列中的两个斜体子序列（在这两个星内）被称为反向重复模式。这两个子序列中的四个字母（例如A，T，G，C）的长度和组合将是变化的。但这两个子序列之间存在关联。请注意，当您考虑第一个子序列时，其互补子序列是ACTGGA（根据A结合T和G结合C），当您反转此互补子序列（即最后一个字母首先出现）时，它与第二个子序列匹配。

FASTA序列中存在大量此类模式（包含1000万条ATGC字母），我想找到这样的模式及其起点和终点位置。

Answer 1

我是Python和生物信息学的新手，但我正在通过rosalind.info网站学习两种方法。您可以使用后缀树执行此操作。后缀树（参见http://en.wikipedia.org/wiki/Suffix_tree）是神奇的数据结构，它使生物信息学中的所有事情成为可能。您可以快速找到多个长序列中的公共子串。后缀树只需要线性时间，因此长度10,000,000是可行的。

首先找到序列的反向补码。然后将两者放入后缀树中，找到它们之间的公共子串（最小长度）。

以下代码使用此后缀树实现：http://www.daimi.au.dk/~mailund/suffix_tree.html。它是用C语言编写的，带有Python绑定。它不会处理大量的序列，但是两个没有问题。但是我不能说这是否会处理10,000,000长度。

from suffix_tree import GeneralisedSuffixTree

baseComplement = { 'A' : 'T', 'C' : 'G', 'G' : 'C', 'T' : 'A' }

def revc(seq):
    return "".join([baseComplement[base] for base in seq[::-1]])

data = "AGGGTTTCCCTGACCTTCACTGCAGGTCATGCA"
# revc  TGCATGACCTGCAGTGAAGGTCAGGGAAACCCT
#       012345678901234567890123456789012
#                 1         2         3
minlength = 6

n = len(data)
tree = GeneralisedSuffixTree([data, revc(data)])
for shared in tree.sharedSubstrings(minlength):
    #print shared
    _, start, stop = shared[0]
    seq = data[start:stop]
    _, rstart, rstop = shared[1]
    rseq = data[n-rstop:n-rstart]
    print "Match: {0} at [{1}:{2}] and {3} at [{4}:{5}]".format(seq, start, stop, rseq, n-rstop, n-rstart)

这会产生输出

Match: AGGTCA at [23:29] and TGACCT at [10:16]
Match: TGACCT at [10:16] and AGGTCA at [23:29]
Match: CTGCAG at [19:25] and CTGCAG at [19:25]

它每次匹配两次，每次一次。那里也有反向回文！

Answer 2

这是一个强力实现，虽然它对超长序列可能不是很有用。

def substrings(s, lmin, lmax):
    for i in range(len(s)):
        for l in range(lmin, lmax+1):
            subst = s[i:i+l]
            if len(subst) == l:
                yield i, l, subst

def ivp(s, lmin, lmax):
    mapping = {'A': 'T', 'G': 'C', 'T': 'A', 'C': 'G'}
    for i, l, sub in substrings(s, lmin, lmax):
        try:
            from string import maketrans
        except ImportError: # we're on Python 3
            condition = sub.translate(
                       {ord(k): v for k, v in mapping.items()})[::-1] in s
        else: # Python 2
            condition = sub.translate(maketrans('ATGC', 'TACG'))[::-1] in s
        if condition:
            yield i, l, sub

让我们找到长度为6的“反向重复模式”（以及它们的起始位置和长度）：

>>> list(ivp('AGGGTTTCCCTGACCTTCACTGCAGGTCATGCA', 6, 6))
[(10, 6, 'TGACCT'), (19, 6, 'CTGCAG'), (23, 6, 'AGGTCA')]

但是，这不会检查两个模式是否重叠。例如，'CTGCAG'匹配自己。

Answer 3

我有一个想法，就是找到一个长序列的倒置回文序列。考虑整个序列的DNA序列的一部分并产生其互补序列。然后反转该补码序列的部分。然后执行这两个部分之间的动态对齐并计算它的成本（一个来自实际序列，另一个来自反向补码序列）。成本将给出一个最佳对齐的想法。现在，如果最佳对齐的成本＆gt; =阈值成本，则选择该部分并找到公共区域。该特定部分的两个共同区域将是一个反向重复单元。一旦找到该单元然后重复它以用于下一部分，则另外明智地增加部分的长度。任何人都可以实现此算法。可能是一个有用的解决方案。

Answer 4

我使用列表推导来拍摄它。我还是python的新手，但在过去5年左右的时间里一直是C＃dev。这会产生您想要的输出，尽管它绝对不能优化以便能够有效地处理1000万个字符串。

注意：因为我们将列表转换为frequency_words中的一个集合，为了删除重复的条目，结果不会被排序。

def pattern_matching(text, pattern):
    """ Returns the start and end positions of each instance of the pattern  """
    return [[x, str(len(pattern) + x)] for x in range(len(text) - len(pattern) + 1) if
            pattern in text[x:len(pattern) + x]]


def frequent_words(text, k):
    """ Finds the most common k-mers of k """
    counts = [len(pattern_matching(text, text[x:x + k])) for x in range(len(text) - k)]
    return set([text[x:x + k] for x in range(len(text) - k) if counts[x] == max(counts)])


def reverse_complement(pattern):
    """ Formed by taking the complement of each nucleotide in Pattern """
    complements = {'A': 'T', 'C': 'G', 'T': 'A', 'G': 'C'}
    return ''.join([complements.get(c, c) for c in pattern][::-1])


def find_invert_repeats(text, pattern_size):
    """ Returns the overlap for frequent words and its reverse """
    freqs = frequent_words(text, pattern_size)
    rev_freqs = frequent_words(reverse_complement(text), pattern_size)
    return [[x, pattern_matching(text, x)] for x in set(freqs).intersection(rev_freqs)]

print(find_invert_repeats("AGGGTTTCCCTGACCTTCACTGCAGGTCATGCA", 6))

[['TGACCT', [[10, '16']]], ['AGGTCA', [[23, '29']]], ['CTGCAG', [[19, '25']]]]

如何在FASTA序列中找到反向重复模式？

4 个答案: