callidus 1.0.67

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7e8348b821e13ceed061213ebf3f311f32c52853
+  data.tar.gz: b9231b12ef42ef76f52129149c367d724d4280cf
+SHA512:
+  metadata.gz: 46ac0cbdd0e5bf0f50475505a6ed89c60537ac0bfa9879872238ac269e460bebe6347e194c694f044d5aac371add9cfc28dba2f16d5787fec4704c03ed1d6834
+  data.tar.gz: 075e233a7eb2c697aea13d7966a548dcd8d310220d7db2d743d611658020e74c11ee488a15184cb3679799119be5d917af9839ba8355de90d2594a52b5379916

data/lib/callidus.rb

@@ -0,0 +1,3 @@
+require_relative "./src/KNN.rb"
+require_relative "./src/LinearRegression.rb"
+require_relative "./src/Winnow.rb"

data/lib/src/KNN.rb

@@ -0,0 +1,28 @@
+require_relative "../util/Comp"
+
+module Callidus
+    class KNN
+        attr_accessor :input
+        attr_accessor :output
+
+        def initialize(ip = [], op = [])
+            @input = ip
+            @output = op
+        end
+
+        def predict(x, k = 1)
+            diffs = @input.map { |i| Math.sqrt(x.each_with_index.map { |val, ind| (i[ind] - val) ** 2 }.sum) }
+            tdiffs = diffs.dup
+
+            mins = []
+
+            k.times do |i|
+                ind = tdiffs.index(tdiffs.min)
+                mins << tdiffs[ind]
+                tdiffs.pop(ind)
+            end
+
+            return @output[diffs.index(Comp::Arrays.MostFrequent(mins))];
+        end
+    end
+end

data/lib/src/LinearRegression.rb

@@ -0,0 +1,97 @@
+require_relative "../util/Util"
+
+module Callidus
+    class LinearRegression
+        attr_accessor :input
+        attr_accessor :output
+        attr_accessor :predicted_output
+
+        attr_reader :slope
+        attr_reader :y_intercept
+
+        attr_reader :correlation
+        attr_reader :standard_error
+
+        def initialize(ip = [], op = [])
+            @input = ip
+            @output = op
+
+            @trained = false
+        end
+
+        private def assert_trained(method = "train")
+            if !@trained
+                raise Util::UntrainedError.new("LinearRegression")
+            end
+        end
+
+        def formatted
+            assert_trained()
+
+            "f(x) = #{@slope}x + #{@y_intercept}"
+        end
+
+        def train
+            sum_x = 0
+            sum_y = 0
+            sum_xy = 0
+            sum_xx = 0
+
+            n = @input.size > @output.size ? @output.size : @input.size
+
+            @predicted_output = []
+
+            n.times do |i|
+                x = @input[i]
+                y = @output[i]
+
+                sum_x += x
+                sum_y += y
+                sum_xx += (x * x)
+                sum_xy += (x * y)
+            end
+
+            @slope = ((n * sum_xy - sum_x * sum_y).to_f / (n * sum_xx - sum_x * sum_x).to_f).round(3)
+            @y_intercept = ((sum_y / n).to_f - (@slope * sum_x).to_f / n.to_f).round(3)
+
+            @predicted_output = @input.map { |x| (x * @slope + @y_intercept).round(3) }
+
+            @trained = true
+
+            self.find_correlation.find_standard_error
+        end
+
+        def find_correlation
+            assert_trained()
+
+            mean = @output.sum/@output.size
+
+            diffYM = @output.map { |y| (y - mean) ** 2 };
+            diffPYM = @predicted_output.map { |y| (y - mean) ** 2 };
+
+            @correlation = (diffPYM.sum/diffYM.sum).round(3)
+
+            self
+        end
+
+        def find_standard_error
+            assert_trained()
+
+            n = @input.size > @output.size ? @output.size : @input.size
+
+            diffs = []
+
+            n.times do |i|
+                diffs << (@predicted_output[i] - @output[i]) ** 2
+            end
+
+            @standard_error = (Math.sqrt(diffs.sum/(n - 2.0))).round(3)
+
+            self
+        end
+
+        def predict(x)
+            x * @slope + @y_intercept
+        end
+    end
+end

data/lib/src/Winnow.rb

@@ -0,0 +1,64 @@
+require_relative "../util/Util"
+
+module Callidus
+    class Winnow
+        attr_accessor :input
+        attr_accessor :output
+
+        attr_accessor :a
+        attr_accessor :mode
+
+        attr_reader :weights
+
+        def initialize(ip = [], op = [], options = {})
+            @input = ip
+            @output = op
+
+            @default_weight = options[:default_weight] || 1
+            @a = options[:a] || 2;
+            @mode = options[:mode] || 0 # 0 is demote, 1 is reset
+
+            @weights = []
+            @trained = false
+        end
+
+        private def assert_trained(method = "train")
+            if !@trained
+                raise Util::UntrainedError.new("Winnow")
+            end
+        end
+
+        def train(a = @a)
+            if (@input[0] and @input[0].size != @weights.size)
+                @weights = Array.new(@input[0].size, @default_weight)
+            end
+    
+            @input.each_index do |i|
+                @input[i].each_index do |j|
+                    if @input[i][j] == 1
+                        @weights[j] *= @output[i] == 0 ? (@mode == 0 ? 1 / a : 0) : a
+                    end
+                end
+            end
+    
+            @trained = true
+    
+            return self
+        end
+
+        def predict(x, options = {})
+            assert_trained()
+
+            bias = options[:bias] || 0
+            threshold = options[:threshold] || (@input.size / 2).to_i
+    
+            probability = 0;
+    
+            x.each_index do |i|
+                probability += @weights[i] * x[i] + bias
+            end
+    
+            return (probability > threshold ? 1 : 0)
+        end
+    end
+end

data/lib/util/Comp.rb

@@ -0,0 +1,53 @@
+class ::Array
+    def sum
+        s = 0
+
+        self.each do |i|
+            s += i
+        end
+
+        s
+    end
+
+    def max
+        m = self[0]
+
+        self.each do |i|
+            if i > m
+                m = i
+            end
+        end
+
+        m
+    end
+
+    def min
+        m = self[0]
+
+        self.each do |i|
+            if i < m
+                m = i
+            end
+        end
+    
+        m
+    end
+end
+
+module Comp
+    class Arrays
+        def self.MostFrequent(arr)
+            freqs = {}
+
+            arr.each do |i|
+                if freqs.has_key?(i)
+                    freqs[i] = freqs[i] + 1
+                else
+                    freqs[i] = 1
+                end
+            end
+            
+            arr[freqs.values.index(freqs.values.max)];
+        end
+    end
+end

data/lib/util/Util.rb

@@ -0,0 +1,7 @@
+module Util
+    class UntrainedError < StandardError
+        def initialize(modelType, method = "train")
+            super("Model must be trained (hint: Call the `" + method + "` method of your " + modelType + " instance)")
+        end
+    end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: callidus
+version: !ruby/object:Gem::Version
+  version: 1.0.67
+platform: ruby
+authors:
+- Hayden Higginbotham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-21 00:00:00.000000000 Z
+dependencies: []
+description: A collection of machine learning algorithms implemented in a very simple,
+  concise, and easy-to-use way.
+email: hayden@higg.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/callidus.rb
+- lib/src/KNN.rb
+- lib/src/LinearRegression.rb
+- lib/src/Winnow.rb
+- lib/util/Comp.rb
+- lib/util/Util.rb
+homepage: https://github.com/haydenhigg/Callidus
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://github.com/haydenhigg/Callidus#Callidus
+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: Callidus
+test_files: []