disco 0.2.3 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9b8792d465e2bd894ce9aaa5dabf79dd89e93337d838917c709ac7747b85772
-  data.tar.gz: 9d34a5124dc26f8a2ecb7e2ed3cbf524fe586c37c693d885e668974e24dfaf0a
+  metadata.gz: 5f400f07839587b574ddcfa4c88335bfe20fcd876164b943e8094a35c3c1cfef
+  data.tar.gz: e2426b283146837d14be154ff0e67eb2505fd6587958b39212bf2dfe3bfccd80
 SHA512:
-  metadata.gz: 658b48b75994a295382eb22908d4a5f1825b01bfc26f52428e993802c42f7ebb435a59e7f1262d17400d65eda886f1a4f38edff82cdeda96c2a0ce280602742f
-  data.tar.gz: c9acce77cae8a575c5814456247600367d5fea4eb85a52309e26cac643d107bc03c42c99ce094c2f9ec46a329fd2dfa97d2f58f0020b337feb88b56346630942
+  metadata.gz: 2be9f24184036ec5b093de55640aebb60887ac59c566f37698fcba7a18daa15cf586566708def0060f80fc0747a50447538cf42fdf36024ae19ddac0de8b415c
+  data.tar.gz: 4682a5524a8cad4a247ec53f99c78e317d56ee55433bb2ad7806af4f2a9854bc016fd23564003f009dc69d0fdcf81949dc88c64d3cbe824a8e76fc5cae8abc7d

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 0.2.7 (2021-08-06)
+
+- Added warning for `value`
+
+## 0.2.6 (2021-02-24)
+
+- Improved performance
+- Improved `inspect` method
+- Fixed issue with `similar_users` and `item_recs` returning the original user/item
+- Fixed error with `fit` after loading
+
+## 0.2.5 (2021-02-20)
+
+- Added `top_items` method
+- Added `optimize_similar_users` method
+- Added support for Faiss for `optimize_item_recs` and `optimize_similar_users` methods
+- Added `rmse` method
+- Improved performance
+
+## 0.2.4 (2021-02-15)
+
+- Added `user_ids` and `item_ids` methods
+- Added `user_id` argument to `user_factors`
+- Added `item_id` argument to `item_factors`
+
 ## 0.2.3 (2020-11-28)
 
 - Added `predict` method

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2019-2020 Andrew Kane
+Copyright (c) 2019-2021 Andrew Kane
 
 MIT License
 

data/README.md

@@ -35,24 +35,22 @@ recommender.fit([
 
 > IDs can be integers, strings, or any other data type
 
-If users don’t rate items directly (for instance, they’re purchasing items or reading posts), this is known as implicit feedback. Leave out the rating, or use a value like number of purchases, number of page views, or time spent on page:
+If users don’t rate items directly (for instance, they’re purchasing items or reading posts), this is known as implicit feedback. Leave out the rating.
 
 ```ruby
 recommender.fit([
-  {user_id: 1, item_id: 1, value: 1},
-  {user_id: 2, item_id: 1, value: 1}
+  {user_id: 1, item_id: 1},
+  {user_id: 2, item_id: 1}
 ])
 ```
 
-> Use `value` instead of rating for implicit feedback
-
-Get user-based (user-item) recommendations - “users like you also liked”
+Get user-based recommendations - “users like you also liked”
 
 ```ruby
 recommender.user_recs(user_id)
 ```
 
-Get item-based (item-item) recommendations - “users who liked this item also liked”
+Get item-based recommendations - “users who liked this item also liked”
 
 ```ruby
 recommender.item_recs(item_id)
@@ -106,11 +104,10 @@ views = Ahoy::Event.
   count
 
 data =
-  views.map do |(user_id, post_id), count|
+  views.map do |(user_id, post_id), _|
     {
       user_id: user_id,
-      item_id: post_id,
-      value: count
+      item_id: post_id
     }
   end
 ```
@@ -201,6 +198,8 @@ bin = File.binread("recommender.bin")
 recommender = Marshal.load(bin)
 ```
 
+Alternatively, you can store only the factors and use a library like [Neighbor](https://github.com/ankane/neighbor). See the [examples](https://github.com/ankane/neighbor/tree/master/examples).
+
 ## Algorithms
 
 Disco uses high-performance matrix factorization.
@@ -237,6 +236,16 @@ There are a number of ways to deal with this, but here are some common ones:
 - For user-based recommendations, show new users the most popular items.
 - For item-based recommendations, make content-based recommendations with a gem like [tf-idf-similarity](https://github.com/jpmckinney/tf-idf-similarity).
 
+Get top items with:
+
+```ruby
+recommender = Disco::Recommender.new(top_items: true)
+recommender.fit(data)
+recommender.top_items
+```
+
+This uses [Wilson score](https://www.evanmiller.org/how-not-to-sort-by-average-rating.html) for explicit feedback (add [wilson_score](https://github.com/instacart/wilson_score) to your application’s Gemfile) and item frequency for implicit feedback.
+
 ## Data
 
 Data can be an array of hashes
@@ -257,45 +266,65 @@ Or a Daru data frame
 Daru::DataFrame.from_csv("ratings.csv")
 ```
 
-## Faster Similarity
+## Performance
 
-If you have a large number of users/items, you can use an approximate nearest neighbors library like [NGT](https://github.com/ankane/ngt) to speed up item-based recommendations and similar users.
+If you have a large number of users or items, you can use an approximate nearest neighbors library like [Faiss](https://github.com/ankane/faiss) to improve the performance of certain methods.
 
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'ngt', '>= 0.3.0'
+gem 'faiss'
 ```
 
-Speed up item-based recommendations with:
+Speed up the `user_recs` method with:
 
 ```ruby
-model.optimize_item_recs
+recommender.optimize_user_recs
 ```
 
-Speed up similar users with:
+Speed up the `item_recs` method with:
 
 ```ruby
-model.optimize_similar_users
+recommender.optimize_item_recs
 ```
 
-This should be called after fitting or loading the model.
+Speed up the `similar_users` method with:
+
+```ruby
+recommender.optimize_similar_users
+```
+
+This should be called after fitting or loading the recommender.
 
 ## Reference
 
+Get ids
+
+```ruby
+recommender.user_ids
+recommender.item_ids
+```
+
 Get the global mean
 
 ```ruby
 recommender.global_mean
 ```
 
-Get the factors
+Get factors
 
 ```ruby
 recommender.user_factors
 recommender.item_factors
 ```
 
+Get factors for specific users and items
+
+```ruby
+recommender.user_factors(user_id)
+recommender.item_factors(item_id)
+```
+
 ## Credits
 
 Thanks to:
@@ -304,6 +333,28 @@ Thanks to:
 - [Implicit](https://github.com/benfred/implicit/) for serving as an initial reference for user and item similarity
 - [@dasch](https://github.com/dasch) for the gem name
 
+## Upgrading
+
+### 0.2.7
+
+There’s now a warning when passing `:value` with implicit feedback, as this has no effect on recommendations and can be removed. Earlier versions of the library incorrectly stated this was used.
+
+```ruby
+recommender.fit([
+  {user_id: 1, item_id: 1, value: 1},
+  {user_id: 2, item_id: 1, value: 3}
+])
+```
+
+to:
+
+```ruby
+recommender.fit([
+  {user_id: 1, item_id: 1},
+  {user_id: 2, item_id: 1}
+])
+```
+
 ## History
 
 View the [changelog](https://github.com/ankane/disco/blob/master/CHANGELOG.md)

data/lib/disco.rb

@@ -9,6 +9,7 @@ require "net/http"
 
 # modules
 require "disco/data"
+require "disco/metrics"
 require "disco/recommender"
 require "disco/version"
 

data/lib/disco/metrics.rb

@@ -0,0 +1,10 @@
+module Disco
+  module Metrics
+    class << self
+      def rmse(act, exp)
+        raise ArgumentError, "Size mismatch" if act.size != exp.size
+        Math.sqrt(act.zip(exp).sum { |a, e| (a - e)**2 } / act.size.to_f)
+      end
+    end
+  end
+end

data/lib/disco/recommender.rb

@@ -1,46 +1,73 @@
 module Disco
   class Recommender
-    attr_reader :global_mean, :item_factors, :user_factors
+    attr_reader :global_mean
 
-    def initialize(factors: 8, epochs: 20, verbose: nil)
+    def initialize(factors: 8, epochs: 20, verbose: nil, top_items: false)
       @factors = factors
       @epochs = epochs
       @verbose = verbose
+      @user_map = {}
+      @item_map = {}
+      @top_items = top_items
     end
 
     def fit(train_set, validation_set: nil)
       train_set = to_dataset(train_set)
       validation_set = to_dataset(validation_set) if validation_set
 
+      check_training_set(train_set)
+
+      # TODO option to set in initializer to avoid pass
+      # could also just check first few values
+      # but may be confusing if they are all missing and later ones aren't
       @implicit = !train_set.any? { |v| v[:rating] }
 
+      if @implicit && train_set.any? { |v| v[:value] }
+        warn "[disco] WARNING: Passing `:value` with implicit feedback has no effect on recommendations and can be removed. Earlier versions of the library incorrectly stated this was used."
+      end
+
+      # TODO improve performance
+      # (catch exception instead of checking ahead of time)
       unless @implicit
-        ratings = train_set.map { |o| o[:rating] }
-        check_ratings(ratings)
-        @min_rating = ratings.min
-        @max_rating = ratings.max
+        check_ratings(train_set)
 
         if validation_set
-          check_ratings(validation_set.map { |o| o[:rating] })
+          check_ratings(validation_set)
         end
       end
 
-      check_training_set(train_set)
-      create_maps(train_set)
-
       @rated = Hash.new { |hash, key| hash[key] = {} }
       input = []
-      value_key = @implicit ? :value : :rating
       train_set.each do |v|
-        u = @user_map[v[:user_id]]
-        i = @item_map[v[:item_id]]
+        # update maps and build matrix in single pass
+        u = (@user_map[v[:user_id]] ||= @user_map.size)
+        i = (@item_map[v[:item_id]] ||= @item_map.size)
         @rated[u][i] = true
 
         # explicit will always have a value due to check_ratings
-        input << [u, i, v[value_key] || 1]
+        input << [u, i, @implicit ? 1 : v[:rating]]
       end
       @rated.default = nil
 
+      # much more efficient than checking every value in another pass
+      raise ArgumentError, "Missing user_id" if @user_map.key?(nil)
+      raise ArgumentError, "Missing item_id" if @item_map.key?(nil)
+
+      # TODO improve performance
+      unless @implicit
+        @min_rating, @max_rating = train_set.minmax_by { |o| o[:rating] }.map { |o| o[:rating] }
+      end
+
+      if @top_items
+        @item_count = [0] * @item_map.size
+        @item_sum = [0.0] * @item_map.size
+        train_set.each do |v|
+          i = @item_map[v[:item_id]]
+          @item_count[i] += 1
+          @item_sum[i] += (@implicit ? 1 : v[:rating])
+        end
+      end
+
       eval_set = nil
       if validation_set
         eval_set = []
@@ -52,7 +79,7 @@ module Disco
           u ||= -1
           i ||= -1
 
-          eval_set << [u, i, v[value_key] || 1]
+          eval_set << [u, i, @implicit ? 1 : v[:rating]]
         end
       end
 
@@ -67,8 +94,12 @@ module Disco
       @user_factors = model.p_factors(format: :numo)
       @item_factors = model.q_factors(format: :numo)
 
-      @user_index = nil
-      @item_index = nil
+      @normalized_user_factors = nil
+      @normalized_item_factors = nil
+
+      @user_recs_index = nil
+      @similar_users_index = nil
+      @similar_items_index = nil
     end
 
     # generates a prediction even if a user has already rated the item
@@ -95,139 +126,239 @@ module Disco
       u = @user_map[user_id]
 
       if u
-        predictions = @item_factors.inner(@user_factors[u, true])
-
-        predictions =
-          @item_map.keys.zip(predictions).map do |item_id, pred|
-            {item_id: item_id, score: pred}
-          end
+        rated = item_ids ? {} : @rated[u]
 
         if item_ids
-          idx = item_ids.map { |i| @item_map[i] }.compact
-          predictions = predictions.values_at(*idx)
+          ids = Numo::NArray.cast(item_ids.map { |i| @item_map[i] }.compact)
+          return [] if ids.size == 0
+
+          predictions = @item_factors[ids, true].inner(@user_factors[u, true])
+          indexes = predictions.sort_index.reverse
+          indexes = indexes[0...[count + rated.size, indexes.size].min] if count
+          predictions = predictions[indexes]
+          ids = ids[indexes]
+        elsif @user_recs_index && count
+          predictions, ids = @user_recs_index.search(@user_factors[u, true].expand_dims(0), count + rated.size).map { |v| v[0, true] }
         else
-          @rated[u].keys.sort_by { |v| -v }.each do |i|
-            predictions.delete_at(i)
-          end
+          predictions = @item_factors.inner(@user_factors[u, true])
+          indexes = predictions.sort_index.reverse # reverse just creates view
+          indexes = indexes[0...[count + rated.size, indexes.size].min] if count
+          predictions = predictions[indexes]
+          ids = indexes
         end
 
-        predictions.sort_by! { |pred| -pred[:score] } # already sorted by id
-        predictions = predictions.first(count) if count && !item_ids
+        predictions.inplace.clip(@min_rating, @max_rating) if @min_rating
 
-        # clamp *after* sorting
-        # also, only needed for returned predictions
-        if @min_rating
-          predictions.each do |pred|
-            pred[:score] = pred[:score].clamp(@min_rating, @max_rating)
-          end
-        end
+        keys = @item_map.keys
+        result = []
+        ids.each_with_index do |item_id, i|
+          next if rated[item_id]
 
-        predictions
+          result << {item_id: keys[item_id], score: predictions[i]}
+          break if result.size == count
+        end
+        result
+      elsif @top_items
+        top_items(count: count)
       else
-        # no items if user is unknown
-        # TODO maybe most popular items
         []
       end
     end
 
-    def optimize_similar_items
+    def similar_items(item_id, count: 5)
       check_fit
-      @item_index = create_index(@item_factors)
+      similar(item_id, @item_map, normalized_item_factors, count, @similar_items_index)
     end
-    alias_method :optimize_item_recs, :optimize_similar_items
+    alias_method :item_recs, :similar_items
 
-    def optimize_similar_users
+    def similar_users(user_id, count: 5)
       check_fit
-      @user_index = create_index(@user_factors)
+      similar(user_id, @user_map, normalized_user_factors, count, @similar_users_index)
     end
 
-    def similar_items(item_id, count: 5)
+    def top_items(count: 5)
       check_fit
-      similar(item_id, @item_map, @item_factors, item_norms, count, @item_index)
+      raise "top_items not computed" unless @top_items
+
+      if @implicit
+        scores = Numo::UInt64.cast(@item_count)
+      else
+        require "wilson_score"
+
+        range = @min_rating..@max_rating
+        scores = Numo::DFloat.cast(@item_sum.zip(@item_count).map { |s, c| WilsonScore.rating_lower_bound(s / c, c, range) })
+
+        # TODO uncomment in 0.3.0
+        # wilson score with continuity correction
+        # https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval#Wilson_score_interval_with_continuity_correction
+        # z = 1.96 # 95% confidence
+        # range = @max_rating - @min_rating
+        # n = Numo::DFloat.cast(@item_count)
+        # phat = (Numo::DFloat.cast(@item_sum) - (@min_rating * n)) / range / n
+        # phat = (phat - (1 / 2 * n)).clip(0, 100) # continuity correction
+        # scores = (phat + z**2 / (2 * n) - z * Numo::DFloat::Math.sqrt((phat * (1 - phat) + z**2 / (4 * n)) / n)) / (1 + z**2 / n)
+        # scores = scores * range + @min_rating
+      end
+
+      indexes = scores.sort_index.reverse
+      indexes = indexes[0...[count, indexes.size].min] if count
+      scores = scores[indexes]
+
+      keys = @item_map.keys
+      indexes.size.times.map do |i|
+        {item_id: keys[indexes[i]], score: scores[i]}
+      end
     end
-    alias_method :item_recs, :similar_items
 
-    def similar_users(user_id, count: 5)
+    def user_ids
+      @user_map.keys
+    end
+
+    def item_ids
+      @item_map.keys
+    end
+
+    def user_factors(user_id = nil)
+      if user_id
+        u = @user_map[user_id]
+        @user_factors[u, true] if u
+      else
+        @user_factors
+      end
+    end
+
+    def item_factors(item_id = nil)
+      if item_id
+        i = @item_map[item_id]
+        @item_factors[i, true] if i
+      else
+        @item_factors
+      end
+    end
+
+    def optimize_user_recs
       check_fit
-      similar(user_id, @user_map, @user_factors, user_norms, count, @user_index)
+      @user_recs_index = create_index(item_factors, library: "faiss")
     end
 
-    private
+    def optimize_similar_items(library: nil)
+      check_fit
+      @similar_items_index = create_index(normalized_item_factors, library: library)
+    end
+    alias_method :optimize_item_recs, :optimize_similar_items
+
+    def optimize_similar_users(library: nil)
+      check_fit
+      @similar_users_index = create_index(normalized_user_factors, library: library)
+    end
+
+    def inspect
+      to_s # for now
+    end
 
-    def create_index(factors)
-      require "ngt"
+    private
 
-      index = Ngt::Index.new(factors.shape[1], distance_type: "Cosine")
-      index.batch_insert(factors)
-      index
+    # factors should already be normalized for similar users/items
+    def create_index(factors, library:)
+      # TODO make Faiss the default in 0.3.0
+      library ||= defined?(Faiss) && !defined?(Ngt) ? "faiss" : "ngt"
+
+      case library
+      when "faiss"
+        require "faiss"
+
+        # inner product is cosine similarity with normalized vectors
+        # https://github.com/facebookresearch/faiss/issues/95
+        #
+        # TODO use non-exact index in 0.3.0
+        # https://github.com/facebookresearch/faiss/wiki/Faiss-indexes
+        # index = Faiss::IndexHNSWFlat.new(factors.shape[1], 32, :inner_product)
+        index = Faiss::IndexFlatIP.new(factors.shape[1])
+
+        # ids are from 0...total
+        # https://github.com/facebookresearch/faiss/blob/96b740abedffc8f67389f29c2a180913941534c6/faiss/Index.h#L89
+        index.add(factors)
+
+        index
+      when "ngt"
+        require "ngt"
+
+        # could speed up search with normalized cosine
+        # https://github.com/yahoojapan/NGT/issues/36
+        index = Ngt::Index.new(factors.shape[1], distance_type: "Cosine")
+
+        # NGT normalizes so could call create_index without normalized factors
+        # but keep code simple for now
+        ids = index.batch_insert(factors)
+        raise "Unexpected ids. Please report a bug." if ids.first != 1 || ids.last != factors.shape[0]
+
+        index
+      else
+        raise ArgumentError, "Invalid library: #{library}"
+      end
     end
 
-    def user_norms
-      @user_norms ||= norms(@user_factors)
+    def normalized_user_factors
+      @normalized_user_factors ||= normalize(@user_factors)
     end
 
-    def item_norms
-      @item_norms ||= norms(@item_factors)
+    def normalized_item_factors
+      @normalized_item_factors ||= normalize(@item_factors)
     end
 
-    def norms(factors)
+    def normalize(factors)
       norms = Numo::SFloat::Math.sqrt((factors * factors).sum(axis: 1))
       norms[norms.eq(0)] = 1e-10 # no zeros
-      norms
+      factors / norms.expand_dims(1)
     end
 
-    def similar(id, map, factors, norms, count, index)
+    def similar(id, map, norm_factors, count, index)
       i = map[id]
-      if i
+
+      if i && norm_factors.shape[0] > 1
         if index && count
-          keys = map.keys
-          result = index.search(factors[i, true], size: count + 1)[1..-1]
-          result.map do |v|
-            {
-              # ids from batch_insert start at 1 instead of 0
-              item_id: keys[v[:id] - 1],
-              # convert cosine distance to cosine similarity
-              score: 1 - v[:distance]
-            }
+          if defined?(Faiss) && index.is_a?(Faiss::Index)
+            predictions, ids = index.search(norm_factors[i, true].expand_dims(0), count + 1).map { |v| v.to_a[0] }
+          else
+            result = index.search(norm_factors[i, true], size: count + 1)
+            # ids from batch_insert start at 1 instead of 0
+            ids = result.map { |v| v[:id] - 1 }
+            # convert cosine distance to cosine similarity
+            predictions = result.map { |v| 1 - v[:distance] }
           end
         else
-          predictions = factors.dot(factors[i, true]) / norms
-
-          predictions =
-            map.keys.zip(predictions).map do |item_id, pred|
-              {item_id: item_id, score: pred}
-            end
-
-          max_score = predictions.delete_at(i)[:score]
-          predictions.sort_by! { |pred| -pred[:score] } # already sorted by id
-          predictions = predictions.first(count) if count
-          # divide by max score to get cosine similarity
-          # only need to do for returned records
-          predictions.each { |pred| pred[:score] /= max_score }
-          predictions
+          predictions = norm_factors.inner(norm_factors[i, true])
+          indexes = predictions.sort_index.reverse
+          indexes = indexes[0...[count + 1, indexes.size].min] if count
+          predictions = predictions[indexes]
+          ids = indexes
         end
-      else
-        []
-      end
-    end
 
-    def create_maps(train_set)
-      user_ids = train_set.map { |v| v[:user_id] }.uniq.sort
-      item_ids = train_set.map { |v| v[:item_id] }.uniq.sort
+        keys = map.keys
 
-      raise ArgumentError, "Missing user_id" if user_ids.any?(&:nil?)
-      raise ArgumentError, "Missing item_id" if item_ids.any?(&:nil?)
+        # TODO use user_id for similar_users in 0.3.0
+        key = :item_id
 
-      @user_map = user_ids.zip(user_ids.size.times).to_h
-      @item_map = item_ids.zip(item_ids.size.times).to_h
+        result = []
+        # items can have the same score
+        # so original item may not be at index 0
+        ids.each_with_index do |id, j|
+          next if id == i
+
+          result << {key => keys[id], score: predictions[j]}
+        end
+        result
+      else
+        []
+      end
     end
 
     def check_ratings(ratings)
-      unless ratings.all? { |r| !r.nil? }
-        raise ArgumentError, "Missing ratings"
+      unless ratings.all? { |r| !r[:rating].nil? }
+        raise ArgumentError, "Missing rating"
       end
-      unless ratings.all? { |r| r.is_a?(Numeric) }
-        raise ArgumentError, "Ratings must be numeric"
+      unless ratings.all? { |r| r[:rating].is_a?(Numeric) }
+        raise ArgumentError, "Rating must be numeric"
       end
     end
 
@@ -266,7 +397,10 @@ module Disco
         rated: @rated,
         global_mean: @global_mean,
         user_factors: @user_factors,
-        item_factors: @item_factors
+        item_factors: @item_factors,
+        factors: @factors,
+        epochs: @epochs,
+        verbose: @verbose
       }
 
       unless @implicit
@@ -274,6 +408,11 @@ module Disco
         obj[:max_rating] = @max_rating
       end
 
+      if @top_items
+        obj[:item_count] = @item_count
+        obj[:item_sum] = @item_sum
+      end
+
       obj
     end
 
@@ -285,11 +424,20 @@ module Disco
       @global_mean = obj[:global_mean]
       @user_factors = obj[:user_factors]
       @item_factors = obj[:item_factors]
+      @factors = obj[:factors]
+      @epochs = obj[:epochs]
+      @verbose = obj[:verbose]
 
       unless @implicit
         @min_rating = obj[:min_rating]
         @max_rating = obj[:max_rating]
       end
+
+      @top_items = obj.key?(:item_count)
+      if @top_items
+        @item_count = obj[:item_count]
+        @item_sum = obj[:item_sum]
+      end
     end
   end
 end

data/lib/disco/version.rb

@@ -1,3 +1,3 @@
 module Disco
-  VERSION = "0.2.3"
+  VERSION = "0.2.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disco
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.7
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-28 00:00:00.000000000 Z
+date: 2021-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libmf
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description:
-email: andrew@chartkick.com
+email: andrew@ankane.org
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -51,6 +51,7 @@ files:
 - lib/disco.rb
 - lib/disco/data.rb
 - lib/disco/engine.rb
+- lib/disco/metrics.rb
 - lib/disco/model.rb
 - lib/disco/recommender.rb
 - lib/disco/version.rb
@@ -75,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Recommendations for Ruby and Rails using collaborative filtering