通過使用 tf-idf 將文本特征化為向量來計算余弦相似度

Question

我是 Apache Spark 的新手，想從一堆文本中找到相似的文本，我自己嘗試如下 -

我有 2 個 RDD-

第一個 RDD 包含不完整的文本如下 -

[0,541 Suite 204, Redwood City, CA 94063]
[1,6649 N Blue Gum St, New Orleans,LA, 70116]
[2,#69, Los Angeles, Los Angeles, CA, 90034]
[3,98 Connecticut Ave Nw, Chagrin Falls]
[4,56 E Morehead Webb, TX, 78045]

第二個 RDD 包含正確的地址如下 -

[0,541 Jefferson Avenue, Suite 204, Redwood City, CA 94063]
[1,6649 N Blue Gum St, New Orleans, Orleans, LA, 70116]
[2,25 E 75th St #69, Los Angeles, Los Angeles, CA, 90034]
[3,98 Connecticut Ave Nw, Chagrin Falls, Geauga, OH, 44023]
[4,56 E Morehead St, Laredo, Webb, TX, 78045]

已經編寫了這段代碼，這需要很多時間，誰能告訴我使用 Scala 在 Apache Spark 中執行此操作的正確方法。

val incorrect_address_count = incorrect_address_rdd.count()
val all_address = incorrect_address_rdd.union(correct_address_rdd) map (_._2.split(" ").toSeq)

val hashingTF = new HashingTF()
val tf = hashingTF.transform(all_address)
.zipWithIndex()

val input_vector_rdd = tf.filter(_._2 < incorrect_address_count)

val address_db_vector_rdd = tf.filter(_._2 >= incorrect_address_countt)
.map(f => (f._2 - input_count, f._1))
.join(correct_address_rdd)
.map(f => (f._2._1, f._2._2))

val input_similarity_rdd = input_vector_rdd.cartesian(address_db_vector_rdd)
.map(f => {

val cosine_similarity = cosineSimilarity(f._1._1.toDense, f._2._1.toDense)

(f._1._2, cosine_similarity, f._2._2)
})


def cosineSimilarity(vectorA: Vector, vectorB: Vector) = {

var dotProduct = 0.0
var normA = 0.0
var normB = 0.0
var index = vectorA.size - 1

for (i <- 0 to index) {
dotProduct += vectorA(i) * vectorB(i)
normA += Math.pow(vectorA(i), 2)
normB += Math.pow(vectorB(i), 2)
}
(dotProduct / (Math.sqrt(normA) * Math.sqrt(normB)))
}

Answer 1

我有幾乎同樣的問題。 我有 370K 行，每行有 2 個 300K 和 400K 的向量。 我將測試 rdd 行與這兩個向量相乘。

您可以進行 2 項重大改進。 一是預先計算規范。 他們不會改變。 其次是使用稀疏向量。 如果你這樣做，你可以使用 vector.size 它是 300K。 如果您使用 Sparse，它會針對每個關鍵字進行迭代。（每行 20-30）。

另外我擔心這是最有效的方法，因為計算不需要洗牌。如果你最后有一個很好的估計，你可以按分數過濾，事情會很快。（我的意思是哪個分數對你來說就足夠了。）

def cosineSimilarity(vectorA: SparseVector, vectorB:SparseVector,normASqrt:Double,normBSqrt:Double) :(Double,Double) = {
  var dotProduct = 0.0
  for (i <-  vectorA.indices){ 
    dotProduct += vectorA(i) * vectorB(i)
  }
  val div = (normASqrt * normBSqrt)
  if( div == 0 )
    (dotProduct,0)
  else
    (dotProduct,dotProduct / div)
}