recommend_it 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: de2266a44910ede2906b3d2d14432400e1947c8730554d7421c64534ce2a5ffb
+  data.tar.gz: df6b2b1849fa821b9b9a0eb7a8e6138e4de8fdd2190a6b84d191ccc7ad6a2d0f
+SHA512:
+  metadata.gz: a746eb1b0c828b1c9f652f0096cc87544c2c833f29da588de20fd1a9cd36982efdf4ef01e315e76558ab285e855d61ff4ca3a488764e89160312f0ab148d1cf1
+  data.tar.gz: 6e7747d78b0f8844383c586df8a70329aca144483add71691917c681c8e9594691a53b8bd71da2ca6bb57a984230b779ace2ee54667251607d3b6ab586f6221c

data/lib/models/user.rb

@@ -0,0 +1,9 @@
+class User
+    def initialize(id)
+        @id = id
+    end
+
+    def id
+        return @id
+    end
+end

data/lib/recommend.rb

@@ -0,0 +1,22 @@
+require 'user_based_recommendation'
+
+class Recommend
+    attr_reader :item, :order_details, :data
+    attr_accessor :type
+
+    # @param type = This is the type of recommendation to be performed e.g UserBasedRecommendation.new
+    # @param item = This is the object the recommendation will be performed for e.g user
+    # @param order_details = Hash containing array of users ordered menu items
+    # @param data = Matrix data of users against their purchase count of menu items
+    def initialize(type, item, order_details = [], data)
+        @type = type
+        @item = item
+        @order_details = order_details
+        @data = data
+    end
+
+    # Returns hash of user previous menus and new recommended menu items
+    def recommendation()
+        @type.recommendation(self)
+    end
+end

data/lib/user_based_recommendation.rb

@@ -0,0 +1,51 @@
+require 'utils/similars'
+
+class UserBasedRecommendation
+    include Similars
+
+    # Get recommendation
+    # user => current logged in user
+    # data => item purchase count matrix based on users
+    def recommendation(context)
+        user = context.item
+        data = context.data
+        order_details = context.order_details
+        similar_users = Similars.get_similar_users(user,data)
+        result = Hash.new
+        if similar_users.length > 0
+            user_menus = Array.new
+            user_menus = order_details[user.id]
+            similars_menus = get_similars_menus(similar_users,order_details)
+            recommend = Array.new
+            similars_menus.each do |s|
+                if !user_menus.include? s
+                    recommend.push(s)
+                end
+            end
+            result[:user] = user_menus
+            result[:recommendation] = recommend
+        end
+        return result
+    end
+
+    # Returns all similars menu items
+    def get_similars_menus(similar_users,order_details)
+        number_of_users = similar_users.length
+        similars_menus = Array.new
+        similar_users.each do |user_id, sim_index|
+            get_all_similar_users_menu_items(order_details,user_id,similars_menus)
+        end
+        return similars_menus
+    end
+
+    # Returns an array containing all menu items ordered by similar users
+    def get_all_similar_users_menu_items(order_details,user_id,menus)
+        order_details[user_id].each do |menu|
+            if !menus.include? menu
+                menus.push(menu)
+            end
+        end
+        return menus
+    end
+
+end

data/lib/utils/mock.rb

@@ -0,0 +1,98 @@
+module Mock
+    # Mock data to use for testing purposes
+
+    # Returns document vector of valid length
+    def self.d1_same_size
+        return [1,2,4,5,1,6,4,4]
+    end
+
+    # Returns document vector of valid length
+    def self.d2_same_size
+        return [1,0,4,4,1,2,4,3]
+    end
+
+    # Returns a document vector of invalid length
+    def self.d1_invalid_size
+        return [1,2,4,5,4]
+    end
+
+    # Returns users that have similar order details
+    def self.order_details_similar
+        return {
+            1 => [1,3,5,7],
+            2 => [1,4,3],
+            3 => [9,77]
+        }
+    end
+
+    # Returns users that have similar order details
+    def self.order_details_similar_12
+        return {
+            1 => [1,3,5,7],
+            2 => [1,4,3],
+            3 => [9,77,44],
+            4 => [1,5,7],
+            5 => [1,4,3],
+            6 => [9,4],
+            7 => [1,3,5,7],
+            8 => [1,4,3],
+            9 => [2,77],
+            10 => [1,3,7],
+            11 => [1,4,3,13],
+            12 => [9,5]
+        }
+    end
+
+    # Returns users that have different order details
+    def self.order_details_different
+        return {
+            1 => [61,63,5,7],
+            2 => [1,4,3],
+            3 => [9,77]
+        }
+    end
+
+    # Returns users that have similar purchase count
+    def self.matrix_data
+        return {
+            1 => [1,0,8,0,0,3,6],
+            2 => [0,2,0,0,3,0,6],
+            3 => [1,0,8,0,0,3,0]
+        }
+    end
+
+    # Returns12 similar purchase count for users
+    def self.matrix_data_12
+        return {
+            1 => [1,0,8,0,2,3,6],
+            2 => [0,2,0,0,3,0,6],
+            3 => [1,0,8,0,0,3,0],
+            4 => [1,0,8,3,2,3,0],
+            5 => [1,0,8,0,0,3,0],
+            6 => [1,0,0,0,0,3,0],
+            7 => [1,0,3,0,0,0,0],
+            8 => [1,0,8,1,0,3,4],
+            9 => [0,0,8,0,0,3,0],
+            10 => [1,0,8,0,0,3,0],
+            11 => [1,0,8,0,0,3,0],
+            12 => [1,0,8,0,0,3,0]
+        }
+    end
+
+    # Returns users that don't have similar purchase counts
+    def self.matrix_data_different
+        return {
+            1 => [1,0,8,0,0,3,6],
+            2 => [0,2,0,0,3,0,0],
+            3 => [0,0,0,1,0,0,0]
+        }
+    end
+
+    # Returns an array of users with similarity indexes
+    def self.similarity_indexes
+        return {
+            3 => 0.8201995322647244,
+            2 => 0.490352188754876
+        }
+    end
+end

data/lib/utils/similars.rb

@@ -0,0 +1,67 @@
+module Similars
+
+    # Calculate similarity index using the cosine similarity model
+    # Formula is defined as cos(d1,d2) = (d1●d2)/||d1|| * ||d2||
+    # (d1●d2) is known as the dot product i.e multiplying each attributes of the document vectors by each other
+    # ||d1||, ||d2|| is defined as magnitude
+    # Document vector magnitude is calculated by squaring each document vector attribute and find the square root of the sum
+    def self.similarity_index(d1,d2)
+        d2 = fix_missing_values(d1,d2)
+        dot_product = calculate_dot_product(d1,d2)
+        d1_magnitude = calculate_vector_magnitude(d1)
+        d2_magnitude = calculate_vector_magnitude(d2)
+        return dot_product / (d1_magnitude * d2_magnitude) # convert to  values to float before calculation so decimal places will not be lost
+    end
+
+    # Find dot product of the document vectors
+    # Dot product is done by mutliplying attribute by attribute of each document vector
+    def self.calculate_dot_product(d1,d2)
+        sum = 0
+        i = 0
+        while i < d1.length
+            sum = sum + d1[i] * d2[i]
+            i += 1
+        end
+        return sum.to_f
+    end
+
+    # Document vector magnitude is calculated by summing up the squares of each attribute and finding the square root of the sum
+    def self.calculate_vector_magnitude(vector)
+        sum = 0
+        i = 0
+        while i < vector.length
+            sum = sum + vector[i] * vector[i]
+            i += 1
+        end
+        return Math.sqrt(sum).to_f
+    end
+
+    # Returns an array of similarity index of users against the logged in user
+    # Sort the similarity indexes in descending order to get like users first
+    def self.get_similar_users(user,data)
+        sim = Hash.new
+        d1 = data[user.id]
+        data.each do |key, d2|
+            if key != user.id
+                index = similarity_index(d1, d2)
+                if index > 0 && !index.nan? # Only store users that have similarity index greater than 0 and is not NaN (NaN values are derived when document vector is filled with only zero values)
+                    sim[key] = index
+                end
+            end
+        end
+        return sim.sort_by {|k,v| -v}.to_h # sort_by function converts hash to multidemsional array, so convert back to hash after sorting
+    end
+
+    # Fix vectors of varying length by adding zeros
+    def self.fix_missing_values(d1,d2)
+        i = 0
+        length_diff = d1.length - d2.length
+        if length_diff > 0
+            while i < length_diff
+                d2.push(0)
+                i += 1
+            end
+        end
+        return d2
+    end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: recommend_it
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Weje Emmanuel Okechukwu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-01 00:00:00.000000000 Z
+dependencies: []
+description: Meal recommedation engine based on collaborative filtering
+email: wejemm@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/models/user.rb
+- lib/recommend.rb
+- lib/user_based_recommendation.rb
+- lib/utils/mock.rb
+- lib/utils/similars.rb
+homepage: http://rubygems.org/gems/recommend_it
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+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: Meal recommedation engine based on collaborative filtering
+test_files: []