newral 0.1

data/lib/newral/classifier/k_means_cluster.rb

@@ -0,0 +1,45 @@
+module Newral
+  
+    module Classifier
+          
+      class KMeansCluster 
+
+        # input array of points, cluster_labels: how many clusters to find, max_iterations stop after x approximations
+        # output hash of clusters where has keys are cluster_labels and value is points(Array) and center(point) 
+        def initialize( points, cluster_labels: [:a,:b], max_iterations: 20 )
+          @points = points
+          @cluster_labels = cluster_labels
+          @max_iterations = max_iterations
+        end 
+
+        def process 
+          @cluster_set = Newral::Data::ClusterSet.new( cluster_labels: @cluster_labels )
+          runs = 0
+          @points.sample( @cluster_set.cluster_array.length ).each_with_index do |point,idx|
+            @cluster_set.cluster_array[ idx ].center = point
+          end 
+    
+          while @cluster_set.cluster_array.collect{ |cluster| cluster.moved }.member?( true ) && runs < @max_iterations
+            @cluster_set.clusters.each do |key,cluster|
+              cluster.points=[] 
+            end
+     
+            # iterate over points assign, best cluster
+            @points.each do |point|
+              min_distance =  { cluster:'none', distance: 99**99 }
+              @cluster_set.clusters.each do |key,cluster|
+                distance = Newral::Tools::euclidian_distance( cluster.center, point )
+                min_distance = {cluster: cluster, distance: distance } if distance < min_distance[:distance]
+              end
+              min_distance[:cluster].add_point point
+            end
+            @cluster_set.update_centers
+            runs=runs+1
+          end
+          @cluster_set
+        end 
+
+      end
+
+    end
+  end 

data/lib/newral/classifier/node.rb

@@ -0,0 +1,58 @@
+module Newral
+  
+    module Classifier
+      
+   
+      class Node 
+  
+        attr_writer :parent_node 
+        attr_accessor :center
+        attr_reader :sub_nodes
+        def initialize( sub_nodes, from_point: false )
+          if from_point
+            @sub_nodes = [Vector.elements( sub_nodes )]
+            @center = Vector.elements sub_nodes 
+          else 
+            @sub_nodes = sub_nodes
+            @center = Vector.elements( [0]*sub_nodes.first.center.size )
+            sub_nodes.each do |node|
+              @center = @center + node.center
+            end
+            @center = @center/@sub_nodes.size.to_f
+            @sub_nodes.each do |node|
+              node.parent_node = self 
+            end
+          end
+          @parent_node = nil
+         
+        end
+  
+        def to_s
+          if @sub_nodes.size == 1
+            @sub_nodes.first.to_s
+          else
+            "=>(#{@sub_nodes.collect{|node| node.to_s }.join(',')})"
+          end
+        end
+  
+        def flatten_points
+           @sub_nodes.collect do |node|
+            if !node.kind_of?( Node )
+              [node]
+            elsif node.sub_nodes.size == 1 
+              node.center 
+            else
+              node.flatten_points
+            end
+          end.flatten
+        end 
+  
+        def to_cluster 
+          points = flatten_points
+          Data::Cluster.new( points: points.collect{|p| p.to_a } )
+        end
+  
+  
+    end 
+  end 
+end

data/lib/newral/classifier/node_distance.rb

@@ -0,0 +1,19 @@
+module Newral
+  
+    module Classifier
+      class NodeDistance 
+        attr_reader :node1, :node2, :distance
+        def initialize( node1, node2 )
+          @node1 = node1 
+          @node2 = node2 
+          @distance = Newral::Tools.euclidian_distance( node1.center, node2.center )
+        end
+
+        def <=>( other )
+          self.distance <=> other.distance
+        end 
+
+      end
+    end
+
+end 

data/lib/newral/data/base.rb

@@ -0,0 +1,153 @@
+module Newral
+  module Data 
+    module Errors
+      class InputOutputSizeMismatch < ::StandardError; end 
+      class WrongPointDimension < ::StandardError; end 
+      class UnknownValue < ::StandardError; end 
+      class UnknownSet < ::StandardError; end 
+      class UnknownCategory < ::StandardError; end 
+      class DownSamplingImpossible < ::StandardError; end 
+    end
+
+    class Base
+      attr_accessor :outputs, :labels, :inputs
+      def initialize( inputs: [], outputs: [], labels:[] )
+        @inputs = inputs
+        @outputs = outputs
+        @labels = labels
+        raise Errors::InputOutputSizeMismatch unless @inputs.size == @outputs.size
+      end 
+
+      def add_input( input, output: nil, label:nil )
+        @labels << label
+        @outputs << output
+        @inputs << input
+      end
+
+      def sub_set( set: :inputs, category: :all )
+        data = case set
+          when :inputs then @inputs
+          when :outputs then @outputs 
+          else
+            raise Errors::UnknownSet
+          end 
+        
+        case category
+          when :all then data 
+          when :training then data[0..(data.size.to_f*0.7).to_i]
+          when :validation then  data[(data.size.to_f*0.7).to_i+1..(data.size.to_f*0.8).to_i ]
+          when :testing then  data[(data.size.to_f*0.8).to_i+1,data.size ]
+        else
+          raise Errors::UnknownCategory, category.to_s
+        end
+      end 
+
+      def values_for( searched_value, only_first: false, return_objects: [], search_objects: [] )
+        results = []
+        search_objects.each_with_index do |each_value,idx|
+          if only_first 
+            return return_objects[idx] if searched_value == each_value || [searched_value] == each_value
+          else 
+            results << return_objects[idx] if searched_value == each_value || [searched_value] == each_value
+          end
+        end
+        results unless only_first
+      end 
+
+      def output_for_input( input )
+        values_for input, search_objects: @inputs, return_objects: @outputs, only_first:  true 
+      end
+
+      def label_for_input( input )
+        values_for input, search_objects: @inputs, return_objects: @labels, only_first:  true
+      end
+
+      def inputs_for_output( output )
+        values_for output, search_objects: @outputs, return_objects: @inputs
+      end
+
+      def normalized_inputs(normalized_high: 1, normalized_low:-1 )
+        return [] if @inputs.size == 0 || !@inputs.first.kind_of?( Array )
+        max_values = [Float::MIN]*@inputs.first.size
+        min_values = [Float::MAX]*@inputs.first.size
+        @inputs.each do |input|
+          input.each_with_index do |value,idx|
+            max_values[idx] = value.to_f if value > max_values[idx]
+            min_values[idx] = value.to_f if value < min_values[idx]
+          end
+        end
+        @inputs.collect do |input|
+          row = [0]*input.size
+          input.each_with_index do |value,idx|
+            row[idx] = (value-min_values[idx])/(max_values[idx]-min_values[idx]).to_f*(normalized_high-normalized_low)+normalized_low
+          end
+          row 
+        end
+      end
+      
+      def output_hash( normalized_high: 1, normalized_low:-1 )
+        @output_hash = @outputs.inject({}) do |hash,output|
+          hash[output] = ( hash[output] || 0 )+1
+          hash
+        end 
+        new_hash = {}
+        @output_hash.keys.sort.each_with_index do |key,idx|
+          new_hash[ key ] = normalized_low+((normalized_high.to_f-normalized_low)*idx)/( [@output_hash.keys.length-1,1].max )
+        end 
+        @output_hash = new_hash
+      end 
+
+      def output_normalized
+         hash = output_hash
+         @outputs.collect{ |k| hash[k]}
+      end
+      
+      # this will make it easier to use outputs for neura networks
+      # as it translates them to vectors like [1,0,0]
+      # if you have 3 possible outputs this will return [1,0,0],[0,1,0],[0,0,1]
+      def output_as_vector( category: :all )
+        hash = output_hash
+        sub_set( set: :outputs, category: category ).collect do  |k| 
+          vector = [0]*output_hash.keys.size
+          vector[ output_hash.keys.index( k ) ] = 1 # output_hash.keys 
+          vector
+        end 
+      end 
+        
+      def count_outputs
+        output_hash = {}
+        @outputs.each do |output| 
+          output_key = output.size == 1 ? output.first.to_s.to_sym : output.join('-')
+          output_hash[output_key] = (output_hash[output_key] || 0) + 1
+        end
+        output_hash 
+      end
+
+      def sample( offset:0,limit:100 )
+        Base.new( inputs:  @inputs[offset..limit+offset] , outputs: @outputs[offset..limit+offset] )
+      end 
+
+      def downsample_input!( height:1, width: 1, width_of_line: nil )
+        raise DownSamplingImpossible unless @inputs.first.size % ( width*height ) == 0
+        total_height = @inputs.first.size/width_of_line
+        
+        @inputs.collect! do |input| 
+          downsampled = []
+          pos = 0
+          while pos < input.size do 
+            matrix = []
+            height.times do |h|
+              start_pos = pos+(width_of_line*h)
+              end_pos = pos+width+(width_of_line)*h-1
+              matrix = matrix+input[start_pos..end_pos]
+            end 
+            downsampled << (  matrix.inject(0){|sum,e| sum+e }/matrix.length.to_f > 0.5 ? 1 : 0 )
+            pos = pos+width
+            pos=pos+width_of_line*(height-1) if (pos%width_of_line) == 0
+          end
+          downsampled 
+        end 
+      end 
+    end
+  end 
+end

data/lib/newral/data/cluster.rb

@@ -0,0 +1,37 @@
+module Newral
+  module Data 
+    class Cluster
+      attr_accessor :label, :points, :center, :moved
+      def initialize( label: nil, points: [], center: nil, moved: true )
+        @label = label
+        @points = points
+        @point_size = points.size > 0 ? points.first.size : 1
+        @moved = moved # did center move when updating it
+        @center = center
+      end 
+
+      def add_point( point )
+        if @points.size == 0
+          @point_size = point.size
+          @center ||= point
+        else
+          # all points must be of same dimension
+          raise Errors::WrongPointDimension unless point.size == @point_size 
+        end
+        @points << point 
+        self
+      end 
+
+      def update_center
+        return unless @points.size > 0
+        new_center = Vector.elements( [0]*points.first.size )
+        @points.each do |point| 
+          new_center = new_center + Vector.elements( point )
+        end 
+        new_center = ( new_center/@points.size.to_f).to_a
+        @moved = new_center != @center
+        @center = new_center
+      end 
+    end
+  end
+end

data/lib/newral/data/cluster_set.rb

@@ -0,0 +1,38 @@
+module Newral
+  module Data 
+    class ClusterSet
+      attr_accessor :clusters
+      def initialize( cluster_labels: [], clusters: nil )
+        if clusters 
+          idx = 0
+          @clusters = clusters.inject({}){ |h,cluster| cluster.label = "cluster_#{ idx }";h[cluster.label] = cluster;idx=idx+1; h }
+        else 
+          @clusters = cluster_labels.inject({}){ |h,label| h[label] = Cluster.new(label: label); h }
+        end
+      end 
+
+      def []( label )
+        label.kind_of?(String) || label.kind_of?(Symbol)  ? @clusters[ label ] : cluster_array[ label ]
+      end 
+
+      def cluster_array
+        @clusters.values
+      end
+
+      def update_centers
+        @clusters.each do |key,cluster| 
+          cluster.update_center
+        end 
+      end
+
+      def clusters_count
+        @clusters.inject({}) do |h,cluster|
+          h[cluster[0]] = cluster[1].points.size
+          h 
+        end 
+      end
+
+
+    end
+  end
+end

data/lib/newral/data/csv.rb

@@ -0,0 +1,23 @@
+module Newral
+  module Data 
+    require "CSV"
+    require "open-uri"
+    class Csv < Base
+      def initialize( file_name: nil, output_fields: 1 )
+        @file_name = file_name
+        @output_fields = output_fields
+        super( inputs: [], outputs: [])
+      end 
+
+      def process
+        open( @file_name ) do |file|
+          file.each_line do |line|
+            input = CSV.parse_line( line ).collect{ |field| field.match(/^\d*\.?\d+$/) ? field.to_f : field }
+            add_input( input.slice(0,input.size-1-@output_fields), output: input.slice(input.size-@output_fields, input.size ))
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/newral/data/idx.rb

@@ -0,0 +1,48 @@
+module Newral
+  module Data
+    require "open-uri"
+    module Errors 
+      class UnexpectedEOF < StandardError; end 
+      class EOFExpected < StandardError; end 
+      class LabelsNotMatchingItems < StandardError; end 
+    end 
+
+    class Idx < Base
+      # http://yann.lecun.com/exdb/mnist/
+      # used for Handwritten Images
+      def initialize( file_name: nil, label_file_name: nil )
+        @file_name = file_name
+        @label_file_name = label_file_name
+        super( inputs: [], outputs: [])
+      end 
+
+      def process
+        number_of_items = 0
+        open( @file_name, 'rb' ) do |file|
+          magic,number_of_items = file.read(8).unpack("NN")
+          width,height = file.read(8).unpack("NN")
+          number_of_items.times do 
+            raise Errors::UnexpectedEOF if file.eof?
+            image = file.read(width*height).unpack("C"*width*height)
+            @inputs << image 
+          end 
+          raise Errors::EOFExpected unless file.eof?
+        end
+
+        open( @label_file_name, 'rb' ) do |file|
+          magic,number_of_labels = file.read(8).unpack("NN")
+          raise Errors::LabelsNotMatchingItems unless number_of_labels==number_of_items
+          number_of_items.times do 
+            raise Errors::UnexpectedEOF,"#{ @outputs.size } vs. #{ number_of_labels }" if file.eof?
+            label = file.read(1).unpack("c").first
+            @outputs << label 
+          end 
+          raise Errors::EOFExpected,"#{ @outputs.size } #{file.read.size}" unless file.eof?
+        end
+
+
+      end
+    
+    end
+  end
+end#

data/lib/newral/error_calculation.rb

@@ -0,0 +1,28 @@
+module Newral
+  module ErrorCalculation
+   class DimensionsNotMatching < StandardError ; end 
+    def self.sum_of_squares( results, expected )
+      sum = 0
+      raise DimensionsNotMatching, "results: #{ results.size } expected: #{ expected.size }" unless expected.size == results.size 
+      results.each_with_index do |result,idx|
+        Array(result).each_with_index do |r,r_idx|
+          exp = Array(expected[idx])
+          sum = sum+(r-exp[r_idx])**2
+        end
+      end
+      sum
+    end 
+
+    def self.root_mean_square( results, expected )
+      sum = sum_of_squares( results, expected )
+      (sum.to_f/results.size)**0.5
+    end 
+
+    def self.mean_square( results, expected )
+      sum = sum_of_squares( results, expected )
+      sum.to_f/results.size
+    end
+    
+    
+  end
+end