recommengine 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c24a755e1e54a103c8f5fb7ac95b3d471c405c82
-  data.tar.gz: 33b6f29231a938e68da66a7989649c1288f00472
+  metadata.gz: 00c3b60d76e9a77e8ffe57a61f4a6d378638ac06
+  data.tar.gz: 0a8ca1c880611d2a5a3646b98c6e9e8d5bec3579
 SHA512:
-  metadata.gz: 5c3a27cd35c29b64639824a9634dae31a29ae50a6cd81757984a48f4e07e609a9a49c9fcadfbf5aa4d89f4f7c13c006747a61f02b51ffc5a3026d49ed60896ab
-  data.tar.gz: 591ff0da2180d3ed941301c7d1b3d62d4479f831705c900f3c2dc4fb1bccfd00ccf94224cd84a66a9f0c8f1d82b8a09f8080fff7ca96f85a515271b73d47e6fc
+  metadata.gz: 97cd7325701aa1aa34687797e518798131bd4de7773aed4f64abd59bc91ffe7b097c3862567f6a4eb7ecc620174ba70e7513bbb26fc84820a9f5b95ab617077a
+  data.tar.gz: f749cbd245f20a45acf828a8aa15c0ca413d119109cf3ca3807650f6bf366eef25f4c062d2a6b9af5e70adcc490cdaff06973b5f34dfa1af93cdbcd681d12b42

data/README.md

@@ -1,5 +1,5 @@
 # RecommEngine
-A plug-and-play recommendation engine gem supporting multiple similarity algorithms.  Use to recommend products for people, or people for products.
+A plug-and-play recommendation engine gem supporting multiple similarity algorithms.  Use to recommend items for people, or people for items.
 
 ## Installation
 Simply `gem install recommengine` or if using bundler, add recommengine to your Gemfile thusly
@@ -8,29 +8,30 @@ require 'recommengine'
 ```
 
 ## Methodology
-RecommEngine uses a weighted scoring system in conjunction with a similarity algorithm (of either the Pearson or Euclidean variety) to suggest 'products' to users based on their prior behavior in accordance with the principle of collaborative filtering.  In order to utilize this gem, you must have users, products, and some kind of numerical scoring system that describes a user's interaction with a given product.
-Products need not be physical items, as this gem has applications outside the ecommerce realm. Products can be things like movies or web links as well.  Similarly, scores aren't limited to only to ratings -- they only need to be a numerical representation that describes a user's behavior.  For example:
+RecommEngine uses a weighted scoring system in conjunction with a similarity algorithm (of either the Pearson or Euclidean variety) to suggest items to users based on their prior behavior in accordance with the principle of collaborative filtering.  In order to utilize this gem, you must have users, items, and some kind of numerical scoring system that describes a user's interaction with a given item.
 
+Items need not be physical products, as recommendation engines have applications outside the ecommerce/marketplace realm. Items can be things like movies or web links as well.  Similarly, scores aren't limited only to ratings of physical items -- they only need to be a numerical representation that describes a user's behavior.  For example:
 
-|(Score)| Physical Goods | Movies |  Web Habits  |
+
+| Score | Physical Goods | Movies |  Web Habits  |
 --------|:--------------:|:------:|-------------:|
-|   0   | No Interaction |  < *   | Didn't Click |
-|   1   | Browsed        |   *    | Clicked      |
-|   2   | Searched For   |   **   | Searched for |
-|   3   | Bought         |   ***  |     N/A      |
-|   4   | Bought > 1x    |   **** |     N/A      |
+|   0   | No Interaction |   *    | Didn't Click |
+|   1   | Browsed        |   **   | Clicked      |
+|   2   | Searched For   |   ***  | Searched for |
+|   3   | Bought         |   **** |     N/A      |
+|   4   | Bought > 1x    |   *****|     N/A      |
 
 ### Euclidean Algorithm
 
-The Euclidean distance algorithm is a simplistic similarity measure that determines how close two points are when plotted in [Cartesian coordinates](https://en.wikipedia.org/wiki/Cartesian_coordinate_system).  Read more about Euclidean distance on [wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance).
+The Euclidean distance algorithm is a simplistic similarity measure that determines how close two points are when plotted in [Cartesian coordinates](https://en.wikipedia.org/wiki/Cartesian_coordinate_system).  This algorithm essentially calculates average distance by means of the [Pythagorean Theorem](https://en.wikipedia.org/wiki/Pythagorean_theorem) and inverts the result so that a score of '1.0' represents a perfect correlation (both users have identical preferences) and a score of '0.0' representents no correlation. Read more about Euclidean distance on [wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance).
 
 ### Pearson Algorithm
 
-The Pearson similarity score adds a bit more complexity.  Feel free to read up on it on [wikipedia](https://en.wikipedia.org/wiki/Pearson_product-moment_correlation_coefficient).  The Pearson method is the default similarity algorithm in RecommEngine, primarily because it compensates for grade inflation when determining similarity.
+The Pearson similarity score adds a bit more complexity.  While not as intuitive as calculating Euclidean distance, the Pearson correlation determines the ratio how much all scored items between two users vary altogether to the product of how much they vary individually, such that a score of '1.0' represents a perfect correlation, a score of '0.0' represents no correlation, and a score of '-1.0' represents an inverse (negative) correlation.  The general idea from a Cartesian standpoint (assuming we have a `subject` user on the X axis, a `comparate` user on the Y axis, scores correlating to axial position, and a scatter plot of items) is to determine the 'best-fit' line that comes as close as possible to touching all items (a score of 1.0 could be represented by a perfectly diagonal line that touches all items).  Feel free to read up on it on [wikipedia](https://en.wikipedia.org/wiki/Pearson_item-moment_correlation_coefficient).  The Pearson method is the default similarity algorithm in RecommEngine, primarily because it compensates for grade inflation and can determine negative correlations between users' preferences.
 
 ### How Recommendations Work
 
-When passing 'data' and 'subject' arguments to the recommendations method, RecommEngine will compare the similarity between all members of the data hash and the subject using the specified similarity algorithm, and determine a weighted predicted score for each product based upon each user's similarity to the subject.  Only 'products' that the subject has not yet rated will be returned.  The products are sorted by score in descending order.
+When passing `data:` and `subject:` arguments to the recommendations method, RecommEngine will compare the similarity between all members of the `data` hash and the `subject` using the specified `similarity` algorithm, and determine a weighted predicted score for each item based upon each user's similarity to the subject and the scores that each user gave each item.  Only items that the subject has not yet scored will be returned (no need to recommend an item to a user that he/she has already interacted with).  The items are sorted by score in descending order.
 
 ## Usage
 
@@ -62,12 +63,12 @@ RecommEngine.recs(data: books, subject: :alice)
  ["War of the Worlds", 3.5]]
 ```
 
-Only products the subject has not rated will be returned.  The second element in each array is the predicted score the subject will give to the product, based upon the weighted average that similar users to alice have rated the product.  Since no similarity algorithm was specified, the Pearson score is used by default.
+Only items the subject has not rated will be returned (we won't recommend items with which the user is already familiar).  The second element in each array is the predicted score the subject will give to the item, based upon the weighted average that similar users to alice have rated the item.  Since no similarity algorithm was specified, the Pearson score is used by default.
 
 Alternatively, we could specify the use of the Euclidean algorithm as follows.
 
 ```ruby
-RecommEngine(data: books, subject: :alice, similarity: 'Euclidean')
+RecommEngine.recs(data: books, subject: :alice, similarity: 'Euclidean')
 ```
 
 Which returns a similar, though subtly different set of results:
@@ -77,12 +78,18 @@ Which returns a similar, though subtly different set of results:
  ["War of the Worlds", 3.8959601003790714],
  ["The Great Gatsby", 3.7736808311188366]]
 ```
-### Top Matches
+
+If you only want the top recommendation, simply:
+
+```Ruby
+RecommEngine.top_rec(data: books, subject: :alice, similarity: 'Euclidean')
+```
+### Similar Users
 
 RecommEngine includes a utility to find similar users to a subject.  This can be done by calling:
 
 ```ruby
-RecommEngine.top_matches(data: books, subject: :bob)
+RecommEngine.similar_users(data: books, subject: :bob)
 ```
 
 which returns:
@@ -95,9 +102,13 @@ You'll notice a reasonably strong positive correlation with Don (meaning Don and
 
 By default, the Pearson algorithm is used, and only 3 results are returned.  These  parameters can be defined explicitly when calling the method, by passing for example `num: 5` and/or `similarity: 'Euclidean'`.
 
+Practically speaking, this can be used as a means to recommend users to one another in a social network.
+
+To get users with the lowest similarity score: `RecommEngine.dissimilar_users(data: ...`
+
 ### Flipper
 
-RecommEngine also provides a handy means to 'flip' your data -- transposing products and users.  This can be handy when attempting direct marketing campaigns for instance.  Products are compared by similarity, and users are recommended for each products.  It can lead to some interesting results.  For example
+RecommEngine also provides a handy means to 'flip' your data -- transposing items and users.  This can be used for making generic item recommendations (for instance when a user is not logged in, or you do not have very much data for the logged-in user).  This can also be handy when pushing direct marketing campaigns for specific items.  Items are compared by similarity, and users are recommended for each items.  It can lead to some interesting results.  For example
 
 ```ruby
 RecommEngine.recs(data: RecommEngine.flip(books), subject: 'Crime and Punishment')

data/lib/recommengine.rb

@@ -1,27 +1,30 @@
-files = %w[calculator euclidean_calculator flipper matcher pearson_calculator recommender]
-files.each { |f| require "recommengine/#{f}" }
+files = %w[calculator euclidean_calculator flipper matcher pearson_calculator recommender test_data]
+files.each { |f| require "./lib/recommengine/#{f}" }
 
 module RecommEngine
+
   DEFAULT_ALGORITHM = 'Pearson'
   DEFAULT_MATCHES_NUMBER = 3
 
-  def recommendations(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM)
+  module_function
+
+  def recs(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM)
     RecommEngine::Recommender.new(data: data, subject: subject, similarity: similarity).recs
   end
 
-  alias_method :recs, :recommendations
+  def top_rec(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM)
+    RecommEngine::Recommender.new(data: data, subject: subject, similarity: similarity).top_rec
+  end
 
-  def top_matches(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM, num: RecommEngine::DEFAULT_MATCHES_NUMBER)
+  def similar_users(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM, num: RecommEngine::DEFAULT_MATCHES_NUMBER)
     RecommEngine::Matcher.new(data: data, subject: subject, similarity: similarity, num: num).top_matches
   end
 
-  def bottom_matches(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM, num: RecommEngine::DEFAULT_MATCHES_NUMBER)
+  def dissimilar_users(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM, num: RecommEngine::DEFAULT_MATCHES_NUMBER)
     RecommEngine::Matcher.new(data: data, subject: subject, similarity: similarity, num: num).bottom_matches
   end
 
   def flip(data)
     RecommEngine::Flipper.new(data).flip
   end
-
-  module_function :recommendations, :recs, :top_matches, :flip
 end

data/lib/recommengine/euclidean_calculator.rb

@@ -1,19 +1,25 @@
 module RecommEngine
   class EuclideanCalculator < Calculator
-    attr_reader :data, :subject, :comparate
+    def calc
+      1.0 / (Math.sqrt(1.0 + sum_of_squared_distances))
+    end
+
+    private
 
-    def initialize(data:, subject:, comparate:)
-      super
+    def squared_distances
+      data[subject].map{ |item, subject_score| square_of_distance(item, subject_score) if comparate_score(item) }.compact
     end
 
-    def calc
-      1.0 / (Math.sqrt(1.0 + sum_simalarities))
+    def sum_of_squared_distances
+      squared_distances.inject(:+)
     end
 
-    private
+    def comparate_score(item)
+      data[comparate][item]
+    end
 
-    def sum_simalarities
-      @data[@subject].map{ |product, score| ((score - data[comparate][product])**2) if data[comparate][product] }.compact.inject(:+)
+    def square_of_distance(item, subject_score)
+      (subject_score - comparate_score(item))**2
     end
   end
 end

data/lib/recommengine/flipper.rb

@@ -1,5 +1,7 @@
 module RecommEngine
   class Flipper
+    attr_reader :data
+
     def initialize(data)
       @data = data
     end
@@ -7,10 +9,10 @@ module RecommEngine
     def flip
       result = {}
       result.default = {}
-      @data.each_key do |k|
-        @data[k].each_key do |kk|
-          result[kk] = {} if result[kk].empty?
-          result[kk][k] = @data[k][kk]
+      data.each_key do |user|
+        data[user].each_key do |item|
+          result[item] = {} if result[item].empty?
+          result[item][user] = data[user][item]
         end
       end
       result

data/lib/recommengine/matcher.rb

@@ -20,24 +20,27 @@ module RecommEngine
     private
 
     def all_matches
-      scores.sort_by{|k, v| v}
+      similarity_scores.sort_by{|k, v| v}
     end
 
-    def scores
+    def similarity_scores
       scores = {}
-      data.each_key do |k|
-        next if subject == k
-        scores[k] = similarity_calculator.new(data: @data, subject: @subject, comparate: k).calc
+      comparates.each do |comparate|
+        scores[comparate] = similarity_calculator.new(data: data, subject: subject, comparate: comparate).calc
       end
       scores
     end
 
     def similarity_calculator
-      Module.const_get("RecommEngine::#{@similarity}Calculator")
+      Module.const_get("RecommEngine::#{similarity}Calculator")
     end
 
     def upper_limit
       num - 1
     end
+
+    def comparates
+      data.dup.delete_if{ |k,v| k == subject }.keys
+    end
   end
 end

data/lib/recommengine/pearson_calculator.rb

@@ -1,40 +1,40 @@
 module RecommEngine
   class PearsonCalculator < Calculator
-    attr_accessor :sum1, :sum2, :sq_sum1, :sq_sum2, :product_sum
+    attr_reader :sum_of_subject_scores, :sum_of_comparate_scores, :sum_of_sq_subject_scores, :sum_of_sq_comparate_scores, :sum_of_scores_product, :_number_of_hits, :_similar_items
 
-    def initialize(data:, subject:, comparate:)
+    def initialize(*args)
       super
-      @sum1 = @sum2 = @sq_sum1 = @sq_sum2 = @product_sum = 0
+      @sum_of_subject_scores = @sum_of_comparate_scores = @sum_of_sq_subject_scores = @sum_of_sq_comparate_scores = @sum_of_scores_product = 0
     end
 
     def calc
-      return 0 if similar_items.empty?
-      sum_all_similarities
+      return 0 if number_of_hits < 2
+      sum_all_scores
       perform_equation
     end
 
     private
 
     def similar_items
-      @similar_items ||= @data[@subject].map{ |k, v| k if @data[@comparate].keys.include?(k) }.compact
+      @_similar_items ||= data[subject].map{ |k, v| k if data[comparate].keys.include?(k) }.compact
     end
 
     def number_of_hits
-      @number_of_hits ||= similar_items.length
+      @_number_of_hits ||= similar_items.length
     end
 
-    def sum_all_similarities
-      similar_items.each{ |item| sum_simalarities(item) }
+    def sum_all_scores
+      similar_items.each{ |item| sum_scores_for(item) }
     end
 
-    def sum_simalarities(item)
-      subject_val = @data[@subject][item]
-      comparate_val = @data[@comparate][item]
-      @sum1 += subject_val
-      @sum2 += comparate_val
-      @sq_sum1 += subject_val**2
-      @sq_sum2 += comparate_val**2
-      @product_sum += subject_val * comparate_val
+    def sum_scores_for(item)
+      subject_val = data[subject][item]
+      comparate_val = data[comparate][item]
+      @sum_of_subject_scores += subject_val
+      @sum_of_comparate_scores += comparate_val
+      @sum_of_sq_subject_scores += subject_val**2.0
+      @sum_of_sq_comparate_scores += comparate_val**2.0
+      @sum_of_scores_product += subject_val * comparate_val
     end
 
     def perform_equation
@@ -42,11 +42,11 @@ module RecommEngine
     end
 
     def numerator
-      @product_sum - (@sum1 * @sum2/number_of_hits)
+      sum_of_scores_product - (sum_of_subject_scores * sum_of_comparate_scores/number_of_hits)
     end
 
     def denominator
-      @denominator ||= Math.sqrt((@sq_sum1 - (@sum1**2)/number_of_hits)*(@sq_sum2 - (@sum2**2)/number_of_hits))
+      @_denominator ||= Math.sqrt((sum_of_sq_subject_scores - (sum_of_subject_scores**2.0)/number_of_hits)*(sum_of_sq_comparate_scores - (sum_of_comparate_scores**2.0)/number_of_hits))
     end
   end
 end

data/lib/recommengine/recommender.rb

@@ -1,62 +1,78 @@
 module RecommEngine
   class Recommender
-    attr_reader :data, :subject, :similarity, :similarity_scores, :totals, :similarity_sums
+    attr_reader :data, :subject, :similarity_algorithm, :user_similarity_scores, :sum_of_weighted_scores_by_item, :sum_of_user_similarity_scores_by_item, :predicted_scores
 
     def initialize(data:, subject:, similarity: RecommEngine::DEFAULT_ALGORITHM)
       @data = data
       @subject = subject
-      @similarity = similarity
-      @similarity_scores = {}
-      @totals = {}
-      @similarity_sums = {}
-      @totals.default = 0
-      @similarity_sums.default = 0
+      @similarity_algorithm = similarity
+      @predicted_scores = {}
+      @user_similarity_scores = {}
+      @sum_of_weighted_scores_by_item = {}
+      @sum_of_user_similarity_scores_by_item = {}
+      @sum_of_weighted_scores_by_item.default = 0
+      @sum_of_user_similarity_scores_by_item.default = 0
     end
 
     def recs
-      @data.each_key do |comperate|
-        next if is_subject?(comperate) || non_positive_similarity?(comperate)
-        @data[comperate].each_key do |product|
-          update_sums(comperate, product) unless scored_by_subject?(@subject, product)
-        end
-      end
-      rankings
+      calculate_weighted_totals
+      calculate_predicted_scores
+      predicted_scores.sort_by{ |item, score| score }.reverse
+    end
+
+    def top_rec
+      calculate_weighted_totals
+      calculate_predicted_scores
+      predicted_scores.max_by{ |item, score| score }
     end
 
     private
 
-    def is_subject?(comperate)
-      comperate == @subject
+    def calculate_weighted_totals
+      comparates.each do |comparate|
+        data[comparate].each_key{ |item| update_cumulative_totals(comparate, item) unless scored_by_subject?(item) }
+      end
     end
 
-    def score(comperate)
-      return @similarity_scores[comperate] if @similarity_scores && @similarity_scores[comperate]
-      @similarity_scores[comperate] = similarity_calculator.new(data: @data, subject: @subject, comparate: comperate).calc
+    def comparates
+      data.dup.delete_if{ |user, item| user == subject || non_positive_similarity?(user) }.keys
+    end
+
+    def non_positive_similarity?(comparate)
+      similarity_score(comparate) <= 0
+    end
+
+    def similarity_score(comparate)
+      user_similarity_scores[comparate] ||= similarity_calculator.new(data: calculator_data(comparate), subject: subject, comparate: comparate).calc
     end
 
     def similarity_calculator
-      Module.const_get("RecommEngine::#{@similarity}Calculator")
+      Module.const_get("RecommEngine::#{similarity_algorithm}Calculator")
     end
 
-    def non_positive_similarity?(comperate)
-      score(comperate) <= 0
+    def calculator_data(comparate)
+      data.select{ |user, item| user == subject || user == comparate }
     end
 
-    def scored_by_subject?(subject, product)
-      if @data[subject][product]
-        !@data[subject][product].zero?  || @data[subject].include?(product)
-      end
+    def calculate_predicted_scores
+      sum_of_weighted_scores_by_item.each { |item, sum_of_scores| predicted_scores[item] = average_weighted_similarity_score(item, sum_of_scores) }
+    end
+
+    def scored_by_subject?(item)
+      data[subject][item] && !data[subject][item].zero?
+    end
+
+    def update_cumulative_totals(comparate, item)
+      sum_of_weighted_scores_by_item[item] += weighted_similarity_score(comparate, item)
+      sum_of_user_similarity_scores_by_item[item] += similarity_score(comparate)
     end
 
-    def update_sums(comperate, product)
-      @totals[product] += @data[comperate][product] * score(comperate)
-      @similarity_sums[product] += score(comperate)
+    def weighted_similarity_score(comparate, item)
+      data[comparate][item] * similarity_score(comparate)
     end
 
-    def rankings
-      rankings = {}
-      @totals.each { |subject, total| rankings[subject] = total / @similarity_sums[subject] }
-      rankings.sort_by{|k, v| v}.reverse
+    def average_weighted_similarity_score(item, sum_of_scores)
+      sum_of_scores / sum_of_user_similarity_scores_by_item[item]
     end
   end
 end

data/lib/recommengine/test_data.rb

@@ -0,0 +1,23 @@
+module RecommEngine
+  WU_TANG = {'Ghostface Killah'=> {'The Sixth Sense'=> 2.5, 'Snakes on a Plane'=> 3.5, '27 Dresses'=> 3.0, 'The Avengers'=> 3.5, 'Pootie Tang'=> 2.5, 'Titanic'=> 3.0},
+  'RZA'=> {'The Sixth Sense'=> 3.0, 'Snakes on a Plane'=> 3.5, '27 Dresses'=> 1.5, 'The Avengers'=> 5.0, 'Titanic'=> 3.0, 'Pootie Tang'=> 3.5},
+  'Raekwon'=> {'The Sixth Sense'=> 2.5, 'Snakes on a Plane'=> 3.0, 'The Avengers'=> 3.5, 'Titanic'=> 4.0},
+  'GZA'=> {'Snakes on a Plane'=> 3.5, '27 Dresses'=> 3.0, 'Titanic'=> 4.5, 'The Avengers'=> 4.0, 'Pootie Tang'=> 2.5},
+  'Method Man'=> {'The Sixth Sense'=> 3.0, 'Snakes on a Plane'=> 4.0, '27 Dresses'=> 2.0, 'The Avengers'=> 3.0, 'Titanic'=> 3.0,'Pootie Tang'=> 2.0},
+  'ODB' => {'The Sixth Sense'=> 3.0, 'Snakes on a Plane'=> 4.0, 'Titanic'=> 3.0, 'The Avengers'=> 5.0, 'Pootie Tang'=> 3.5},
+  'Inspectah Deck'=> {'Snakes on a Plane'=>4.5, 'Pootie Tang'=>1.0, 'The Avengers'=>4.0}}
+
+  CRITICS = {"Lisa Rose"=>{"Lady in the Water"=>2.5, "Snakes on a Plane"=>3.5, "Just My Luck"=>3.0, "Superman Returns"=>3.5, "You, Me and Dupree"=>2.5, "The Night Listener"=>3.0},
+  "Gene Seymour"=>{"Lady in the Water"=>3.0, "Snakes on a Plane"=>3.5, "Just My Luck"=>1.5, "Superman Returns"=>5.0, "The Night Listener"=>3.0, "You, Me and Dupree"=>3.5},
+  "Michael Phillips"=>{"Lady in the Water"=>2.5, "Snakes on a Plane"=>3.0, "Superman Returns"=>3.5, "The Night Listener"=>4.0},
+  "Claudia Puig"=>{"Snakes on a Plane"=>3.5, "Just My Luck"=>3.0, "The Night Listener"=>4.5, "Superman Returns"=>4.0, "You, Me and Dupree"=>2.5},
+  "Mick LaSalle"=>{"Lady in the Water"=>3.0, "Snakes on a Plane"=>4.0, "Just My Luck"=>2.0, "Superman Returns"=>3.0, "The Night Listener"=>3.0, "You, Me and Dupree"=>2.0},
+  "Jack Matthews"=>{"Lady in the Water"=>3.0, "Snakes on a Plane"=>4.0, "The Night Listener"=>3.0, "Superman Returns"=>5.0, "You, Me and Dupree"=>3.5},
+  "Toby"=>{"Snakes on a Plane"=>4.5, "You, Me and Dupree"=>1.0,"Superman Returns"=>4.0}}
+
+  BOOKS = {alice: {"War and Peace" => 2.5, "Crime and Punishment" => 3.5},
+  bob: {"War of the Worlds" => 5.0, "War and Peace" => 1.5, "The Great Gatsby" => 4.0},
+  cindy: {"War and Peace" => 5.0, "The Great Gatsby" => 4.5, "War of the Worlds" => 3.0, "Twenty Thousand Leagues Under the Sea" => 3.0},
+  don: {"War of the Worlds" => 4.0, "The Great Gatsby" => 2.5, "Twenty Thousand Leagues Under the Sea" => 5.0, "Crime and Punishment" => 4.5, "War and Peace" => 3.0},
+  erica: {"War of the Worlds" => 3.0, "The Great Gatsby" => 4.5, "Twenty Thousand Leagues Under the Sea" => 4.0, "Crime and Punishment" => 4.5, "War and Peace" => 3.5}}
+end

data/recommengine.gemspec

@@ -2,7 +2,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name          = 'recommengine'
-  s.version       = '0.1.3'
+  s.version       = '0.1.4'
   s.date          = '2015-09-12'
   s.summary       = "A flexible recommendation engine."
   s.description   = "A flexible recommendation engine supporting multiple similarity algorithms for use in ecommerce sites, marketplaces, social sharing apps, and more."

data/spec/lib/recommender_spec.rb

@@ -5,7 +5,7 @@ describe '.recommender' do
 
   describe '#initialize' do
     it 'defaults to Pearson similarity algorithm if none is specified' do
-      expect(default_recommender.similarity).to eq('Pearson')
+      expect(default_recommender.similarity_algorithm).to eq('Pearson')
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recommengine
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Cody Knauer
@@ -42,6 +42,7 @@ files:
 - lib/recommengine/matcher.rb
 - lib/recommengine/pearson_calculator.rb
 - lib/recommengine/recommender.rb
+- lib/recommengine/test_data.rb
 - recommengine.gemspec
 - spec/lib/euclidean_calculator_spec.rb
 - spec/lib/flipper_spec.rb
@@ -70,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A flexible recommendation engine.