cofi_cost 0.0.2

data/README

@@ -0,0 +1,10 @@
+Playground for collaborative filtering in Ruby using NArray and rb-gsl.
+
+“Snowflakes, like people, are all different and beautiful, 
+but they can be a nuisance when they lose their identity in a mob”
+
+Roadmap:
+First release name: Graupel
+Release Date: TBD
+From http://en.wikipedia.org/wiki/Graupel Jan 1, 2012
+"Graupel refers to precipitation that forms when supercooled droplets of water are collected and freeze on a falling snowflake, forming a 2–5 mm (0.079–0.197 in) ball of rime. The term graupel is the German word for this meteorological phenomenon. Graupel is sometimes referred to as small hail, although the World Meteorological Organization defines small hail as snow pellets encapsulated by ice, a precipitation halfway between graupel and hail."

data/lib/cofi_cost.rb

@@ -0,0 +1,167 @@
+require 'gsl'
+require 'matrix'
+require 'narray'
+
+include GSL::MultiMin
+
+class CofiCost
+
+	attr_accessor :ratings, :num_features, :cost, :lambda
+	attr_reader :boolean_rated, :num_tracks, :num_users, :features, :theta, :ratings_mean, :ratings_norm, :predictions
+	
+	def initialize(ratings, num_features, lambda, features = nil, theta = nil)
+		@ratings = ratings.to_f	# make sure it's a float for correct normalization
+		@num_features = num_features
+		@cost = 0
+		@boolean_rated = @ratings > 0 # return 0 for all rated and 1 for all unrated
+		@boolean_unrated = @boolean_rated.eq 0 # return 1 for all unrated and 0 for all unrated
+		@num_tracks = @ratings.shape[1] # @ratings is users x tracks
+		@num_users = @ratings.shape[0]
+		# set initial parameters
+		# allow theta/features to be set for testing
+		if features.nil? then @features = NArray.float(@num_features, @num_tracks).randomn else @features = features end
+		if theta.nil? then @theta = NArray.float(@num_features, @num_users).randomn else @theta = theta end
+		@ratings_mean = NArray.float(1, @num_tracks).fill(0.0)
+		@ratings_norm = NArray.float(@num_users, @num_tracks).fill(0.0)
+		@ratings_mean, @ratings_norm = normalize_ratings
+		@lambda = lambda
+		@predictions = nil
+	end
+	
+	def normalize_ratings
+		for i in 0..@num_tracks-1 # sadly, @num_tracks.each_index does not work with NArray yet
+			track_rating = @ratings[true,i] # get all user ratings for track i (including unrated)
+			boolean_track_rating = boolean_rated[true,i] # get all user ratings that exist for track i
+		    	@ratings_mean[i] = track_rating[boolean_track_rating].mean
+		    	
+		    	track_norm = @ratings_norm[true,i]
+		    	track_norm[boolean_track_rating] = track_rating[boolean_track_rating] - @ratings_mean[i]
+		    	@ratings_norm[true,i] = track_norm
+		end
+		return @ratings_mean, @ratings_norm
+	end
+	
+	def unroll_params(v)
+		v = v.to_na
+		theta = v.slice(0..@theta.size-1).reshape(@theta.shape[0],true)
+		features = v.slice(@theta.size..-1).reshape(@features.shape[0],true)
+		return theta, features
+	end
+	
+	def partial_cost_calc(theta,features)
+		(NArray.ref(NMatrix.ref(features) * NMatrix.ref(theta.transpose(1,0))) - @ratings_norm) * @boolean_rated
+	end
+	
+	def roll_up_theta_and_features
+		# roll up theta and features together
+		# (oddly, NArray objects created don't seem to recognize the hcat method
+		# 	added to the open class NArray
+		#	x = GSL:: Vector.alloc(@theta.reshape(true).hcat(@features.reshape(true)))
+		#		will fail)
+		#		I don't understand why this is/how to fix it.
+		theta_reshaped = @theta.reshape(true)
+		features_reshaped = @features.reshape(true)
+		rolled = NArray.hcat(theta_reshaped,features_reshaped)
+		GSL:: Vector.alloc(rolled) # starting point
+	end
+	
+	def unroll_params_init_shape(x)
+		theta, features = unroll_params(x)
+		@theta = theta.reshape(@theta.shape[0],true)
+		@features = features.reshape(@features.shape[0],true)
+	end
+	
+	def min_cost
+		cost_f = Proc.new { |v|
+			theta, features = unroll_params(v)
+			# In octave:
+			# 1/2 * sum(sum(((X * Theta.transpose - Y).*R).^2)) + lambda/2 * sum(sum((Theta).^2)) + lambda/2 * sum(sum((X).^2))
+			(partial_cost_calc(theta,features)**2).sum + @lambda/2 * (features**2).sum
+		}
+		cost_df = Proc.new { |v, df|
+			theta, features = unroll_params(v)
+			# In octave:
+			# xgrad = ((X * Theta.transpose - Y).* R) * Theta + lambda * X # X_grad
+			# thetagrad = ((X * Theta.transpose - Y).* R).transpose * X + lambda * Theta
+			
+			# I realize this is a hack. I'm not totally sure why or how but just setting
+			# df = NArray.hcat(dfzero,dfone) results in no steps being made in gradient descent.
+			# ideas/suggestions welcome :)
+			dfzero = (NArray.ref(NMatrix.ref(partial_cost_calc(theta,features)) * NMatrix.ref(theta)) + @lambda * features).flatten
+			dfone = (NArray.ref(NMatrix.ref((partial_cost_calc(theta,features)).transpose(1,0)) * NMatrix.ref(features)) + @lambda * theta).flatten
+			dfcomp = NArray.hcat(dfzero,dfone)
+			for i in 0..dfcomp.size-1	# again .each_index does not yet work with NArray
+				df[i] = dfcomp[i]
+			end
+		}
+		
+		x = roll_up_theta_and_features
+		cost_func = Function_fdf.alloc(cost_f, cost_df, x.size)
+
+		# TODO: figure out which algorithm to use
+		# http://www.gnu.org/software/gsl/manual/html_node/Multimin-Algorithms-with-Derivatives.html
+		minimizer = FdfMinimizer.alloc("conjugate_fr", x.size)
+		minimizer.set(cost_func, x, 0.01, 1e-4)
+		
+		iter = 0
+		begin
+			iter += 1
+			status = minimizer.iterate()
+			status = minimizer.test_gradient(1e-3)
+			if status == GSL::SUCCESS
+				puts("Minimum found at")
+			end
+			x = minimizer.x
+			f = minimizer.f
+			printf("%5d %.5f %.5f %10.5f\n", iter, x[0], x[1], f)
+		end while status == GSL::CONTINUE and iter < 10
+		
+		unroll_params_init_shape(x)
+		@cost = f
+		@predictions = calc_predictions
+	end
+	
+	def calc_predictions
+		NArray.ref(NMatrix.ref(@features) * NMatrix.ref(@theta.transpose(1,0))) + @ratings_mean
+	end
+
+end
+
+class NArray
+	class << self
+		def cat(dim=0, *narrays)
+		      raise ArgumentError, "'dim' must be an integer" unless dim.is_a?(Integer)
+		      raise ArgumentError, "must have narrays to cat" if narrays.size == 0
+		      new_typecode = narrays.map(&:typecode).max
+		      narrays.uniq.each {|narray| narray.newdim!(dim) if narray.shape[dim].nil? }
+		      shapes = narrays.map(&:shape)
+		      new_dim_size = shapes.inject(0) {|sum,v| sum + v[dim] }
+		      new_shape = shapes.first.dup
+		      new_shape[dim] = new_dim_size
+		      narr = NArray.new(new_typecode, *new_shape)
+		      range_cnt = 0
+		      narrays.zip(shapes) do |narray, shape|
+			index = shape.map {true}
+			index[dim] = (range_cnt...(range_cnt += shape[dim]))
+			narr[*index] = narray
+		      end
+		      narr
+		end
+		def vcat(*narrays) ; cat(1, *narrays) end
+		def hcat(*narrays) ; cat(0, *narrays) end
+	end
+end
+
+##ratings = NArray.float(4,5).indgen(0,2)
+#ratings = NArray[[5.0,4.0,0.0,0.0],[3.0,0.0,0.0,0.0],[4.0,0.0,0.0,0.0],[3.0,0.0,0.0,0.0],[3.0,0.0,0.0,0.0]]
+#num_features = 2
+#lambda = 1
+#g = CofiCost.new(ratings, num_features, lambda)
+#puts g.theta.nil?
+#g.min_cost
+#puts "new theta"
+#puts g.theta.to_a.to_s
+#puts "new features"
+#puts g.features.to_a.to_s
+#puts "predictions"
+#puts g.predictions.to_a.to_s

data/test/unit/test_cofi_cost.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require_relative '../../lib/cofi_cost.rb'
+require 'narray'
+require 'gsl'
+require 'matrix'
+
+class CofiCostTest < Test::Unit::TestCase
+
+  def setup
+    ratings = NArray[[5.0,4.0,0.0,0.0],[3.0,0.0,0.0,0.0],[4.0,0.0,0.0,0.0],[3.0,0.0,0.0,0.0],[3.0,0.0,0.0,0.0]]
+    num_features = 2
+    lambda = 1
+    features = NArray[[0.139489,1.804804],[-0.501808,1.050885],[0.354079,-0.518884],[-0.015370,0.096253],[1.147623,-0.745562]]
+    theta = NArray[[-0.079641,1.211386],[-0.130688,0.444762],[-0.789258,1.222232],[0.212132,-1.174545]]
+    @c = CofiCost.new(ratings, num_features, lambda, features, theta)
+  end
+  
+  def teardown
+    @c = nil
+  end
+  
+  def test_happy_case
+    @c.min_cost
+    assert_equal 0.15929446605989878, @c.cost
+    # oddly the following fails, even though they are equal (not enough decimal places me thinks)
+    # assert_equal NArray[[4.62547,3.91302,8.30084,1.59081],[2.96361,3.17939,1.88322,3.88434],[3.92356,4.32263,1.739,5.6172],[2.98132,3.06219,2.47359,3.3213],[2.93724,3.14111,1.33728,3.77855]], @c.predictions
+    assert_equal 4.625468057637709, @c.predictions[0,0]
+  end
+  
+  def test_normalize_ratings
+    assert_equal NArray[[4.5],[3.0],[4.0],[3.0],[3.0]], @c.ratings_mean
+    assert_equal NArray[[0.5,-0.5,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], @c.ratings_norm
+  end
+  
+  def test_roll_up_theta_and_features
+    rolled = @c.roll_up_theta_and_features
+    assert_equal GSL:: Vector.alloc([-0.079641, 1.211386, -0.130688, 0.444762, -0.789258, 1.222232, 0.212132, -1.174545, 0.139489, 1.804804, -0.501808, 1.050885, 0.354079, -0.518884, -0.01537, 0.096253, 1.147623, -0.745562]), rolled
+  end
+  
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: cofi_cost
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Wolfe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gsl
+  requirement: &83060750 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *83060750
+- !ruby/object:Gem::Dependency
+  name: narray
+  requirement: &83060170 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *83060170
+description: Playground for collaborative filtering in Ruby using NArray and rb-gsl.
+email: tomwolfe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cofi_cost.rb
+- README
+- test/unit/test_cofi_cost.rb
+homepage: http://github.com/tomwolfe/cofi_cost
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- libgsl0-dev
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Collaborative filtering
+test_files: []