cmfrec 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c19c6069b22f666ab280851cdfcaab346c1c08599be2e97043bdc41da552b6f
-  data.tar.gz: 6f0ffb63861b47568119e7014ff1c9d1a71fcf5852c6b1df2a8ca9b16bd239d3
+  metadata.gz: 34e8dc08914cbc418470cd7eb3adf3d33013b786319f4510212c80bf3629f3ca
+  data.tar.gz: c1b91a1f77b4b51a5ca4491376f8a02230ea54873f8c1b2b06f4761d6ddd0686
 SHA512:
-  metadata.gz: 15104fb705c8bf1ffe3959846ddacde37a8845ee667c6ab334df6b1aacc7da42af894e2f94f1bfc35739943f8293b3f70e22358f7fc030e814c5dadbce4bb75e
-  data.tar.gz: 8d7806b1500de927ecca3705ade074a2dc197a5e413a3a0e755f3d952aa8916b10a87f635e7958726e315a05376c216c6c5a79b6d33f4a61d723e4bbfbbcd382
+  metadata.gz: a3c57734379199196a4e3f51d9ec02b19ef1abac13d57a10ca3c20e9b76c9ee5db4b17d790330d41a9576c2ba28a9eeccafeb5760b54cfdf80a7431368895068
+  data.tar.gz: 5a24a77a6665854abb38916a22e8141a6cae637a51f98e3df3762566f2e73cb60b9bd9a25303df0411ea53dec3211bf7534711dc55c510311620341cbe4e4ac3

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 0.1.6 (2021-08-12)
+
+- Added `user_ids` and `item_ids` methods
+- Added `user_id` argument to `user_factors`
+- Added `item_id` argument to `item_factors`
+- Added `user_id` argument to `user_bias`
+- Added `item_id` argument to `item_bias`
+- Added `item_ids` argument to `new_user_recs`
+- Fixed order for `user_recs`
+
+## 0.1.5 (2021-08-10)
+
+- Fixed issue with `user_recs` and `new_user_recs` returning rated items
+- Fixed error with `new_user_recs`
+
+## 0.1.4 (2021-02-04)
+
+- Added support for saving and loading recommenders
+- Added `similar_users` and `similar_items`
+- Improved ARM detection
+
+## 0.1.3 (2020-12-28)
+
+- Added ARM shared library for Mac
+
 ## 0.1.2 (2020-12-09)
 
 - Added `load_movielens` method

data/LICENSE.txt

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) 2020 David Cortes
-Copyright (c) 2020 Andrew Kane
+Copyright (c) 2020-2021 Andrew Kane
 
 All rights reserved.
 

data/README.md

@@ -107,6 +107,26 @@ Get recommendations with only side information
 recommender.new_user_recs([], user_info: {cats: 0, dogs: 2})
 ```
 
+## Similarity
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'ngt'
+```
+
+Get similar users
+
+```ruby
+recommender.similar_users(user_id)
+```
+
+Get similar items - “users who liked this item also liked”
+
+```ruby
+recommender.similar_items(item_id)
+```
+
 ## Examples
 
 ### MovieLens
@@ -125,6 +145,35 @@ recommender.fit(ratings.first(80000), user_info: user_info, item_info: item_info
 recommender.predict(ratings.last(20000))
 ```
 
+### 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).
+  group("properties->>'post_id'"). # postgres syntax
+  count
+
+data =
+  views.map do |(user_id, post_id), count|
+    {
+      user_id: user_id,
+      item_id: post_id,
+      value: count
+    }
+  end
+```
+
+Create a recommender and get recommended posts for a user
+
+```ruby
+recommender = Cmfrec::Recommender.new
+recommender.fit(data)
+recommender.user_recs(current_user.id)
+```
+
 ## Options
 
 Specify the number of factors and epochs
@@ -163,8 +212,33 @@ Or a Rover data frame
 Rover.read_csv("ratings.csv")
 ```
 
+## Storing Recommenders
+
+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)
+```
+
 ## Reference
 
+Get ids
+
+```ruby
+recommender.user_ids
+recommender.item_ids
+```
+
 Get the global mean
 
 ```ruby

data/lib/cmfrec.rb

@@ -19,7 +19,11 @@ module Cmfrec
     if Gem.win_platform?
       "cmfrec.dll"
     elsif RbConfig::CONFIG["host_os"] =~ /darwin/i
-      "libcmfrec.dylib"
+      if RbConfig::CONFIG["host_cpu"] =~ /arm/i
+        "libcmfrec.arm64.dylib"
+      else
+        "libcmfrec.dylib"
+      end
     else
       "libcmfrec.so"
     end

data/lib/cmfrec/recommender.rb

@@ -11,29 +11,193 @@ module Cmfrec
         item_bias: item_bias,
         add_implicit_features: add_implicit_features
       )
+
+      @fit = false
+      @user_map = {}
+      @item_map = {}
+      @user_info_map = {}
+      @item_info_map = {}
     end
 
     def fit(train_set, user_info: nil, item_info: nil)
+      reset
+      partial_fit(train_set, user_info: user_info, item_info: item_info)
+    end
+
+    def predict(data)
+      check_fit
+
+      data = to_dataset(data)
+
+      u = data.map { |v| @user_map[v[:user_id]] || @user_map.size }
+      i = data.map { |v| @item_map[v[:item_id]] || @item_map.size }
+
+      row = int_ptr(u)
+      col = int_ptr(i)
+      n_predict = data.size
+      predicted = Fiddle::Pointer.malloc(n_predict * Fiddle::SIZEOF_DOUBLE)
+
+      if @implicit
+        check_status FFI.predict_X_old_collective_implicit(
+          row, col, predicted, n_predict,
+          @a, @b,
+          @k, @k_user, @k_item, @k_main,
+          @m, @n,
+          @nthreads
+        )
+      else
+        check_status FFI.predict_X_old_collective_explicit(
+          row, col, predicted, n_predict,
+          @a, @bias_a,
+          @b, @bias_b,
+          @global_mean,
+          @k, @k_user, @k_item, @k_main,
+          @m, @n,
+          @nthreads
+        )
+      end
+
+      predictions = real_array(predicted)
+      predictions.map! { |v| v.nan? ? @global_mean : v } if @implicit
+      predictions
+    end
+
+    def user_recs(user_id, count: 5, item_ids: nil)
+      check_fit
+      user = @user_map[user_id]
+
+      if user
+        a_vec = @a[user * @k * Fiddle::SIZEOF_DOUBLE, @k * Fiddle::SIZEOF_DOUBLE]
+        a_bias = @bias_a ? @bias_a[user * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE].unpack1("d") : 0
+        # @rated[user] will be nil for recommenders saved before 0.1.5
+        top_n(a_vec: a_vec, a_bias: a_bias, count: count, rated: (@rated[user] || {}).keys, item_ids: item_ids)
+      else
+        # no items if user is unknown
+        # TODO maybe most popular items
+        []
+      end
+    end
+
+    def new_user_recs(data, count: 5, user_info: nil, item_ids: nil)
+      check_fit
+
+      a_vec, a_bias, rated = factors_warm(data, user_info: user_info)
+      top_n(a_vec: a_vec, a_bias: a_bias, count: count, rated: rated, item_ids: item_ids)
+    end
+
+    def user_ids
+      @user_map.keys
+    end
+
+    def item_ids
+      @item_map.keys
+    end
+
+    def user_factors(user_id = nil)
+      read_factors(@a, [@m, @m_u].max, @k_user + @k + @k_main, user_id, @user_map)
+    end
+
+    def item_factors(item_id = nil)
+      read_factors(@b, [@n, @n_i].max, @k_item + @k + @k_main, item_id, @item_map)
+    end
+
+    def user_bias(user_id = nil)
+      read_bias(@bias_a, user_id, @user_map) if @bias_a
+    end
+
+    def item_bias(item_id = nil)
+      read_bias(@bias_b, item_id, @item_map) if @bias_b
+    end
+
+    def similar_items(item_id, count: 5)
+      check_fit
+      similar(item_id, @item_map, item_factors, count, item_index)
+    end
+    alias_method :item_recs, :similar_items
+
+    def similar_users(user_id, count: 5)
+      check_fit
+      similar(user_id, @user_map, user_factors, count, user_index)
+    end
+
+    private
+
+    def user_index
+      @user_index ||= create_index(user_factors)
+    end
+
+    def item_index
+      @item_index ||= create_index(item_factors)
+    end
+
+    def create_index(factors)
+      require "ngt"
+
+      index = Ngt::Index.new(@k, distance_type: "Cosine")
+      index.batch_insert(factors)
+      index
+    end
+
+    # TODO include bias
+    def similar(id, map, factors, count, index)
+      i = map[id]
+      if i
+        keys = map.keys
+        result = index.search(factors[i], 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]
+          }
+        end
+      else
+        []
+      end
+    end
+
+    def reset
+      @fit = false
+      @user_map.clear
+      @item_map.clear
+      @user_info_map.clear
+      @item_info_map.clear
+      @user_index = nil
+      @item_index = nil
+    end
+
+    # TODO resize pointers as needed and reset values for new memory
+    def partial_fit(train_set, user_info: nil, item_info: nil)
       train_set = to_dataset(train_set)
 
-      @implicit = !train_set.any? { |v| v[:rating] }
+      unless @fit
+        @implicit = !train_set.any? { |v| v[:rating] }
+      end
+
       unless @implicit
         ratings = train_set.map { |o| o[:rating] }
         check_ratings(ratings)
       end
 
       check_training_set(train_set)
-      create_maps(train_set)
+      update_maps(train_set)
 
       x_row = []
       x_col = []
       x_val = []
       value_key = @implicit ? :value : :rating
+      @rated = Hash.new { |hash, key| hash[key] = {} }
       train_set.each do |v|
-        x_row << @user_map[v[:user_id]]
-        x_col << @item_map[v[:item_id]]
+        u = @user_map[v[:user_id]]
+        i = @item_map[v[:item_id]]
+        @rated[u][i] = true
+
+        x_row << u
+        x_col << i
         x_val << (v[value_key] || 1)
       end
+      @rated.default = nil
 
       @m = @user_map.size
       @n = @item_map.size
@@ -52,16 +216,14 @@ module Cmfrec
       uu = nil
       ii = nil
 
-      @user_info_map = {}
+      # side info
       u_row, u_col, u_sp, nnz_u, @m_u, p_ = process_info(user_info, @user_map, @user_info_map, :user_id)
-
-      @item_info_map = {}
       i_row, i_col, i_sp, nnz_i, @n_i, q = process_info(item_info, @item_map, @item_info_map, :item_id)
 
       @precompute_for_predictions = false
 
       # initialize w/ normal distribution
-      reset_values = true
+      reset_values = !@fit
 
       @a = Fiddle::Pointer.malloc([@m, @m_u].max * (@k_user + @k + @k_main) * Fiddle::SIZEOF_DOUBLE)
       @b = Fiddle::Pointer.malloc([@n, @n_i].max * (@k_item + @k + @k_main) * Fiddle::SIZEOF_DOUBLE)
@@ -75,16 +237,7 @@ module Cmfrec
       i_colmeans = Fiddle::Pointer.malloc(q * Fiddle::SIZEOF_DOUBLE)
 
       if @implicit
-        @w_main_multiplier = 1.0
-        @alpha = 1.0
-        @adjust_weight = false # downweight?
-        @apply_log_transf = false
-
-        # different defaults
-        @lambda_ = 1e0
-        @w_user = 10
-        @w_item = 10
-        @finalize_chol = false
+        set_implicit_vars
 
         args = [
           @a, @b,
@@ -175,104 +328,13 @@ module Cmfrec
         @global_mean = real_array(glob_mean).first
       end
 
-      @u_colmeans = real_array(u_colmeans)
-      @i_colmeans = real_array(i_colmeans)
-      @u_colmeans_ptr = u_colmeans
-
-      self
-    end
-
-    def predict(data)
-      check_fit
-
-      data = to_dataset(data)
-
-      u = data.map { |v| @user_map[v[:user_id]] || @user_map.size }
-      i = data.map { |v| @item_map[v[:item_id]] || @item_map.size }
-
-      row = int_ptr(u)
-      col = int_ptr(i)
-      n_predict = data.size
-      predicted = Fiddle::Pointer.malloc(n_predict * Fiddle::SIZEOF_DOUBLE)
-
-      if @implicit
-        check_status FFI.predict_X_old_collective_implicit(
-          row, col, predicted, n_predict,
-          @a, @b,
-          @k, @k_user, @k_item, @k_main,
-          @m, @n,
-          @nthreads
-        )
-      else
-        check_status FFI.predict_X_old_collective_explicit(
-          row, col, predicted, n_predict,
-          @a, @bias_a,
-          @b, @bias_b,
-          @global_mean,
-          @k, @k_user, @k_item, @k_main,
-          @m, @n,
-          @nthreads
-        )
-      end
-
-      predictions = real_array(predicted)
-      predictions.map! { |v| v.nan? ? @global_mean : v } if @implicit
-      predictions
-    end
-
-    def user_recs(user_id, count: 5, item_ids: nil)
-      check_fit
-      user = @user_map[user_id]
-
-      if user
-        if item_ids
-          # remove missing ids
-          item_ids = item_ids.select { |v| @item_map[v] }
-
-          data = item_ids.map { |v| {user_id: user_id, item_id: v} }
-          scores = predict(data)
-
-          item_ids.zip(scores).map do |item_id, score|
-            {item_id: item_id, score: score}
-          end
-        else
-          a_vec = @a[user * @k * Fiddle::SIZEOF_DOUBLE, @k * Fiddle::SIZEOF_DOUBLE]
-          a_bias = @bias_a ? @bias_a[user * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE].unpack1("d") : 0
-          top_n(a_vec: a_vec, a_bias: a_bias, count: count)
-        end
-      else
-        # no items if user is unknown
-        # TODO maybe most popular items
-        []
-      end
-    end
-
-    # TODO add item_ids
-    def new_user_recs(data, count: 5, user_info: nil)
-      check_fit
-
-      a_vec, a_bias = factors_warm(data, user_info: user_info)
-      top_n(a_vec: a_vec, a_bias: a_bias, count: count)
-    end
-
-    def user_factors
-      read_factors(@a, [@m, @m_u].max, @k_user + @k + @k_main)
-    end
-
-    def item_factors
-      read_factors(@b, [@n, @n_i].max, @k_item + @k + @k_main)
-    end
+      @u_colmeans = u_colmeans
 
-    def user_bias
-      read_bias(@bias_a) if @bias_a
-    end
+      @fit = true
 
-    def item_bias
-      read_bias(@bias_b) if @bias_b
+      self
     end
 
-    private
-
     def set_params(
       k: 40, lambda_: 1e+1, method: "als", use_cg: true, user_bias: true,
       item_bias: true, add_implicit_features: false,
@@ -329,15 +391,14 @@ module Cmfrec
       @nthreads = nthreads
     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
-
-      raise ArgumentError, "Missing user_id" if user_ids.any?(&:nil?)
-      raise ArgumentError, "Missing item_id" if item_ids.any?(&:nil?)
+    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? }
 
-      @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)
@@ -354,7 +415,7 @@ module Cmfrec
     end
 
     def check_fit
-      raise "Not fit" unless defined?(@implicit)
+      raise "Not fit" unless @fit
     end
 
     def to_dataset(dataset)
@@ -376,26 +437,59 @@ module Cmfrec
       end
     end
 
-    def read_factors(ptr, d1, d2)
-      arr = []
-      offset = 0
+    def read_factors(ptr, d1, d2, id, map)
       width = d2 * Fiddle::SIZEOF_DOUBLE
-      d1.times do |i|
-        arr << ptr[offset, width].unpack("d*")
-        offset += width
+      if id
+        i = map[id]
+        ptr[i * width, width].unpack("d*") if i
+      else
+        arr = []
+        offset = 0
+        d1.times do |i|
+          arr << ptr[offset, width].unpack("d*")
+          offset += width
+        end
+        arr
       end
-      arr
     end
 
-    def read_bias(ptr)
-      real_array(ptr)
+    def read_bias(ptr, id, map)
+      if id
+        i = map[id]
+        ptr[i * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE].unpack1("d") if i
+      else
+        real_array(ptr)
+      end
     end
 
-    def top_n(a_vec:, a_bias:, count:)
-      include_ix = nil
-      n_include = 0
-      exclude_ix = nil
-      n_exclude = 0
+    def top_n(a_vec:, a_bias:, count:, rated: nil, item_ids: nil)
+      if item_ids
+        # remove missing ids
+        item_ids = item_ids.map { |v| @item_map[v] }.compact
+        return [] if item_ids.empty?
+
+        include_ix = int_ptr(item_ids)
+        n_include = item_ids.size
+
+        # TODO uncomment in 0.2.0
+        count = n_include # if n_include < count
+      else
+        include_ix = nil
+        n_include = 0
+      end
+
+      if rated && !item_ids
+        # assumes rated is unique and all items are known
+        # calling code is responsible for this
+        exclude_ix = int_ptr(rated)
+        n_exclude = rated.size
+        remaining = @item_map.size - n_exclude
+        return [] if remaining == 0
+        count = remaining if remaining < count
+      else
+        exclude_ix = nil
+        n_exclude = 0
+      end
 
       outp_ix = Fiddle::Pointer.malloc(count * Fiddle::SIZEOF_INT)
       outp_score = Fiddle::Pointer.malloc(count * Fiddle::SIZEOF_DOUBLE)
@@ -425,6 +519,16 @@ module Cmfrec
       data = to_dataset(data)
       user_info = to_dataset(user_info) if user_info
 
+      # remove unknown items
+      data, unknown_data = data.partition { |d| @item_map[d[:item_id]] }
+
+      if unknown_data.any?
+        # TODO warn for unknown items?
+        # warn "[cmfrec] Unknown items: #{unknown_data.map { |d| d[:item_id] }.join(", ")}"
+      end
+
+      item_ids = data.map { |d| @item_map[d[:item_id]] }
+
       nnz = data.size
       a_vec = Fiddle::Pointer.malloc((@k_user + @k + @k_main) * Fiddle::SIZEOF_DOUBLE)
       bias_a = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE)
@@ -465,7 +569,7 @@ module Cmfrec
           check_ratings(ratings)
         end
         xa = real_ptr(ratings)
-        x_col = int_ptr(data.map { |d| d[:item_id] })
+        x_col = int_ptr(item_ids)
       else
         xa = nil
         x_col = nil
@@ -479,7 +583,7 @@ module Cmfrec
           u_vec_sp, u_vec_x_col, nnz_u_vec,
           @na_as_zero_user,
           @nonneg,
-          @u_colmeans_ptr,
+          @u_colmeans,
           @b, @n, @c,
           xa, x_col, nnz,
           @k, @k_user, @k_item, @k_main,
@@ -505,7 +609,7 @@ module Cmfrec
           @na_as_zero_user, @na_as_zero,
           @nonneg,
           @c, cb,
-          @global_mean, @bias_b, @u_colmeans_ptr,
+          @global_mean, @bias_b, @u_colmeans,
           xa, x_col, nnz, xa_dense,
           @n, weight, @b, @bi,
           @add_implicit_features,
@@ -528,7 +632,7 @@ module Cmfrec
         check_status FFI.factors_collective_explicit_single(*fiddle_args(args))
       end
 
-      [a_vec, real_array(bias_a).first]
+      [a_vec, real_array(bias_a).first, item_ids.uniq]
     end
 
     # convert boolean to int
@@ -585,5 +689,126 @@ module Cmfrec
     def real_array(ptr)
       ptr.to_s(ptr.size).unpack("d*")
     end
+
+    def set_implicit_vars
+      @w_main_multiplier = 1.0
+      @alpha = 1.0
+      @adjust_weight = false # downweight?
+      @apply_log_transf = false
+
+      # different defaults
+      @lambda_ = 1e0
+      @w_user = 10
+      @w_item = 10
+      @finalize_chol = false
+    end
+
+    def dump_ptr(ptr)
+      ptr.to_s(ptr.size) if ptr
+    end
+
+    def load_ptr(str)
+      Fiddle::Pointer[str] if str
+    end
+
+    def marshal_dump
+      obj = {
+        implicit: @implicit
+      }
+
+      # options
+      obj[:factors] = @k
+      obj[:epochs] = @niter
+      obj[:verbose] = @verbose
+
+      # factors
+      obj[:user_map] = @user_map
+      obj[:item_map] = @item_map
+      obj[:rated] = @rated
+      obj[:user_factors] = dump_ptr(@a)
+      obj[:item_factors] = dump_ptr(@b)
+
+      # bias
+      obj[:user_bias] = dump_ptr(@bias_a)
+      obj[:item_bias] = dump_ptr(@bias_b)
+
+      # mean
+      obj[:global_mean] = @global_mean
+
+      # side info
+      obj[:user_info_map] = @user_info_map
+      obj[:item_info_map] = @item_info_map
+      obj[:user_info_factors] = dump_ptr(@c)
+      obj[:item_info_factors] = dump_ptr(@d)
+
+      # implicit features
+      obj[:add_implicit_features] = @add_implicit_features
+      obj[:user_factors_implicit] = dump_ptr(@ai)
+      obj[:item_factors_implicit] = dump_ptr(@bi)
+
+      unless @implicit
+        obj[:min_rating] = @min_rating
+        obj[:max_rating] = @max_rating
+      end
+
+      obj[:user_means] = dump_ptr(@u_colmeans)
+
+      obj
+    end
+
+    def marshal_load(obj)
+      @implicit = obj[:implicit]
+
+      # options
+      set_params(
+        k: obj[:factors],
+        niter: obj[:epochs],
+        verbose: obj[:verbose],
+        user_bias: !obj[:user_bias].nil?,
+        item_bias: !obj[:item_bias].nil?,
+        add_implicit_features: obj[:add_implicit_features]
+      )
+
+      # factors
+      @user_map = obj[:user_map]
+      @item_map = obj[:item_map]
+      @rated = obj[:rated] || {}
+      @a = load_ptr(obj[:user_factors])
+      @b = load_ptr(obj[:item_factors])
+
+      # bias
+      @bias_a = load_ptr(obj[:user_bias])
+      @bias_b = load_ptr(obj[:item_bias])
+
+      # mean
+      @global_mean = obj[:global_mean]
+
+      # side info
+      @user_info_map = obj[:user_info_map]
+      @item_info_map = obj[:item_info_map]
+      @c = load_ptr(obj[:user_info_factors])
+      @d = load_ptr(obj[:item_info_factors])
+
+      # implicit features
+      @add_implicit_features = obj[:add_implicit_features]
+      @ai = load_ptr(obj[:user_factors_implicit])
+      @bi = load_ptr(obj[:item_factors_implicit])
+
+      unless @implicit
+        @min_rating = obj[:min_rating]
+        @max_rating = obj[:max_rating]
+      end
+
+      @u_colmeans = load_ptr(obj[:user_means])
+
+      @m = @user_map.size
+      @n = @item_map.size
+      @m_u = @user_info_map.size
+      @n_i = @item_info_map.size
+
+      set_implicit_vars if @implicit
+
+      @fit = @m > 0
+    end
   end
 end

data/lib/cmfrec/version.rb

@@ -1,3 +1,3 @@
 module Cmfrec
-  VERSION = "0.1.2"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: cmfrec
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.6
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-10 00:00:00.000000000 Z
+date: 2021-08-12 00:00:00.000000000 Z
 dependencies: []
 description:
-email: andrew@chartkick.com
+email: andrew@ankane.org
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -25,6 +25,7 @@ files:
 - lib/cmfrec/recommender.rb
 - lib/cmfrec/version.rb
 - vendor/LICENSE.txt
+- vendor/libcmfrec.arm64.dylib
 - vendor/libcmfrec.dylib
 - vendor/libcmfrec.so
 homepage: https://github.com/ankane/cmfrec
@@ -46,7 +47,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 using collective matrix factorization