如何在 Ruby on Rails 中使用 Redis 有效地获取两个哈希值的点积

Question

我在数据库的特征表中有一个这样的数据结构，称为 token_vector（哈希）：

Feature.find(1).token_vector = { "a" => 0.1, "b" => 0.2, "c" => 0.3 }

其中有 25 个特征。首先，我在 script/console 中将数据输入到 Redis 中：

REDIS.set(  "feature1",
            "#{ TokenVector.to_json Feature.find(1).token_vector }"
)
# ...
REDIS.set(  "feature25",
            "#{ TokenVector.to_json Feature.find(25).token_vector }"
)

TokenVector.to_json 首先将哈希值转换为 JSON 格式。 Redis 中存储的 25 个 JSON 哈希值大约占用 8 MB。

我有一个方法，称为Analysis#locate。此方法采用两个 token_vector 之间的点积。散列的点积的工作原理如下：

hash1 = { "a" => 1, "b" => 2, "c" => 3 }
hash2 = { "a" => 4, "b" => 5, "c" => 6, "d" => 7 }

散列中的每个重叠键（在本例中为 a、b 和 c，而不是 d）将其值两两相乘，然后相加。

hash1 中 a 的值为 1，hash2 中 a 的值为 4。将它们相乘得到1*4 = 4。

hash1 中 b 的值为 2，hash2 中 b 的值为 5。将它们相乘得到2*5 = 10。

hash1 中 c 的值为 3，hash2 中 c 的值为 6。将它们相乘得到3*6 = 18。

hash1 中 d 的值不存在，hash2 中 d 的值为 7。在这种情况下，为第一个哈希设置d = 0。将它们相乘即可得到 0*7 = 0。

现在将相乘的值相加。 4 + 10 + 18 + 0 = 32。这是 hash1 和 hash2 的点积。

Analysis.locate( hash1, hash2 ) # => 32

我有一个经常使用的方法，Analysis#topicize。该方法接受一个参数，token_vector，它只是一个哈希值，与上面类似。 Analysis#topicize 采用 token_vector 与 25 个特征的 token_vectors 中每一个的点积，并创建这 25 个点积的新向量，称为feature_vector。 feature_vector 只是一个数组。代码如下所示：

def self.topicize token_vector

  feature_vector = FeatureVector.new

  feature_vector.push(
    locate( token_vector, TokenVector.from_json( REDIS.get "feature1" ) )
  )
  # ...
  feature_vector.push(
    locate( token_vector, TokenVector.from_json( REDIS.get "feature25" ) )
  )

  feature_vector

end

如您所见，它采用了我在上面输入到 Redis 中的 token_vector 和每个功能的 token_vector 的点积，并将值推入一个数组。

我的问题是，每次调用该方法大约需要 18 秒。我是否误用了 Redis？我认为问题可能是我不应该将 Redis 数据加载到 Ruby 中。我是否应该向 Redis 发送数据 (token_vector) 并编写一个 Redis 函数来让它执行 dot_product 函数，而不是使用 Ruby 代码编写它？

Answer 1

您必须对其进行分析才能确定，但​​我怀疑您在序列化/反序列化 JSON 对象方面浪费了大量时间。与其将 token_vector 转换为 JSON 字符串，为什么不直接将其放入 Redis 中，因为 Redis 有 它自己的哈希类型？

REDIS.hmset "feature1",   *Feature.find(1).token_vector.flatten
# ...
REDIS.hmset "feature25",  *Feature.find(25).token_vector.flatten

Hash#flatten 的作用是将哈希值转换为 { 'a' =>; 1、'b' => 2 } 转换为 [ 'a', 1, 'b', 2 ] 这样的数组，然后我们使用 splat (*) 发送每个元素数组作为 Redis#hmset 的参数（“hmset”中的“m”代表“多个”，如“一次设置多个哈希值”）。

然后，当您想将其取回时，请使用 Redis#hgetall ，它会自动返回 Ruby 哈希值：

def self.topicize token_vector
  feature_vector = FeatureVector.new

  feature_vector.push locate( token_vector, REDIS.hgetall "feature1" )
  # ...
  feature_vector.push locate( token_vector, REDIS.hgetall "feature25" )

  feature_vector
end

但是！由于您只关心哈希中的值，而不是键，因此您可以使用 Redis#hvals 来简化事情，它只返回值的数组，而不是 hgetall。

您可能会花费大量周期的第二个地方是 locate，您尚未提供其源代码，但是有很多方法可以在 Ruby 中编写点积方法，其中一些方法他们比其他人表现更好。 这个 Ruby 讨论主题涵盖了一些有价值的内容。其中一张海报指向 NArray，一个用 C 语言实现数值数组和向量的库。

如果我理解你的代码正确的话，它可以重新实现这样的东西（先决条件：gem install narray）：

require 'narray'

def self.topicize token_vector
  # Make sure token_vector is an NVector
  token_vector  = NVector.to_na token_vector unless token_vector.is_a? NVector
  num_feats     = 25

  # Use Redis#multi to bundle every operation into one call.
  # It will return an array of all 25 features' token_vectors.
  feat_token_vecs = REDIS.multi do
    num_feats.times do |feat_idx|
      REDIS.hvals "feature#{feat_idx + 1}"
    end
  end 

  pad_to_len = token_vector.length

  # Get the dot product of each of those arrays with token_vector
  feat_token_vecs.map do |feat_vec|
    # Make sure the array is long enough by padding it out with zeroes (using
    # pad_arr, defined below). (Since Redis only returns strings we have to
    # convert each value with String#to_f first.)
    feat_vec = pad_arr feat_vec.map(&:to_f), pad_to_len

    # Then convert it to an NVector and do the dot product
    token_vector * NVector.to_na(feat_vec)

    # If we need to get a Ruby Array out instead of an NVector use #to_a, e.g.:
    # ( token_vector * NVector.to_na(feat_vec) ).to_a
  end
end

# Utility to pad out array with zeroes to desired size
def pad_arr arr, size
  arr.length < size ?
    arr + Array.new(size - arr.length, 0) : arr
end

希望这有帮助！

Answer 2

这并不是真正的答案，只是我之前评论的后续，因为这可能不适合评论。看来 Hash/TokenVector 问题可能不是唯一的问题。我这样做：

token_vector = Feature.find(1).token_vector
Analysis.locate( token_vector, TokenVector[ REDIS.hgetall( "feature1" ) ] )

并收到此错误：

TypeError: String can't be coerced into Float
from /Users/RedApple/S/lib/analysis/vectors.rb:26:in `*'
from /Users/RedApple/S/lib/analysis/vectors.rb:26:in `block in dot'
from /Users/RedApple/S/lib/analysis/vectors.rb:24:in `each'
from /Users/RedApple/S/lib/analysis/vectors.rb:24:in `inject'
from /Users/RedApple/S/lib/analysis/vectors.rb:24:in `dot'
from /Users/RedApple/S/lib/analysis/analysis.rb:223:in `locate'
from (irb):6
from /Users/RedApple/.rvm/rubies/ruby-1.9.2-p290/bin/irb:16:in `<main>'

Analysis#locate 看起来像这样：

def self.locate vector1, vector2
  vector1.dot vector2
end

这是analysis/vectors.rb 第 23-28 行的相关部分，TokenVector#dot 方法：

def dot vector
  inject 0 do |product,item|
    axis, value = item
    product + value * ( vector[axis] || 0 )
  end
end

我不确定问题出在哪里。