【问题标题】:Sequence alignment of multiple slices of ints in golanggolang中多个整数切片的序列比对
【发布时间】:2017-02-25 07:27:30
【问题描述】:

我试图弄清楚如何使用 golang 对齐稍微不完美的二进制切片。以下四个切片都以不同的偏移量正确对齐。但是,并非每一位都是相同的(标记如下),所以我不能只比较原始块。

func main() {

    // Match all three slices up (ignoring occasional errors)
    s1 := []int16{0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1}
    s2 := []int16{ /*                     */ 0, 1, 1, 0, 0, 0, 1, 1, 1, 1}
    //                                       ^              ^
    s3 := []int16{0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1}
    //               ^
    s4 := []int16{ /*            */ 0, 0, 0, 1, 1, 1, 0, 0}

    slices := make([][]int16, 3)
    slices = append(slices, s1, s2, s3, s4)


    offsets := forgivingSyncHere(slices)
}

这是https://play.golang.org/p/zqJ_4qLc8O

【问题讨论】:

  • 在一般情况下,这是与DNA alignment 类似的问题。解决此类问题的算法有些复杂。

标签: arrays go match slice


【解决方案1】:

这取决于您的“成本”函数是什么,您的目标是在哪里最小化您的“成本”。

成本函数可能是这样的。这个想法是“不匹配”比没有任何匹配的成本更高,我们称之为“超支”(比如两倍的成本)。将a[i] != b[i + offset] 的a 和b 等于s1,s2,s3,s4 的情况数加倍。然后将每个配对的每个offset 的绝对值(在本例中为 4 个数组的 6 个配对)添加到开头的超限次数。然后在最后添加超出部分。

样本成本函数:

func cost(sn [][]int16, offsets [][]int) int {
  // cost accumulator
  c := 0.0

  // the factor of how much more costly a mismatch is than an overrun
  mismatchFactor := 2.0

  // define what you want, but here is an example of what I said above
  for i1:=0;i1<len(sn);i++ {
    for i2:=i1+1;i2<len(sn);i2++ {
      c += mismatchFactor * diff(sn[i1], sn[i2], offsets[i1][i2])
      c += math.Abs(offsets[i1][i2])
      c += math.Abs(len(sn[i1]) + offsets[i1][i2] - len(sn[i2]))
    }
  }
}

// offset of the offset of s1 wrt s2
func diff(s1 []int16, s2 []int16, offset int) int {
  // index, index, diff total
  i1,i2,d := 0,0,0
  if offset >= 0 {
    i1 += offset
  } else {
    i2 -= offset
  }
  while i1<len(s1) && i2<len(s2) {
    if s1[i1] != s2[i2] {
      d++
    }
    i1++
    i2++
  }
  return d
}

随心所欲地制作成本函数,这只是一个示例。然而,假设你有一个成本函数,蛮力算法很容易想出。不过,您可以尝试优化算法:)。有很多想法。这与具有编辑距离的字符串搜索算法非常相似。维基百科和谷歌有很多结果。

免责声明:所有这些都未经测试:),但它应该让你开始

【讨论】:

    【解决方案2】:

    相似性可以使用 Levenshtein 距离(也称为编辑距离)来描述 - 一个字符串必须经历的插入、删除和突变的次数才能变成另一个字符串。

    这使您可以定量地谈论相似度,例如编辑距离与两个字符串长度中较短的长度的比率可能是一个合理的指标,但这取决于您所说的相似度究竟是什么意思。

    从那里您可以找到每对要比较的字符串中相同子字符串的长度和数量的下限。在您的情况下,通过观察您的示例,看起来 4 位是您认为的匹配项。 IOW,如果您使用 4 位块,并检查给定序列对的精确匹配,匹配块的数量告诉您它们的相似性是多少?

    如果您对足够小的子字符串进行精确比较,则可以保证至少有几个匹配,即使差异是均匀分布的(如果它们是聚集在一起的,较大的部分将具有精确匹配,因此较短的部分的长度字符串除以最大编辑距离)。

    考虑相似性位置的字符串通用近似匹配的精确解决方案是计算密集型的(并且相关且经过充分研究的问题是最长公共子序列),此外还必须应用于每对序列进行比较,不是每个序列独立。相比之下,选择适当的块大小并通过其可能的子字符串对每个字符串进行索引仅取决于孤立的每个字符串,并且可以提供一个近似的答案。您当然可以记下位置并进一步限制它。

    总而言之,对于您所描述的问题,一个简单的解决方案可能很难解决,实际上序列对齐和近似字符串匹配是通过解决一个更简单的问题来完成的,然后使用更天真/昂贵的方法。

    Rabin Fingerprinting 是一种比 n-gram(滑动窗口)更复杂的将字符串分解为子字符串的方法,但它是一种随机方法,会产生可变大小的字符串(但具有确定性),因此计算边界是一种更多的参与。

    【讨论】:

      猜你喜欢
      • 2019-01-08
      • 2013-03-15
      • 2019-03-15
      • 2017-08-29
      • 1970-01-01
      • 2018-01-09
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多