disco 0.2.0 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96836166496bb14ec8f973fb5e3709e0a28b7d5d8678608d074c0d7613076cc2
-  data.tar.gz: c68d12941fddc51a67938ef951be4ee809faef2e131de0f5856908d8ed1f93d9
+  metadata.gz: a7823dbe0e68967c39a59f8cdc2fe577f4366b492e0559487606b74a7de1cc84
+  data.tar.gz: ba40e46b203e424eccb811c6b042c9a283356c42585b7e00123b4bb2f232b1e2
 SHA512:
-  metadata.gz: 8b960dc961ead701713dbc7f9c104852355ac6d61f9f1f6e1cde43d1d4fa257b2c55859ca42896a6780f006d25f5ff613bf0261e601033db7d3c063f2a9f3d3e
-  data.tar.gz: 6c82413ce53a9100fc97f9a3849c6231ebee4945fd26a3e3a1150f8c3abcca915032d35f4373b83217fa786600181097c003d1d071aab9de00612baf4c4eaa99
+  metadata.gz: ee43326933ac019b0bae631631ba79a7b1e03d1e9669361ef7722aa5a43b7bf2a2f49ccf8b098ab23539392fd09b83224c3cb9d340b80483179fabb45d62ee30
+  data.tar.gz: 9733820cc4e81b22cca51dbf89a02aa87e96cbbc1add753b2799878b5b50b549f2a27886dcfae387ad4cc158ce4bd651354f8bbd2514460ac07a60560ad5c455

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 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
+- Fixed bad recommendations and scores with `user_recs` and explicit feedback
+- Fixed `item_ids` option for `user_recs`
+
+## 0.2.2 (n/a)
+
+- Not available (released by previous gem owner)
+
+## 0.2.1 (2020-10-28)
+
+- Fixed issue with `user_recs` returning rated items
+
 ## 0.2.0 (2020-07-31)
 
 - Changed score to always be between -1 and 1 for `item_recs` and `similar_users` (cosine similarity - this makes it easier to understand and consistent with `optimize_item_recs` and `optimize_similar_users`)

data/LICENSE.txt

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

data/README.md

@@ -1,12 +1,12 @@
 # Disco
 
-:fire: Collaborative filtering for Ruby
+:fire: Recommendations for Ruby and Rails using collaborative filtering
 
 - Supports user-based and item-based recommendations
 - Works with explicit and implicit feedback
 - Uses high-performance matrix factorization
 
-[![Build Status](https://travis-ci.org/ankane/disco.svg?branch=master)](https://travis-ci.org/ankane/disco)
+[![Build Status](https://github.com/ankane/disco/workflows/build/badge.svg?branch=master)](https://github.com/ankane/disco/actions)
 
 ## Installation
 
@@ -44,15 +44,15 @@ recommender.fit([
 ])
 ```
 
-> Use `value` instead of rating for implicit feedback
+> 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)
@@ -64,10 +64,10 @@ Use the `count` option to specify the number of recommendations (default is 5)
 recommender.user_recs(user_id, count: 3)
 ```
 
-Get predicted ratings for specific items
+Get predicted ratings for specific users and items
 
 ```ruby
-recommender.user_recs(user_id, item_ids: [1, 2, 3])
+recommender.predict([{user_id: 1, item_id: 2}, {user_id: 2, item_id: 4}])
 ```
 
 Get similar users
@@ -101,7 +101,8 @@ recommender.item_recs("Star Wars (1977)")
 ```ruby
 views = Ahoy::Event.
   where(name: "Viewed post").
-  group(:user_id, "properties->>'post_id'"). # postgres syntax
+  group(:user_id).
+  group("properties->>'post_id'"). # postgres syntax
   count
 
 data =
@@ -200,6 +201,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)
+
 ## Algorithms
 
 Disco uses high-performance matrix factorization.
@@ -236,6 +239,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
@@ -256,23 +269,29 @@ 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 the `user_recs` method with:
+
+```ruby
+model.optimize_user_recs
 ```
 
-Speed up item-based recommendations with:
+Speed up the `item_recs` method with:
 
 ```ruby
 model.optimize_item_recs
 ```
 
-Speed up similar users with:
+Speed up the `similar_users` method with:
 
 ```ruby
 model.optimize_similar_users
@@ -282,19 +301,33 @@ This should be called after fitting or loading the model.
 
 ## 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:
@@ -315,3 +348,12 @@ Everyone is encouraged to help improve this project. Here are a few ways you can
 - Fix bugs and [submit pull requests](https://github.com/ankane/disco/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/disco.git
+cd disco
+bundle install
+bundle exec rake test
+```

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,39 +1,44 @@
 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] }
 
+      # 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
@@ -41,6 +46,25 @@ module Disco
       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] += (v[value_key] || 1)
+        end
+      end
+
       eval_set = nil
       if validation_set
         eval_set = []
@@ -67,135 +91,258 @@ 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
+    def predict(data)
+      data = to_dataset(data)
+
+      u = data.map { |v| @user_map[v[:user_id]] }
+      i = data.map { |v| @item_map[v[:item_id]] }
+
+      new_index = data.each_index.select { |index| u[index].nil? || i[index].nil? }
+      new_index.each do |j|
+        u[j] = 0
+        i[j] = 0
+      end
+
+      predictions = @user_factors[u, true].inner(@item_factors[i, true])
+      predictions.inplace.clip(@min_rating, @max_rating) if @min_rating
+      predictions[new_index] = @global_mean
+      predictions.to_a
     end
 
     def user_recs(user_id, count: 5, item_ids: nil)
+      check_fit
       u = @user_map[user_id]
 
       if u
-        predictions = @global_mean + @item_factors.dot(@user_factors[u, true])
-        predictions.inplace.clip(@min_rating, @max_rating) if @min_rating
-
-        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.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.each do |i|
-            predictions.delete_at(i)
-          end
+          predictions = @item_factors.inner(@user_factors[u, true])
+          # TODO make sure reverse isn't hurting performance
+          indexes = predictions.sort_index.reverse
+          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
+        predictions.inplace.clip(@min_rating, @max_rating) if @min_rating
+
+        keys = @item_map.keys
+        result = []
+        ids.each_with_index do |item_id, i|
+          next if rated[item_id]
+
+          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
-      @item_index = create_index(@item_factors)
+    def similar_items(item_id, count: 5)
+      check_fit
+      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
-      @user_index = create_index(@user_factors)
+    def similar_users(user_id, count: 5)
+      check_fit
+      similar(user_id, @user_map, normalized_user_factors, count, @similar_users_index)
     end
 
-    def similar_items(item_id, count: 5)
-      similar(item_id, @item_map, @item_factors, item_norms, count, @item_index)
+    def top_items(count: 5)
+      check_fit
+      raise "top_items not computed" unless @top_items
+
+      if @implicit
+        scores = @item_count
+      else
+        require "wilson_score"
+
+        range = @min_rating..@max_rating
+        scores = @item_sum.zip(@item_count).map { |s, c| WilsonScore.rating_lower_bound(s / c, c, range) }
+      end
+
+      scores = scores.map.with_index.sort_by { |s, _| -s }
+      scores = scores.first(count) if count
+      item_ids = item_ids()
+      scores.map do |s, i|
+        {item_id: item_ids[i], score: s}
+      end
     end
-    alias_method :item_recs, :similar_items
 
-    def similar_users(user_id, count: 5)
-      similar(user_id, @user_map, @user_factors, user_norms, count, @user_index)
+    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
+      @user_recs_index = create_index(item_factors, library: "faiss")
+    end
+
+    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
 
     private
 
-    def create_index(factors)
-      require "ngt"
+    # 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
+        # https://github.com/facebookresearch/faiss/wiki/Faiss-indexes
+        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"
 
-      index = Ngt::Index.new(factors.shape[1], distance_type: "Cosine")
-      index.batch_insert(factors)
-      index
+        # 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
+
+        # TODO use user_id for similar_users in 0.3.0
+        key = :item_id
 
-      raise ArgumentError, "Missing user_id" if user_ids.any?(&:nil?)
-      raise ArgumentError, "Missing item_id" if item_ids.any?(&:nil?)
+        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
 
-      @user_map = user_ids.zip(user_ids.size.times).to_h
-      @item_map = item_ids.zip(item_ids.size.times).to_h
+          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
 
@@ -203,6 +350,10 @@ module Disco
       raise ArgumentError, "No training data" if train_set.empty?
     end
 
+    def check_fit
+      raise "Not fit" unless defined?(@implicit)
+    end
+
     def to_dataset(dataset)
       if defined?(Rover::DataFrame) && dataset.is_a?(Rover::DataFrame)
         # convert keys to symbols
@@ -230,7 +381,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
@@ -238,6 +392,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
 
@@ -249,11 +408,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.0"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disco
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.6
 platform: ruby
 authors:
 - Andrew Kane
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-31 00:00:00.000000000 Z
+date: 2021-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libmf
@@ -38,120 +38,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: daru
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rover-df
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: ngt
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.3.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.3.0
-description: 
-email: andrew@chartkick.com
+description:
+email: andrew@ankane.org
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -163,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
@@ -172,7 +61,7 @@ homepage: https://github.com/ankane/disco
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -187,8 +76,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
-summary: Collaborative filtering for Ruby
+summary: Recommendations for Ruby and Rails using collaborative filtering
 test_files: []