# Implementing the Pearson correlation algorithm using Ruby and the GNU Scientific Library

At Ruby Manor on Saturday Alex MacCaw gave a great introduction to his acts_as_recommendable plugin for Rails. acts_as_recommendable simplifies collaborative filtering for Rails models, automatically generating recommended items, at an on-line store for example, based on a database of user preferences.

At its heart, acts_as_recommendable uses a statistical measure known as the Pearson correlation coefficient to calculate the "nearness" of items to one another. Alex talked about the performance issues he encountered when implementing the algorithm in pure ruby. To allow recommendations to be calculated for the entire database he had to switch to making calculations offline and reimplementing the algorithm in C using RubyInline.

The GNU Scientific Library has an implementation of the Pearson algorithm, and in this post I'd like to show how the Ruby code, or its inline-C equivalent can be replaced with GSL code using Ruby bindings to the GSL.

My naive pure Ruby version of the algorithm looks like this:

def ruby_pearson(x,y) n=x.length sumx=x.inject(0) {|r,i| r + i} sumy=y.inject(0) {|r,i| r + i} sumxSq=x.inject(0) {|r,i| r + i**2} sumySq=y.inject(0) {|r,i| r + i**2} prods=[]; x.each_with_index{|this_x,i| prods << this_x*y[i]} pSum=prods.inject(0){|r,i| r + i} # Calculate Pearson score num=pSum-(sumx*sumy/n) den=((sumxSq-(sumx**2)/n)*(sumySq-(sumy**2)/n))**0.5 if den==0 return 0 end r=num/den return r end

Here I should note that the acts_{as}_{recommendable} code is considerably
more complicated, however the heart of the calculation looks something
like the above. We can replace that with an inline C version using
something like:

require 'rubygems' require 'inline' inline do |builder| builder.c ' #include <math.h> double inline_pearson(int n, VALUE x, VALUE y) { double sum1 = 0.0; double sum2 = 0.0; double sum1Sq = 0.0; double sum2Sq = 0.0; double pSum = 0.0; VALUE *x_a = RARRAY(x)->ptr; VALUE *y_a = RARRAY(y)->ptr; int i; for(i=0; i<n; i++) { double this_x; double this_y; this_x = NUM2DBL(x_a[i]); this_y = NUM2DBL(y_a[i]); sum1 += this_x; sum2 += this_y; sum1Sq += pow(this_x, 2); sum2Sq += pow(this_y, 2); pSum += this_y * this_x; } double num; double den; num = pSum - ( ( sum1 * sum2 ) / n ); den = sqrt( ( sum1Sq - ( pow(sum1, 2) ) / n ) * ( sum2Sq - ( pow(sum2, 2) ) / n ) ); if(den == 0){ return 0.0; } else { return num / den; } }' end

Which is a considerable amount of code. I love the fact that this code can be embedded directly in the Ruby source code but, as was pointed out to me, for some people this would be seen as something of a maintenance nightmare. If you're prepared to install the pre-requisite GSL library and its Ruby bindings you can actually replace all of the above code with the simple:

require 'gsl' def gsl_pearson(x,y) GSL::Stats::correlation( GSL::Vector.alloc(x),GSL::Vector.alloc(y) ) end

In this code, the <verb>GSL::Vector.alloc()</verb> method converts a Ruby Array to a GSL Vector class. We then call the correlation method, helpfully provided by the Statistics portion of the GSL.

So, how does this perform ? A quick benchmark :

require 'benchmark' n = 100000 x = []; n.times{x << rand} y = []; n.times{y << rand} Benchmark.bm() do |bm| bm.report("Ruby:") {ruby_pearson(x,y)} bm.report("GSL:") {gsl_pearson(x,y)} bm.report("Inline:") {inline_pearson(n,x,y)} end

Gives some indicative results :

user | system | total | real | |
---|---|---|---|---|

Ruby: | 1.530000 | 0.020000 | 1.550000 | (1.544765) |

GSL: | 0.010000 | 0.000000 | 0.010000 | (0.015925) |

Inline: | 0.000000 | 0.000000 | 0.000000 | (0.004115) |

While the Inline version in this example outperforms the GSL version, both offer considerable savings on the Ruby version. One of the real advantages of the GSL is it allows you to rapidly experiment with alternative implementations of an algorithm. Also you can be safe in the knowledge that your code is based on a well-tested library of scientific functions.