linear-regressions 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c64615109379ef7ead3598aa35d3428d7d4dd8b7
+  data.tar.gz: 63f04cf0baeb243c3f76661392c9a9b24a816da9
+SHA512:
+  metadata.gz: 4274651628d3d38bf5607404f577496de0ecb64fff3c8c23bf082f384ee32dc8016459f23afbf97b73a3c571cee99f0666a3bb3bd22fff8301cb07a7bf41341c
+  data.tar.gz: b8d80ae9990539c66431a7932042d2c4f66fd2ac8b3499b1a1e5abd872d1a544cc18162147c668710a025fae2fc7eede16fe8f8da341e43427268200ed8b1940

data/lib/enumerable_extension.rb

@@ -0,0 +1,96 @@
+
+module Enumerable
+    def entropy
+        dataset = Hash.new(0)
+        self.each{|x| dataset[x] += 1 }
+
+        entropy = 0.0
+        dataset.each do |k,v|
+            p = v.to_f / self.size
+            entropy += (-p)*Math.log2(p)
+        end
+
+        return entropy
+    end
+
+    def concitional_entropy_with(label)
+        dataset = Hash.new{|h,k| h[k] = Array.new }
+        self.each_with_index{|v,i| dataset[v] << label[i] }
+
+        new_entropy = 0.0
+        dataset.each{|k,v| new_entropy += (v.size.to_f / self.size)*v.entropy }
+        return new_entropy
+    end
+
+    def sum
+      self.inject(0){|accum, i| accum + i }
+    end
+
+    def mean
+      self.sum / self.length.to_f
+    end
+
+    def geo_mean
+        geo_sum = self.inject(0){|accum, i| accum + i*i }
+        Math.sqrt(geo_sum)
+    end
+
+    def median
+        sorted = self.sort
+        m = sorted.length / 2
+        if sorted.length.odd?
+            sorted[m]
+        else
+            (sorted[m-1]+sorted[m])/2.0
+        end
+    end
+
+    def sum_and_mean
+        sum = self.sum
+        mean = sum/self.length.to_f
+        return sum,mean
+    end
+
+    def variance(ddof=1)
+        m = self.mean
+        sum = self.inject(0){|accum, i| accum +(i-m)**2 }
+        sum / (self.length - ddof).to_f
+    end
+
+    def stdev(ddof=1)
+        return Math.sqrt(self.variance(ddof))
+    end
+
+    def variance_and_stdev(ddof=1)
+        sv = self.variance(ddof)
+        stdev = Math.sqrt(sv)
+        return sv, stdev
+    end
+
+    def covariance(arr,ddof=1)
+        raise "array length error" if arr.length!=self.length
+        xbar = self.mean
+        ybar = arr.mean
+
+        accum = 0.0
+        arr.length.times do |i|
+            accum += (self[i]-xbar)*(arr[i]-ybar)
+        end
+        return accum / (self.length - ddof).to_f
+    end
+
+    def pearson(arr,ddof=1)
+        self.covariance(arr,ddof) / (self.stdev(ddof) * arr.stdev(ddof))
+    end
+
+    def l1_normalize
+        m = self.sum.to_f
+        self.map{|x| x / m }
+    end
+
+    def l2_normalize
+        m = self.geo_mean
+        self.map{|x| x / m }
+    end
+end
+

data/lib/linear_regressions.rb

@@ -0,0 +1,87 @@
+require 'json'
+require 'matrix'
+require './enumerable_extension'
+require './matrix_extension'
+
+module LinearRegression
+    class LinearRegressionBase
+        def train(entries)
+            raise "hasn't implemented"
+        end
+
+        def beta
+            @beta
+        end
+
+        def predict(vector)
+            x = Matrix[vector + [1]]
+            x_cross_beta = x * @beta
+            return x_cross_beta[0,0]
+        end
+
+        def r_squared_score(new_entries)
+            y = new_entries.map{|v|v[:label]}
+            y_bar = y.mean
+            ss_tot = 0.0
+            y.each do |v|
+                ss_tot += (v-y_bar)**2
+            end
+            # puts "ss_tot=#{ss_tot}"
+
+            ss_res = 0.0
+            new_entries.each do |e|
+                prediction = predict(e[:features])
+                ss_res += (e[:label]-prediction)**2
+            end
+            #puts "ss_res=#{ss_res}"
+            return 1-(ss_res/ss_tot)
+        end
+    end
+
+    class AlternatingLeastSquares < LinearRegressionBase
+        def train(entries)
+            label = entries.map{|e| e[:label] }
+            features = entries.map{|e| e[:features] }.map{|e| e+[1] }
+
+            @dimension = features[0].size
+
+            y = Matrix[label].t
+            x = Matrix[*features]
+
+            @beta = (x.t * x).inv * x.t * y
+        end
+    end
+
+    # alias
+    ALS = AlternatingLeastSquares
+
+    class GradientDescent < LinearRegressionBase
+        def initialize(num_iter: 100, alpha: 0.01)
+            @num_iter = num_iter
+            @alpha = alpha
+        end
+
+        def train(entries, &block)
+            label = entries.map{|e| e[:label] }
+            features = entries.map{|e| e[:features] }.map{|e| e+[1]}
+
+            @dimension = features[0].size
+
+            y = Matrix[label].t
+            x = Matrix[*features]
+
+            @beta = Matrix[@dimension.times.map{|x|1}].t
+
+            @num_iter.times do |i|
+                y_bar = x * @beta
+                loss = y_bar - y
+                gradient = (x.t * loss)/ entries.size
+                @beta = @beta - (@alpha * gradient)
+                yield i,@beta,loss if block!=nil
+            end
+        end
+    end
+
+    # alias
+    GD = GradientDescent
+end

data/lib/matrix_extension.rb

@@ -0,0 +1,65 @@
+
+class Matrix
+	def covariance_matrix
+		dim = self.column_size
+		buff = Array.new(dim){Array.new(dim,0)}
+		0.upto(dim-1) do |i|
+			i.upto(dim-1) do |j|
+				if i==j
+					buff[i][j] = self.column(i).to_a.variance
+				else
+					conv = self.column(i).to_a.covariance(self.column(j).to_a)
+					buff[i][j] = conv
+					buff[j][i] = conv
+				end
+			end
+		end
+		Matrix[*buff]
+	end
+
+    def l1_normalize
+        buff = Array.new
+        self.row_size.times do |i|
+            buff << self.row(i).to_a.l1_normalize
+        end
+        Matrix[*buff]
+    end
+
+    def l2_normalize
+        buff = Array.new
+        self.row_size.times do |i|
+            buff << self.row(i).to_a.l2_normalize
+        end
+        Matrix[*buff]
+    end
+
+	def to_json(*param)
+		buff = []
+		self.row_size.times do |i|
+            buff << self.row(i).to_a
+		end
+		return buff.to_json(param)
+	end
+
+    def inspect
+        buff = ""
+        self.row_size.times do |i|
+            if i==0
+                buff += "Matrix["
+            else
+                buff += " "
+            end
+
+            buff += "[" + self.row(i).to_a.join(",\t") + "]"
+
+            if i==self.row_size-1
+                buff += "]"
+            else
+                buff += ",\n"
+            end
+        end
+        return buff
+    end
+
+	alias to_s inspect
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: linear-regressions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ireullin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-21 00:00:00.000000000 Z
+dependencies: []
+description: Linear regression algorithms which implemented Alternating Least Squares
+  & Gradient Descent
+email:
+- ireullin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/enumerable_extension.rb
+- lib/linear_regressions.rb
+- lib/matrix_extension.rb
+homepage: https://github.com/ireullin/linear-regressions
+licenses:
+- MIT
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Linear regression algorithms which implemented Alternating Least Squares
+  & Gradient Descent
+test_files: []