newral 0.1

data/lib/newral/training/gradient_descent.rb

@@ -0,0 +1,36 @@
+module Newral
+  module Training
+    class GradientDescent
+      attr_reader :best_function, :best_error, :input
+      def initialize( input: [], output: [], iterations:10**5, klass: Newral::Functions::Polynomial, klass_args: {}, start_function: nil   )
+        @input = input
+        @output = output
+        @iterations = iterations
+        @klass = klass
+        @klass_args = klass_args
+        @best_function = start_function
+      end
+
+
+      def process( start_fresh: false, learning_rate:0.01, step:0.01 )
+        @best_function = ( start_fresh ? @klass.create_random( @klass_args ) : @best_function || @klass.create_random( @klass_args )).dup
+        @best_error = @best_function.calculate_error( input: @input, output: @output ) 
+        optimized_error =  0
+        @iterations.times do 
+            function = @best_function.dup.move_with_gradient( input: @input, output: @output, learning_rate: learning_rate, step: step )
+            optimized_error = function.calculate_error( input: @input, output: @output ) 
+            if optimized_error >= @best_error 
+              step = step/10 if step > 10**-8 # # slow down
+              learning_rate = learning_rate / 10 if learning_rate > 10**-8
+            else 
+              @best_function = function
+              best_error = optimized_error
+            end 
+        end 
+        @best_error = @best_function.calculate_error( input: @input, output: @output )
+        @best_function
+      end
+        
+    end 
+  end 
+end  

data/lib/newral/training/greedy.rb

@@ -0,0 +1,36 @@
+module Newral
+  module Training
+    class Greedy
+      attr_reader :best_function, :best_error, :input
+      def initialize( input: [], output: [], iterations:10**5, klass: Newral::Functions::Polynomial, klass_args: {}, start_function: nil   )
+        @input = input
+        @output = output
+        @iterations = iterations
+        @klass = klass
+        @klass_args = klass_args
+        @best_function = start_function
+      end
+
+
+      def process( start_fresh: false )
+        @best_function = case 
+          when start_fresh then @klass.create_random( @klass_args ) 
+          when  @best_function then @best_function
+        else 
+           @klass.create_random( @klass_args )
+        end
+        @best_error = @best_function.calculate_error( input: @input, output: @output )
+        @iterations.times do |i|
+          function = @best_function.dup.move_random # move random is easier to implement with different function types
+          error = function.calculate_error( input: @input, output: @output )
+          if error < @best_error
+            @best_error = error 
+            @best_function = function
+          end 
+        end 
+        @best_function
+      end
+        
+    end 
+  end 
+end  

data/lib/newral/training/hill_climbing.rb

@@ -0,0 +1,77 @@
+module Newral
+  module Training
+    class HillClimbing
+      attr_reader :best_function, :best_error, :input, :needed_iterations
+      def initialize( input: [], output: [], iterations:10**5, klass: Newral::Functions::Polynomial, klass_args: {}, start_function: nil  )
+        @input = input
+        @output = output
+        @iterations = iterations
+        @klass = klass
+        @klass_args = klass_args
+        @best_function = start_function
+        @needed_iterations = 0
+      end
+
+
+      def process( start_fresh: false, max_error:0.01 )
+        @best_function = case 
+          when start_fresh then @klass.create_random( @klass_args ) 
+          when  @best_function then @best_function
+        else 
+           @klass.create_random( @klass_args )
+        end
+        
+        function = @best_function.dup.move_random( @klass_args )
+        @best_error = @best_function.calculate_error( input: @input, output: @output )
+        number_of_directions = @best_function.number_of_directions
+        step_sizes = [1]*number_of_directions
+        acceleration = 1.2
+        candidates = [
+          -acceleration,
+          -1/acceleration,
+          0,
+          1/acceleration,
+          acceleration
+        ]
+        i=0 
+        best_local_function = @best_function.dup
+        before_error = 99999
+        after_error = 1
+        moved = true
+        while i<@iterations  && @best_error > max_error 
+          moved = false
+          before_error = function.calculate_error( input: @input, output: @output )
+          number_of_directions.times do |direction|
+            best_candidate = -1
+            best_candidate_error = 9999999
+            candidates.each do |candidate| 
+              temp_function = function.dup.move( direction: direction, step: step_sizes[ direction ]*candidate)
+              error = temp_function.calculate_error( input: @input, output: @output )
+              if error < best_candidate_error
+                best_candidate = candidate
+                best_candidate_error = error
+                if error < @best_error
+                  @best_error = best_candidate_error
+                  @best_function = temp_function.dup
+                end
+              end 
+            end
+            if best_candidate == 0
+              step_sizes[direction] = step_sizes[direction] / acceleration # take it slower
+            else
+              moved = true
+              function.move( direction: direction, step: step_sizes[ direction ]*best_candidate )
+              # puts "moving #{direction} by #{(step_sizes[ direction ]*candidates[best_candidate]).to_s}"
+              step_sizes[direction] = step_sizes[ direction ] * best_candidate # accelerate
+            end
+          end
+          after_error = function.calculate_error( input: @input, output: @output )
+          i=i+1
+        end
+        @needed_iterations = i 
+        @best_function
+      end
+        
+    end 
+  end 
+end  

data/lib/newral/training/linear_regression.rb

@@ -0,0 +1,30 @@
+module Newral
+  module Training
+    class LinearRegression
+      #https://viblo.asia/p/machine-learning-algorithms-from-scratch-with-ruby-linear-regression-RnB5p1aYKPG
+      attr_reader :best_function, :best_error, :input
+      def initialize( input: [], output: [] )
+        @input = input
+        @output = output
+      end
+
+
+      def process(  )
+        input_mean=Newral::Tools.mean @input
+        output_mean =Newral::Tools.mean @output
+        dividend =0
+        divisor = 0
+        @input.each_with_index do |input,idx|
+         dividend = dividend+(input-input_mean)*( @output[idx]-output_mean)
+         divisor = divisor+(input-input_mean)**2 
+        end 
+        multiplier = dividend/divisor
+        error = output_mean-multiplier*input_mean
+        @best_function = Newral::Functions::Polynomial.new(factors: [multiplier,error])
+        @best_error =@best_function.calculate_error( input: @input, output: @output )
+        @best_function
+      end
+        
+    end 
+  end 
+end  

data/lib/newral/training/linear_regression_matrix.rb

@@ -0,0 +1,32 @@
+module Newral
+  module Training
+    class LinearRegressionMatrix
+      #https://stackoverflow.com/questions/24747643/3d-linear-regression
+      attr_reader :best_function, :best_error, :input
+      def initialize( input: [], output: [] )
+        @input = input
+        @output = output
+      end
+
+
+      def process(  )
+        # @input = [[6 ,4 ,11],[  8 ,5 ,15],[  12, 9, 25],[ 2, 1, 3]]
+        # @output = [20,30,50,7]
+        array = @input.collect do |input| 
+           [1]+input
+        end
+        matrix = Matrix.rows array
+        result = (( matrix.transpose*matrix ).inverse*(matrix.transpose)).to_a
+        
+        weights = result.collect do |r|
+          r.size.times.inject(0) { |sum,i| sum = sum + r[i] * @output[i] }
+        end
+        bias = weights[0]
+        @best_function = Newral::Functions::Vector.new vector: weights[1..weights.length-1], bias: bias 
+        @best_error =@best_function.calculate_error( input: @input, output: @output )
+        @best_function
+      end
+        
+    end 
+  end 
+end  

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: newral
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- stefan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: nmatrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: " Neuralnet for newbies "
+email:
+- stefan.nothegger@gmx.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/newral.rb
+- lib/newral/bayes.rb
+- lib/newral/classifier/dendogram.rb
+- lib/newral/classifier/k_means_cluster.rb
+- lib/newral/classifier/node.rb
+- lib/newral/classifier/node_distance.rb
+- lib/newral/data/base.rb
+- lib/newral/data/cluster.rb
+- lib/newral/data/cluster_set.rb
+- lib/newral/data/csv.rb
+- lib/newral/data/idx.rb
+- lib/newral/error_calculation.rb
+- lib/newral/functions/base.rb
+- lib/newral/functions/block.rb
+- lib/newral/functions/gaussian.rb
+- lib/newral/functions/line.rb
+- lib/newral/functions/polynomial.rb
+- lib/newral/functions/radial_basis_function_network.rb
+- lib/newral/functions/ricker_wavelet.rb
+- lib/newral/functions/vector.rb
+- lib/newral/genetic/tree.rb
+- lib/newral/graphs/a_star.rb
+- lib/newral/graphs/cheapest_first.rb
+- lib/newral/graphs/edge.rb
+- lib/newral/graphs/graph.rb
+- lib/newral/graphs/node.rb
+- lib/newral/graphs/path.rb
+- lib/newral/graphs/tree_search.rb
+- lib/newral/networks/backpropagation_network.rb
+- lib/newral/networks/layer.rb
+- lib/newral/networks/network.rb
+- lib/newral/networks/perceptron.rb
+- lib/newral/networks/sigmoid.rb
+- lib/newral/probability.rb
+- lib/newral/probability_set.rb
+- lib/newral/q_learning/base.rb
+- lib/newral/tools.rb
+- lib/newral/training/gradient_descent.rb
+- lib/newral/training/greedy.rb
+- lib/newral/training/hill_climbing.rb
+- lib/newral/training/linear_regression.rb
+- lib/newral/training/linear_regression_matrix.rb
+homepage: https://github.com/ExistsAndIs1/newral
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Basic Neuralnet
+test_files: []