principal-components-analysis 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30d9d35d743b426922569afb41295639cb782933
+  data.tar.gz: dc2eb5a6667402b76e5cc34152e75f73e147c3e2
+SHA512:
+  metadata.gz: cc77abe7776c57c6fb4e610c03520ffd8410030c6614420761c896f27363a6a61e2bf0596f4f2993fb7ae94f549ae90c70481ba000c4f73b212ae6ee3961c7c3
+  data.tar.gz: a805c60a0611fb571c82674b19bc1fe3757c643ef472c47365df73c6e60295297af72435cf8c4abeee2fe4d4b8e83618d0a5f159f17dd54d033f542c01d31729

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/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

data/lib/principal-components-analysis.rb

@@ -0,0 +1,38 @@
+require 'matrix'
+require 'matrix_extension'
+require 'enumerable_extension'
+
+class PCA
+	def initialize(entries)
+		@dimension = entries[0].size
+		@entries = Matrix[*entries]
+		conv_m = @entries.covariance_matrix
+		# p conv_m
+		eigen_vectors, eigen_values, v_inv = conv_m.eigensystem
+
+		@eigen = []
+		@total_eigenvalue = 0.0
+		@dimension.times do |i|
+			@eigen << { value: eigen_values[i,i], vector: eigen_vectors.row(i).to_a }
+			@total_eigenvalue += eigen_values[i,i]
+		end
+		@eigen.sort_by!{|v| -v[:value]}
+	end
+
+	def eigen
+		@eigen
+	end
+
+	def reduce(reducing_dimension=1)
+		factor_array = []
+		sum_eigenvalue = 0.0
+		reducing_dimension.times.each do |i|
+			factor_array << @eigen[i][:vector]#.map{|v| v * @eigen[i][:value] }
+			sum_eigenvalue += @eigen[i][:value]
+		end
+		factor = Matrix[ *factor_array ]
+		reduced_matrix = @entries * factor.t
+		distortion_rate = 1 - (sum_eigenvalue/@total_eigenvalue)
+		return reduced_matrix,distortion_rate
+	end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: principal-components-analysis
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ireullin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-02 00:00:00.000000000 Z
+dependencies: []
+description: A PCA algorithm for reducing dimension
+email:
+- ireullin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/enumerable_extension.rb
+- lib/matrix_extension.rb
+- lib/principal-components-analysis.rb
+homepage: https://github.com/ireullin/principal-components-analysis
+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: A PCA algorithm for reducing dimension
+test_files: []