deep_miner 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c89c1b6c7bb8dc9f353433f7118270561f7e6c2
+  data.tar.gz: fa1136b9eb30bfe93bdf07f644caa6cf45e188f8
+SHA512:
+  metadata.gz: 43f6750f420ef9983b15f415219390bec7f75a74e483350702124ffe3b3d98205e2ef278ac00bf8b9950268469354cdf619fcffda8f4bd390b8cea0b7706da95
+  data.tar.gz: 5468d263c5877b1b6f1273e29964a7e1144978e678b26f5d6da051bea679e47bdcdd5359b269db840ce41615cdc85afc5536ef1e07911fa9d63822857d7bdb4b

data/lib/deep_miner.rb

@@ -0,0 +1,6 @@
+require "deep_miner/version"
+require_relative "deep_miner/vector_matrix"
+require_relative "deep_miner/perceptron"
+
+module DeepMiner
+end

data/lib/deep_miner/perceptron.rb

@@ -0,0 +1,175 @@
+module DeepMiner
+  # ajcost
+  #
+  # Perceptron is class that implements a single layer neural net
+  # Implemenation is made with vertex_matrix class
+  class Perceptron
+    attr_reader :input, :hidden, :output
+    attr_reader :weight_matrix_ih, :weight_matrix_ho
+    attr_reader :output_delta_v, :hidden_delta_v
+    attr_reader :change_matrix_i, :change_matrix_o
+    attr_reader :out_delta, :hidden_delta
+
+    def initialize(input, hidden, output)
+      fail ArgumentError, 'Input must be Array' unless input.is_a? Array
+      fail ArgumentError, 'Output must be Array' unless output.is_a? Array
+      @input = input
+      @hidden = hidden
+      @output = output
+      # Create activation vectors and weight matrices and change matrices
+      init_activations
+      init_weight_matrices
+      init_change_matrices
+    end
+
+    def predict(input_vector)
+      fail ArgumentError, 'Input vector must be Array' unless input_vector.is_a? Array
+      fail ArgumentError, 'Predict input must be same size as input' unless input_vector.size == @input.size
+      # Set activation vector for the input layer
+      @act_input.apply_new_matrix([] << input_vector)
+
+      # Calculate activation vector for the hidden layer
+      calculate_activation_hidden
+
+      # Calculate activation vector for the output layer
+      calculate_activation_output
+    end
+
+    def back_propogate(target, eta, momentum)
+      fail ArgumentError, 'Target must be Array' unless target.is_a? Array
+      fail ArgumentError, 'Target and Output must have same size' unless target.size == @output.size
+      # Calculate errors for output layer
+      errors_output(target)
+
+      # Calculate errors for hidden layer
+      errors_hidden
+
+      # Update weight vector from hidden to outputs
+      update_output_weight_vector(eta, momentum)
+
+      # Update weight vector from inputs to hidden
+      update_hidden_weight_vector(eta, momentum)
+
+      calculate_error(target)
+    end
+
+    # Train the network with training input, expectations, input, and epoch num
+    def train(train_data, expect, epoch_iter = 50, eta, m)
+      fail ArgumentError, 'Training must be Array' unless train_data.is_a? Array
+      fail ArgumentError, 'Expectation must be Array' unless expect.is_a? Array
+      fail ArgumentError, 'Data and Expectation must be same size' unless train_data.size == expect.size
+
+      1.upto(epoch_iter) do
+        error = 0.0
+        train_data.zip(expect) do |sample, target|
+          predict(sample)
+          error += back_propogate(target, eta, m)
+        end
+      end
+    end
+
+    private
+
+    def calculate_activation_hidden
+      for j in 0..@hidden - 1
+        sum = 0.0
+        for i in 0..input.size - 1
+          sum += @act_input.get_value(0, j) * @weight_matrix_ih.get_value(j, i)
+        end
+        @act_hidden.set_value(0, j, tanh_sigmoid(sum))
+      end
+    end
+
+    def calculate_activation_output
+      for k in 0..@output.size - 1
+        sum = 0.0
+        for j in 0..@hidden - 1
+          sum += @act_hidden.get_value(0, j) * @weight_matrix_ho.get_value(j, k)
+        end
+        @act_output.set_value(0, k, tanh_sigmoid(sum))
+      end
+      @act_output.to_array
+    end
+
+    def calculate_error(target)
+      error = 0.0
+      0.upto(target.size - 1) do |k|
+        error += 0.5 * (target[k] - @act_output.get_value(0, k))**2
+      end
+      error
+    end
+
+    def errors_output(target)
+      @out_delta = Array.new(@output.size, 0.0)
+      0.upto(@output.size - 1) do |k|
+        act_val = @act_output.get_value(0, k)
+        error = target[k] - act_val
+        @out_delta[k] = dx_tanh_sigmoid(act_val) * error
+      end
+    end
+
+    def errors_hidden
+      @hidden_delta = Array.new(@hidden, 0.0)
+      0.upto(@hidden - 1) do |i|
+        error = 0.0
+        0.upto(@output.size - 1) do |j|
+          error += @out_delta[j] * @weight_matrix_ho.get_value(i, j)
+        end
+        @hidden_delta[i] = dx_tanh_sigmoid(@act_hidden.get_value(0, i)) * error
+      end
+    end
+
+    def update_output_weight_vector(eta, momentum)
+      0.upto(@hidden - 1) do |j|
+        0.upto(@output.size - 1) do |k|
+          delta = @out_delta[k] * @act_hidden.get_value(0, j)
+          value = delta * eta + momentum * @change_matrix_o.get_value(j, k)
+          @weight_matrix_ho.add_value(j, k, value)
+          @change_matrix_o.set_value(j, k, delta)
+        end
+      end
+    end
+
+    def update_hidden_weight_vector(eta, momentum)
+      0.upto(@input.size - 1) do |i|
+        0.upto(@hidden - 1) do |j|
+          delta = hidden_delta[j] * @act_input.get_value(0, i)
+          value = delta * eta + momentum * @change_matrix_i.get_value(i, j)
+          @weight_matrix_ih.add_value(i, j, value)
+          @change_matrix_i.set_value(i, j, delta)
+        end
+      end
+    end
+
+    def init_activations
+      ins = [1.0] * @input.size
+      hids = [1.0] * @hidden.size
+      outs = [1.0] * @output.size
+      @act_input = VectorMatrix.new(nil, nil, nil, [] << ins)
+      @act_hidden = VectorMatrix.new(nil, nil, nil, [] << hids)
+      @act_output = VectorMatrix.new(nil, nil, nil, [] << outs)
+    end
+
+    def init_weight_matrices
+      @weight_matrix_ih = VectorMatrix.new(input.size, hidden, 0.1)
+      @weight_matrix_ho = VectorMatrix.new(hidden, output.size, 1.0)
+    end
+
+    def init_change_matrices
+      changei = Array.new(@input.size) { Array.new(@hidden, rand(-0.2..0.2)) }
+      changeo = Array.new(@hidden) { Array.new(@output.size, rand(-0.2..0.2)) }
+      @change_matrix_i = VectorMatrix.objectify(changei)
+      @change_matrix_o = VectorMatrix.objectify(changeo)
+    end
+
+    # Computes the sigmoid function
+    def tanh_sigmoid(x)
+      Math.tanh(x)
+    end
+
+    # Computes the derivative of the sigmoid
+    def dx_tanh_sigmoid(x)
+      1.0 - x**2
+    end
+  end
+end

data/lib/deep_miner/vector_matrix.rb

@@ -0,0 +1,240 @@
+module DeepMiner
+  class VectorMatrix
+    attr_reader :matrix, :n, :m, :random
+
+    def initialize(n, m, random, matrix = nil)
+      if matrix.nil?
+        @n = n
+        @m = m
+        @random = random
+        initialize_h
+      else
+        simple_init(matrix)
+      end
+    end
+
+    # General Operations
+
+    def self.objectify(new_matrix)
+      fail ArgumentError, 'Input must be Array' unless new_matrix.is_a? Array
+      VectorMatrix.new(nil, nil, nil, new_matrix)
+    end
+
+    def apply_value(x)
+      @matrix = Array.new(@n) { Array.new(@m, x) }
+    end
+
+    def apply_new_matrix(x)
+      fail ArgumentError, 'Input must be Array' unless x.is_a? Array
+      @matrix = x
+      @n = @matrix.size
+      @m = @matrix[0].size
+      @random = nil
+    end
+
+    def to_array
+      @matrix
+    end
+
+    def set_value(i, j, x)
+      fail ArgumentError, 'Values cannot be nil' if i.nil? || j.nil? || x.nil?
+      fail ArgumentError, 'Indices must be in matrix bounds' if i < 0 || j < 0 || i > @n || j > @m
+      @matrix[i][j] = x
+    end
+
+    def add_value(i, j, x)
+      fail ArgumentError, 'Values cannot be nil' if i.nil? || j.nil? || x.nil?
+      fail ArgumentError, 'Indices must be in matrix bounds' if i < 0 || j < 0 || i > @n || j > @m
+      @matrix[i][j] += x
+    end
+
+    def get_value(i, j)
+      fail ArgumentError, 'Indices must be in matrix bounds' if i < 0 || j < 0 || i > @n || j > @m
+      @matrix[i][j]
+    end
+
+    def get_row(index, objectify = false)
+      fail ArgumentError, 'Index must be in matrix bounds' if index < 0 || index > @n - 1
+      return VectorMatrix.new(nil, nil, nil, [] << @matrix[index]) if objectify
+      @matrix[index]
+    end
+
+    def get_column(index, objectify = false)
+      fail ArgumentError, 'Index must be in matrix bounds' if index < 0 || index > @m - 1
+      column = []
+      0.upto(@n - 1) do |i|
+        column << @matrix[i][index]
+      end
+      return VectorMatrix.new(nil, nil, nil, [] << column) if objectify
+      column
+    end
+
+    def get_diagonal(objectify = false)
+      diagonal = []
+      0.upto(@n - 1) do |i|
+        0.upto(@m - 1) do |j|
+          diagonal << @matrix[i][j] if i == j
+        end
+      end
+      return VectorMatrix.new(nil, nil, nil, [] << diagonal) if objectify
+      diagonal
+    end
+
+    def see_i_vector_size
+      @matrix.size
+    end
+
+    def see_j_vector_size
+      return 0 if self.see_i_vector_size == 0
+      @matrix[0].size
+    end
+
+    # Matrix Specific Operations
+
+    def self.identity(n, objectify = false)
+      fail ArgumentError, 'N must have a size greater than 0' if n <= 0
+      new_matrix = Array.new(n) { Array.new(n) }
+      0.upto(n - 1) do |i|
+        0.upto(n - 1) do |j|
+          if i == j
+            new_matrix[i][j] = 1
+          else
+            new_matrix[i][j] = 0
+          end
+        end
+      end
+      return VectorMatrix.new(n, n, nil, new_matrix) if objectify
+      new_matrix
+    end
+
+    def trace
+      diagonal = get_diagonal(false)
+      sum = 0.0
+      0.upto(diagonal.size - 1) do |i|
+        sum += diagonal[i]
+      end
+      sum
+    end
+
+    def transpose(objectify = false)
+      transposed = []
+      0.upto(@m - 1) do |i|
+        transposed << get_column(i)
+      end
+      return VectorMatrix.new(nil, nil, nil, transposed) if objectify
+      transposed
+    end
+
+    # Matrix Mathematical Operations
+
+    # Scalar Product
+    def scale(scale_val, objectify = false)
+      scaled = Array.new(@n) { Array.new(@m) }
+      0.upto(@n - 1) do |i|
+        0.upto(@m - 1) do |j|
+          scaled[i][j] = scale_val * @matrix[i][j]
+        end
+      end
+      return VectorMatrix.new(nil, nil, nil, scaled) if objectify
+      scaled
+    end
+
+
+    # Add
+    def add(o_matrix, objectify, not_objectified = true)
+      fail ArgumentError, 'Input matrix must be of type Array' if not_objectified and !o_matrix.is_a? Array
+      o_matrix = VectorMatrix.objectify(o_matrix) if not_objectified
+      added = Array.new(@n) { Array.new(@m) }
+      0.upto(@n - 1) do |i|
+        0.upto(@m - 1) do |j|
+          added[i][j] = @matrix[i][j] + o_matrix.get_value(i, j)
+        end
+      end
+      return VectorMatrix.new(nil, nil, nil, added) if objectify
+      added
+    end
+
+    # Subtract
+    def subtract(o_matrix, objectify, not_objectified = true)
+      fail ArgumentError, 'Input matrix must be of type Array' if not_objectified and !o_matrix.is_a? Array
+      o_matrix = VectorMatrix.objectify(o_matrix) if not_objectified
+      subtracted = Array.new(@n) { Array.new(@m) }
+      0.upto(@n - 1) do |i|
+        0.upto(@m - 1) do |j|
+          subtracted[i][j] = @matrix[i][j] - o_matrix.get_value(i, j)
+        end
+      end
+      return VectorMatrix.new(nil, nil, nil, subtracted) if objectify
+      subtracted
+    end
+
+    # Multiply
+    def multiply(o_matrix, objectify, not_objectified = true)
+      fail ArgumentError, 'Input matrix must be of type Array' if not_objectified and !o_matrix.is_a? Array
+      o_matrix = VectorMatrix.objectify(o_matrix) if not_objectified
+      fail ArgumentError, 'Illegal matrix multiplication dimensions' if @m != o_matrix.see_j_vector_size
+      multiplied = multiply_h(o_matrix)
+      return VectorMatrix.new(nil, nil, nil, multiplied) if objectify
+      multiplied
+    end
+
+    # Matrix Qualities
+
+    def diagonal?
+      0.upto(@n - 1) do |i|
+        0.upto(@m - 1) do |j|
+          return false if (@matrix[i][j].nil? || @matrix[i][j] != 0.0) && i != j
+        end
+      end
+      true
+    end
+
+    def empty?
+      return true if @matrix.size == 0
+      0.upto(@n - 1) do |i|
+        0.upto(@m - 1) do |j|
+          return false unless @matrix[i][j].nil?
+        end
+      end
+      true
+    end
+
+    def square?
+      @n == @m
+    end
+
+    private
+
+    def initialize_h
+      @matrix = Array.new(@n) { Array.new(@m) }
+      for i in 0..@n - 1
+        for j in 0..@m - 1
+          if !@random.nil?
+            @matrix[i][j] = 1.0 * rand(-@random...@random)
+          else
+            @matrix[i][j] = 1.0
+          end
+        end
+      end
+    end
+
+    def simple_init(matrix)
+      @n = matrix.size
+      @m = matrix[0].size
+      @matrix = matrix
+      @random = nil
+    end
+
+    def multiply_h(o_matrix)
+      multiplied = Array.new(@n) { Array.new(@m, 0.0) }
+      0.upto(@n - 1) do |i|
+        0.upto(o_matrix.see_j_vector_size - 1) do |j|
+          0.upto(@m - 1) do |k|
+            multiplied[i][j] += @matrix[i][k] * o_matrix.get_value(k, j)
+          end
+        end
+      end
+      multiplied
+    end
+  end
+end

data/lib/deep_miner/version.rb

@@ -0,0 +1,3 @@
+module DeepMiner
+  VERSION = "0.1.1"
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: deep_miner
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- ajcost
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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'
+description: A library allowing for implementation of neural networks in Ruby
+email:
+- acost@sas.upenn.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/deep_miner.rb
+- lib/deep_miner/perceptron.rb
+- lib/deep_miner/vector_matrix.rb
+- lib/deep_miner/version.rb
+homepage: https://github.com/ajcost/deep_miner
+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.8
+signing_key: 
+specification_version: 4
+summary: Neural Network Library
+test_files: []