disco 0.1.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33961b51cd8461f821c4622f5983b2ac6138cc3b70c9be8ef1d3a6e82c37ab9e
-  data.tar.gz: f4e8cdfa4efb354878c459b57b522a81cd3f0c81e4297c53f9dc88517b312ac8
+  metadata.gz: 8fbecb858b316ed39a9cb726263e182561cba6df498e6253d88c79ebec5cab05
+  data.tar.gz: 42eb38a6e4e0b3fc5a9452deae5a48676ae9a53e78eeb6197718a0c94bd02b6b
 SHA512:
-  metadata.gz: 2f4c207486e858a23480e52b4b9a479fd23b26f0259ef12e39b964d9d7f4cc0067f162207d88119f76414269d65e3ee3d7c675c46f5f143c5b016eacab6e888c
-  data.tar.gz: 2734c1dcc87c423566dd2f842ef7fdd1b7e3cbaa1ecac61dbfafdbc1769b43edca81d28ce60712008eee9d381d64c9e2dea71b210c1a10fecaef75696ee2fd05
+  metadata.gz: d0250346d75fba75064a29578f6bfd39f09ecf712ba2e505b97a4952b5ff8b31af307eb1b912e9b25cc3dc28dee0d096bea44b47bb2ef268859bb4171f0ef8b2
+  data.tar.gz: 7b341328c12885efd0ffece4201036bb9457caee80a48a99ba110af9a81bcf832bbc1e8f8f5f14e7fddffef2dd3f4643837e0d569c997ab0c2d9ae85e12422f7

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## 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`)
+
 ## 0.1.3 (2020-06-28)
 
 - Added support for Rover

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2019 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
 
@@ -46,13 +46,13 @@ recommender.fit([
 
 > 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,14 +101,15 @@ 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 =
   views.map do |(user_id, post_id), count|
     {
       user_id: user_id,
-      post_id: post_id,
+      item_id: post_id,
       value: count
     }
   end
@@ -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) 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 [master]
 
-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/data.rb

@@ -36,8 +36,7 @@ module Disco
 
       return dest if File.exist?(dest)
 
-      temp_dir ||= File.dirname(Tempfile.new("disco"))
-      temp_path = "#{temp_dir}/#{Time.now.to_f}" # TODO better name
+      temp_path = "#{Dir.tmpdir}/disco-#{Time.now.to_f}" # TODO better name
 
       digest = Digest::SHA2.new
 

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,32 +1,33 @@
 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
 
-      @implicit = !train_set.any? { |v| v[:rating] }
+      check_training_set(train_set)
 
+      @implicit = !train_set.any? { |v| v[:rating] }
       unless @implicit
-        ratings = train_set.map { |o| o[:rating] }
-        check_ratings(ratings)
-        @min_rating = ratings.min
-        @max_rating = ratings.max
+        check_ratings(train_set)
+        @min_rating, @max_rating = train_set.minmax_by { |o| o[:rating] }.map { |o| o[:rating] }
 
         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)
+      update_maps(train_set)
 
       @rated = Hash.new { |hash, key| hash[key] = {} }
       input = []
@@ -41,6 +42,16 @@ module Disco
       end
       @rated.default = nil
 
+      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,67 +78,188 @@ module Disco
       @user_factors = model.p_factors(format: :numo)
       @item_factors = model.q_factors(format: :numo)
 
-      @user_index = nil
-      @item_index = 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, item_norms, 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, user_norms, 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(item_norms, library: library)
+    end
+    alias_method :optimize_item_recs, :optimize_similar_items
+
+    def optimize_similar_users(library: nil)
+      check_fit
+      @similar_users_index = create_index(user_norms, library: library)
     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 with factors instead of norms
+        # 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
@@ -139,63 +271,61 @@ module Disco
     end
 
     def norms(factors)
-      norms = Numo::DFloat::Math.sqrt((factors * factors).sum(axis: 1))
+      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
-          # could alternatively do cosine distance = 1 - cosine similarity
-          # 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
+
+        keys = map.keys
+
+        # TODO use user_id for similar_users in 0.3.0
+        key = :item_id
+
+        (1...ids.size).map do |i|
+          {key => keys[ids[i]], score: predictions[i]}
         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
+    def update_maps(train_set)
+      raise ArgumentError, "Missing user_id" if train_set.any? { |v| v[:user_id].nil? }
+      raise ArgumentError, "Missing item_id" if train_set.any? { |v| v[:item_id].nil? }
 
-      raise ArgumentError, "Missing user_id" if user_ids.any?(&:nil?)
-      raise ArgumentError, "Missing item_id" if item_ids.any?(&:nil?)
-
-      @user_map = user_ids.zip(user_ids.size.times).to_h
-      @item_map = item_ids.zip(item_ids.size.times).to_h
+      train_set.each do |v|
+        @user_map[v[:user_id]] ||= @user_map.size
+        @item_map[v[:item_id]] ||= @item_map.size
+      end
     end
 
     def check_ratings(ratings)
-      unless ratings.all? { |r| !r.nil? }
+      unless ratings.all? { |r| !r[:rating].nil? }
         raise ArgumentError, "Missing ratings"
       end
-      unless ratings.all? { |r| r.is_a?(Numeric) }
+      unless ratings.all? { |r| r[:rating].is_a?(Numeric) }
         raise ArgumentError, "Ratings must be numeric"
       end
     end
@@ -204,6 +334,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
@@ -239,6 +373,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
 
@@ -255,6 +394,12 @@ module Disco
         @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.1.3"
+  VERSION = "0.2.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disco
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Andrew Kane
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2021-02-20 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.2.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.3
-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: []