disco 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f0494a12f2efe7d077d989960b4f40bae39e9d433b8c38d45be367f79ad1a3e
+  data.tar.gz: d5ef0e761f5cc3a409e0b7c3d8cdc14a33d5c03ca4eca7b476159c82954ad163
+SHA512:
+  metadata.gz: 0a4995986ac209da39ff9f7c449225f1fc560364936f6df76647e33500f8f07749dc857f2a334b7bb59dadd941403feeee4f43f51647a7df799051a095f0cb3b
+  data.tar.gz: e1bef5d6f9d3272cbca8a6fc56d7d14bcc2bc2b269ddda7931a256f6a4c019419b2e590e06841e5a09914b9523a5b4c09c9ff8bfd817b3d3bd2e99ecf3368752

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019 Andrew Kane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,282 @@
+# Disco
+
+:fire: Collaborative filtering for Ruby
+
+- Supports user-based and item-based recommendations
+- Works with explicit and implicit feedback
+- Uses matrix factorization
+
+[![Build Status](https://travis-ci.org/ankane/disco.svg?branch=master)](https://travis-ci.org/ankane/disco)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'disco'
+```
+
+## Getting Started
+
+Create a recommender
+
+```ruby
+recommender = Disco::Recommender.new
+```
+
+If users rate items directly, this is known as explicit feedback. Fit the recommender with:
+
+```ruby
+recommender.fit([
+  {user_id: 1, item_id: 1, rating: 5},
+  {user_id: 2, item_id: 1, rating: 3}
+])
+```
+
+> 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:
+
+```ruby
+recommender.fit([
+  {user_id: 1, item_id: 1, value: 1},
+  {user_id: 2, item_id: 1, value: 1}
+])
+```
+
+> Use `value` instead of rating for implicit feedback
+
+Get user-based (user-item) 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”
+
+```ruby
+recommender.item_recs(item_id)
+```
+
+Use the `count` option to specify the number of recommendations (default is 5)
+
+```ruby
+recommender.user_recs(user_id, count: 3)
+```
+
+Get predicted ratings for specific items
+
+```ruby
+recommender.user_recs(user_id, item_ids: [1, 2, 3])
+```
+
+Get similar users
+
+```ruby
+recommender.similar_users(user_id)
+```
+
+## Examples
+
+### MovieLens
+
+Load the data
+
+```ruby
+data = Disco.load_movielens
+```
+
+Create a recommender and get similar movies
+
+```ruby
+recommender = Disco::Recommender.new(factors: 20)
+recommender.fit(data)
+recommender.item_recs("Star Wars (1977)")
+```
+
+### Ahoy
+
+[Ahoy](https://github.com/ankane/ahoy) is a great source for implicit feedback
+
+```ruby
+views = Ahoy::Event.
+  where(name: "Viewed post").
+  group(:user_id, "properties->>'post_id'") # postgres syntax
+  count
+
+data =
+  views.map do |(user_id, post_id), count|
+    {
+      user_id: user_id,
+      post_id: post_id,
+      value: count
+    }
+  end
+```
+
+Create a recommender and get recommended posts for a user
+
+```ruby
+recommender = Disco::Recommender.new
+recommender.fit(data)
+recommender.user_recs(current_user.id)
+```
+
+## Storing Recommendations
+
+Disco makes it easy to store recommendations in Rails.
+
+```sh
+rails generate disco:recommendation
+rails db:migrate
+```
+
+For user-based recommendations, use:
+
+```ruby
+class User < ApplicationRecord
+  has_recommended :products
+end
+```
+
+> Change `:products` to match the model you’re recommending
+
+Save recommendations
+
+```ruby
+User.find_each do |user|
+  recs = recommender.user_recs(user.id)
+  user.update_recommended_products(recs)
+end
+```
+
+Get recommendations
+
+```ruby
+user.recommended_products
+```
+
+For item-based recommendations, use:
+
+```ruby
+class Product < ApplicationRecord
+  has_recommended :products
+end
+```
+
+Specify multiple types of recommendations for a model with:
+
+```ruby
+class User < ApplicationRecord
+  has_recommended :products
+  has_recommended :products_v2, class_name: "Product"
+end
+```
+
+And use the appropriate methods:
+
+```ruby
+user.update_recommended_products_v2(recs)
+user.recommended_products_v2
+```
+
+For Rails < 6, speed up inserts by adding [activerecord-import](https://github.com/zdennis/activerecord-import) to your app.
+
+## Storing Recommenders
+
+If you’d prefer to perform recommendations on-the-fly, store the recommender
+
+```ruby
+bin = Marshal.dump(recommender)
+File.binwrite("recommender.bin", bin)
+```
+
+> You can save it to a file, database, or any other storage system
+
+Load a recommender
+
+```ruby
+bin = File.binread("recommender.bin")
+recommender = Marshal.load(bin)
+```
+
+## Algorithms
+
+Disco uses matrix factorization.
+
+- For explicit feedback, it uses [stochastic gradient descent](https://www.csie.ntu.edu.tw/~cjlin/papers/libmf/libmf_journal.pdf)
+- For implicit feedback, it uses [coordinate descent](https://www.csie.ntu.edu.tw/~cjlin/papers/one-class-mf/biased-mf-sdm-with-supp.pdf)
+
+Specify the number of factors and epochs
+
+```ruby
+Disco::Recommender.new(factors: 8, epochs: 20)
+```
+
+If recommendations look off, trying changing `factors`. The default is 8, but 3 could be good for some applications and 300 good for others.
+
+## Validation
+
+Pass a validation set with:
+
+```ruby
+recommender.fit(data, validation_set: validation_set)
+```
+
+## Cold Start
+
+Collaborative filtering suffers from the [cold start problem](https://www.yuspify.com/blog/cold-start-problem-recommender-systems/). It’s unable to make good recommendations without data on a user or item, which is problematic for new users and items.
+
+```ruby
+recommender.user_recs(new_user_id) # returns empty array
+```
+
+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).
+
+## Daru
+
+Disco works with Daru data frames
+
+```ruby
+data = Daru::DataFrame.from_csv("ratings.csv")
+recommender.fit(data)
+```
+
+## Reference
+
+Get the global mean
+
+```ruby
+recommender.global_mean
+```
+
+Get the factors
+
+```ruby
+recommender.user_factors
+recommender.item_factors
+```
+
+## Credits
+
+Thanks to:
+
+- [LIBMF](https://github.com/cjlin1/libmf) for providing high performance matrix factorization
+- [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
+
+## History
+
+View the [changelog](https://github.com/ankane/disco/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/disco/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/disco/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features

data/lib/disco.rb

@@ -0,0 +1,29 @@
+# dependencies
+require "libmf"
+require "numo/narray"
+
+# stdlib
+require "csv"
+require "fileutils"
+require "net/http"
+
+# modules
+require "disco/data"
+require "disco/recommender"
+require "disco/version"
+
+# integrations
+require "disco/engine" if defined?(Rails)
+
+module Disco
+  class Error < StandardError; end
+
+  extend Data
+end
+
+if defined?(ActiveSupport.on_load)
+  ActiveSupport.on_load(:active_record) do
+    require "disco/model"
+    extend Disco::Model
+  end
+end

data/lib/disco/data.rb

@@ -0,0 +1,75 @@
+module Disco
+  module Data
+    def load_movielens
+      item_path = download_file("ml-100k/u.item", "http://files.grouplens.org/datasets/movielens/ml-100k/u.item",
+        file_hash: "553841ebc7de3a0fd0d6b62a204ea30c1e651aacfb2814c7a6584ac52f2c5701")
+      data_path = download_file("ml-100k/u.data", "http://files.grouplens.org/datasets/movielens/ml-100k/u.data",
+        file_hash: "06416e597f82b7342361e41163890c81036900f418ad91315590814211dca490")
+
+      # convert u.item to utf-8
+      movies_str = File.read(item_path).encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "")
+
+      movies = {}
+      CSV.parse(movies_str, col_sep: "|") do |row|
+        movies[row[0]] = row[1]
+      end
+
+      data = []
+      CSV.foreach(data_path, col_sep: "\t") do |row|
+        data << {
+          user_id: row[0].to_i,
+          item_id: movies[row[1]],
+          rating: row[2].to_i
+        }
+      end
+
+      data
+    end
+
+    private
+
+    def download_file(fname, origin, file_hash:)
+      # TODO handle this better
+      raise "No HOME" unless ENV["HOME"]
+      dest = "#{ENV["HOME"]}/.disco/#{fname}"
+      FileUtils.mkdir_p(File.dirname(dest))
+
+      return dest if File.exist?(dest)
+
+      temp_dir ||= File.dirname(Tempfile.new("disco"))
+      temp_path = "#{temp_dir}/#{Time.now.to_f}" # TODO better name
+
+      digest = Digest::SHA2.new
+
+      uri = URI(origin)
+
+      # Net::HTTP automatically adds Accept-Encoding for compression
+      # of response bodies and automatically decompresses gzip
+      # and deflateresponses unless a Range header was sent.
+      # https://ruby-doc.org/stdlib-2.6.4/libdoc/net/http/rdoc/Net/HTTP.html
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        request = Net::HTTP::Get.new(uri)
+
+        puts "Downloading data from #{origin}"
+        File.open(temp_path, "wb") do |f|
+          http.request(request) do |response|
+            response.read_body do |chunk|
+              f.write(chunk)
+              digest.update(chunk)
+            end
+          end
+        end
+      end
+
+      if digest.hexdigest != file_hash
+        raise Error, "Bad hash: #{digest.hexdigest}"
+      end
+
+      puts "Hash verified: #{file_hash}"
+
+      FileUtils.mv(temp_path, dest)
+
+      dest
+    end
+  end
+end

data/lib/disco/engine.rb

@@ -0,0 +1,4 @@
+module Disco
+  class Engine < Rails::Engine
+  end
+end

data/lib/disco/model.rb

@@ -0,0 +1,36 @@
+module Disco
+  module Model
+    def has_recommended(name, class_name: nil)
+      class_name ||= name.to_s.singularize.camelize
+
+      class_eval do
+        unless reflect_on_association(:recommendations)
+          has_many :recommendations, class_name: "Disco::Recommendation", as: :subject, dependent: :destroy
+        end
+
+        has_many :"recommended_#{name}", -> { where("disco_recommendations.context = ?", name).order("disco_recommendations.score DESC") }, through: :recommendations, source: :item, source_type: class_name
+
+        define_method("update_recommended_#{name}") do |items|
+          now = Time.now
+          items = items.map { |item| {subject_type: model_name.name, subject_id: id, item_type: class_name, item_id: item[:item_id], context: name, score: item[:score], created_at: now, updated_at: now} }
+
+          self.class.transaction do
+            recommendations.where(context: name).delete_all
+
+            if items.any?
+              if recommendations.respond_to?(:insert_all!)
+                # Rails 6
+                recommendations.insert_all!(items)
+              elsif recommendations.respond_to?(:bulk_import!)
+                # activerecord-import
+                recommendations.bulk_import!(items, validate: false)
+              else
+                recommendations.create!([items])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/disco/recommender.rb

@@ -0,0 +1,208 @@
+module Disco
+  class Recommender
+    attr_reader :global_mean, :item_factors, :user_factors
+
+    def initialize(factors: 8, epochs: 20, verbose: nil)
+      @factors = factors
+      @epochs = epochs
+      @verbose = verbose
+    end
+
+    def fit(train_set, validation_set: nil)
+      if defined?(Daru)
+        if train_set.is_a?(Daru::DataFrame)
+          train_set = train_set.to_a[0]
+        end
+        if validation_set.is_a?(Daru::DataFrame)
+          validation_set = validation_set.to_a[0]
+        end
+      end
+
+      @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
+
+        if validation_set
+          check_ratings(validation_set.map { |o| o[:rating] })
+        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]]
+        @rated[u][i] = true
+
+        # explicit will always have a value due to check_ratings
+        input << [u, i, v[value_key] || 1]
+      end
+      @rated.default = nil
+
+      eval_set = nil
+      if validation_set
+        eval_set = []
+        validation_set.each do |v|
+          u = @user_map[v[:user_id]]
+          i = @item_map[v[:item_id]]
+
+          # set to non-existent item
+          u ||= -1
+          i ||= -1
+
+          eval_set << [u, i, v[value_key] || 1]
+        end
+      end
+
+      loss = @implicit ? 12 : 0
+      verbose = @verbose
+      verbose = true if verbose.nil? && eval_set
+      model = Libmf::Model.new(loss: loss, factors: @factors, iterations: @epochs, quiet: !verbose)
+      model.fit(input, eval_set: eval_set)
+
+      @global_mean = model.bias
+
+      # TODO read from LIBMF directly to Numo for performance
+      @user_factors = Numo::DFloat.cast(model.p_factors)
+      @item_factors = Numo::DFloat.cast(model.q_factors)
+    end
+
+    def user_recs(user_id, count: 5, item_ids: nil)
+      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
+
+        if item_ids
+          idx = item_ids.map { |i| @item_map[i] }.compact
+          predictions.values_at(*idx)
+        else
+          @rated[u].keys.each do |i|
+            predictions.delete_at(i)
+          end
+        end
+
+        predictions.sort_by! { |pred| -pred[:score] } # already sorted by id
+        predictions = predictions.first(count) if count && !item_ids
+        predictions
+      else
+        # no items if user is unknown
+        # TODO maybe most popular items
+        []
+      end
+    end
+
+    def similar_items(item_id, count: 5)
+      similar(item_id, @item_map, @item_factors, item_norms, count)
+    end
+    alias_method :item_recs, :similar_items
+
+    def similar_users(user_id, count: 5)
+      similar(user_id, @user_map, @user_factors, user_norms, count)
+    end
+
+    private
+
+    def user_norms
+      @user_norms ||= norms(@user_factors)
+    end
+
+    def item_norms
+      @item_norms ||= norms(@item_factors)
+    end
+
+    def norms(factors)
+      norms = Numo::DFloat::Math.sqrt((factors * factors).sum(axis: 1))
+      norms[norms.eq(0)] = 1e-10 # no zeros
+      norms
+    end
+
+    def similar(id, map, factors, norms, count)
+      i = map[id]
+      if i
+        predictions = factors.dot(factors[i, true]) / norms
+
+        predictions =
+          map.keys.zip(predictions).map do |item_id, pred|
+            {item_id: item_id, score: pred}
+          end
+
+        predictions.delete_at(i)
+        predictions.sort_by! { |pred| -pred[:score] } # already sorted by id
+        predictions = predictions.first(count) if count
+        predictions
+      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
+
+      @user_map = user_ids.zip(user_ids.size.times).to_h
+      @item_map = item_ids.zip(item_ids.size.times).to_h
+    end
+
+    def check_ratings(ratings)
+      unless ratings.all? { |r| !r.nil? }
+        raise ArgumentError, "Missing ratings"
+      end
+      unless ratings.all? { |r| r.is_a?(Numeric) }
+        raise ArgumentError, "Ratings must be numeric"
+      end
+    end
+
+    def check_training_set(train_set)
+      raise ArgumentError, "No training data" if train_set.empty?
+    end
+
+    def marshal_dump
+      obj = {
+        implicit: @implicit,
+        user_map: @user_map,
+        item_map: @item_map,
+        rated: @rated,
+        global_mean: @global_mean,
+        user_factors: @user_factors,
+        item_factors: @item_factors
+      }
+
+      unless @implicit
+        obj[:min_rating] = @min_rating
+        obj[:max_rating] = @max_rating
+      end
+
+      obj
+    end
+
+    def marshal_load(obj)
+      @implicit = obj[:implicit]
+      @user_map = obj[:user_map]
+      @item_map = obj[:item_map]
+      @rated = obj[:rated]
+      @global_mean = obj[:global_mean]
+      @user_factors = obj[:user_factors]
+      @item_factors = obj[:item_factors]
+
+      unless @implicit
+        @min_rating = obj[:min_rating]
+        @max_rating = obj[:max_rating]
+      end
+    end
+  end
+end

data/lib/disco/version.rb

@@ -0,0 +1,3 @@
+module Disco
+  VERSION = "0.1.0"
+end

data/lib/generators/disco/recommendation_generator.rb

@@ -0,0 +1,18 @@
+require "rails/generators/active_record"
+
+module Disco
+  module Generators
+    class RecommendationGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      source_root File.join(__dir__, "templates")
+
+      def copy_migration
+        migration_template "migration.rb", "db/migrate/create_disco_recommendations.rb", migration_version: migration_version
+      end
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/disco/templates/migration.rb.tt

@@ -0,0 +1,11 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :disco_recommendations do |t|
+      t.references :subject, polymorphic: true
+      t.references :item, polymorphic: true
+      t.string :context
+      t.float :score
+      t.timestamps
+    end
+  end
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: disco
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: libmf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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'
+description: 
+email: andrew@chartkick.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/disco.rb
+- lib/disco/data.rb
+- lib/disco/engine.rb
+- lib/disco/model.rb
+- lib/disco/recommender.rb
+- lib/disco/version.rb
+- lib/generators/disco/recommendation_generator.rb
+- lib/generators/disco/templates/migration.rb.tt
+homepage: https://github.com/ankane/disco
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Collaborative filtering for Ruby
+test_files: []