brainy 2.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8bd9b3d723d372a31e94f3ae82400de2b04467fb
+  data.tar.gz: 2e20aff692a4e0566b58c0fcbc8b533f90b27a4c
+SHA512:
+  metadata.gz: 4c7962fbcedeadd153df7b02627dca1ca86759d3b13217ca0f6eb2507f0704e425e47d3978067ef882552bfecb414f557d9a6a73c33d0e87074a846e9d712e1a
+  data.tar.gz: f2574f3a69dc530d33f1b827b261f7626651a7f7dd97d91ade352ec49ac68b9ab2c7e6df0cfbf25bdd682c67fa3054f96d1ca32e36d8f0d65fedd482380771c2

data/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2016 Robert Scott Reis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# Brainy - An Artificial Neural Network [![Build Status](https://travis-ci.org/EvilScott/brainy.svg?branch=master)](https://travis-ci.org/EvilScott/brainy)
+
+Brainy is an [Artificial Neural Network (ANN)](https://en.wikipedia.org/wiki/Artificial_neural_network) using the 
+[Backpropagation](https://en.wikipedia.org/wiki/Backpropagation) algorithm. It was originally created as part of 
+the Neural NFL project [here](https://github.com/EvilScott/neuralnfl), but was broken out into a gem to be more reusable.
+
+_NOTE_: As of v2.0 Brainy is _JRuby only_. This decision was made for performance reasons, as it can now leverage the fast linear algebra functionality
+found in the [JBLAS](http://jblas.org/) Java library.
+
+### Usage
+From [examples/sin.rb](https://github.com/EvilScott/brainy/blob/master/examples/sin.rb):
+```ruby
+# Example using sin wave function
+require_relative '../lib/brainy'
+net = Brainy::Network.new(1, 3, 1, learning_rate: 1.0)
+
+# training
+4000.times do
+  i = rand(0..(Math::PI/2))
+  o = Math.sin(i)
+  net.train!([i], [o])
+end
+
+# testing
+mse = 1000.times.map do
+  i = rand(0..(Math::PI/2))
+  o = Math.sin(i)
+  (o - net.evaluate([i]).first) ** 2
+end.reduce(:+) / 1000
+
+puts "your MSE: #{ mse.round(6) }" # smaller is better
+```

data/lib/brainy/gaussian.rb

@@ -0,0 +1,11 @@
+module Brainy
+  java_import java.util.Random
+
+  class Gaussian
+    @rand = Random.new
+
+    def self.next
+      @rand.nextGaussian
+    end
+  end
+end

data/lib/brainy/jblas.rb

@@ -0,0 +1,66 @@
+module Brainy
+  java_import org.jblas.DoubleMatrix
+
+  class JMatrix
+    attr_accessor :java_matrix
+
+    def initialize(data)
+      if data.is_a?(DoubleMatrix)
+        @java_matrix = data
+      elsif data.first.is_a?(Array)
+        @java_matrix = DoubleMatrix.new(data.to_java(Java::double[]))
+      else
+        @java_matrix = DoubleMatrix.new(data.to_java(Java::double))
+      end
+    end
+
+    def self.build(row_count, column_count, &block) #TODO refactor for performance (!!!)
+      JMatrix.new(row_count.times.map do |row|
+        column_count.times.map { |col| block.yield(row, col) }
+      end)
+    end
+
+    def *(x)
+      if x.is_a? JMatrix
+        JMatrix.new(@java_matrix.mmul(x.java_matrix))
+      else
+        JMatrix.new(@java_matrix.mul(x))
+      end
+    end
+
+    def -(mat)
+      JMatrix.new(@java_matrix.sub(mat.java_matrix))
+    end
+
+    def to_a
+      return @java_matrix.getRow(0).toArray.to_a if rows == 1
+      return @java_matrix.getColumn(0).toArray.to_a if columns == 1
+      @java_matrix.rowsAsList.toArray.map { |row| row.toArray.to_a }
+    end
+
+    def row_vectors
+      @java_matrix.rowsAsList.toArray.map { |row| JMatrix.new(row) }
+    end
+
+    def rows
+      @java_matrix.rows
+    end
+
+    def columns
+      @java_matrix.columns
+    end
+
+    def map(&block)
+      return to_a.map { |a| a.to_a.map(&block) } if to_a.first.is_a?(Array)
+      to_a.map(&block)
+    end
+
+    def each_with_index(&block)
+      to_a.each_with_index(&block)
+    end
+
+    def [](idx)
+      @java_matrix.get(idx)
+    end
+  end
+end

data/lib/brainy/network.rb

@@ -0,0 +1,80 @@
+module Brainy
+  class Network
+    attr_accessor :layers
+
+    def initialize(input_count, hidden_count, output_count, options = {})
+      options = default_options.update(options)
+      @learning_rate = options[:learning_rate]
+      @momentum = options[:momentum]
+      @activate = options[:activate]
+      @activate_prime = options[:activate_prime]
+      @weight_init = options[:weight_init]
+      @layers = [
+          JMatrix.build(hidden_count, input_count + 1) { @weight_init.call },
+          JMatrix.build(output_count, hidden_count + 1) { @weight_init.call }
+      ]
+      @last_changes = []
+    end
+
+    def default_options
+      {
+          learning_rate: 0.25,
+          momentum: 0.9,
+          activate: lambda { |x| 1 / (1 + Math.exp(-1 * x)) },
+          activate_prime: lambda { |x| x * (1 - x) },
+          weight_init: lambda { Gaussian.next * 0.1 }
+      }
+    end
+
+    def evaluate(inputs)
+      @layers.reduce(inputs) do |input, layer|
+        (layer * JMatrix.new(input.to_a + [1.0])).map(&@activate)
+      end
+    end
+
+    def train!(inputs, expected)
+      inputs = JMatrix.new(inputs + [1.0])
+      hidden_outs = JMatrix.new((@layers.first * inputs).map(&@activate).to_a + [1.0])
+      output_outs = (@layers.last * hidden_outs).map(&@activate)
+      output_deltas = get_output_deltas(expected, output_outs)
+      hidden_deltas = get_hidden_deltas(hidden_outs, @layers.last, output_deltas)
+      changes = [get_weight_change(inputs, hidden_deltas), get_weight_change(hidden_outs, output_deltas)]
+      @layers.length.times do |idx|
+        @layers[idx] -= changes[idx]
+        @layers[idx] -= (@last_changes[idx] * @momentum) unless @last_changes[idx].nil?
+      end
+      @last_changes = changes
+    end
+
+    def get_output_deltas(expected, output)
+      expected.zip(output.to_a).map do |expect, out|
+        (out - expect) * @activate_prime.call(out)
+      end
+    end
+
+    def get_hidden_deltas(hidden_outs, output_nodes, output_deltas)
+      hidden_outs.to_a.slice(0...-1).each_with_index.map do |out, index|
+        output_nodes.row_vectors.zip(output_deltas)
+            .map { |weights, delta| weights[index] * delta }
+            .reduce(:+) * @activate_prime.call(out)
+      end
+    end
+
+    def get_weight_change(inputs, deltas)
+      JMatrix.build(deltas.count, inputs.to_a.count) do |row, col|
+        @learning_rate * deltas[row] * inputs[col]
+      end
+    end
+
+    def serialize
+      YAML.dump({ layers: layers.map(&:to_a) })
+    end
+
+    def self.from_serialized(dump, options = {})
+      layer_values = YAML.load(dump.class == File ? dump : File.open(dump))[:layers]
+      net = Network.new(1, 1, 1, options)
+      net.layers = layer_values.map { |vals| JMatrix.new(vals) }
+      net
+    end
+  end
+end

data/lib/brainy/version.rb

@@ -0,0 +1,3 @@
+module Brainy
+  VERSION = '2.0.1'
+end

data/lib/brainy.rb

@@ -0,0 +1,9 @@
+require 'yaml'
+require 'java'
+
+require_relative 'jar/jblas-1.2.4.jar'
+require_relative 'brainy/gaussian'
+require_relative 'brainy/jblas'
+require_relative 'brainy/network'
+
+module Brainy; end

data/spec/lib/brainy/gaussian_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../../spec_helper'
+
+module Brainy
+  describe Gaussian do
+    describe '.next' do
+      it 'returns a random number in the normal distribution' do
+        expect(Gaussian.next).to be_a Float
+      end
+    end
+
+  end
+end

data/spec/lib/brainy/jblas_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../spec_helper'
+
+module Brainy
+  describe JMatrix do
+    let (:mat_data) { [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] }
+    let (:vec_data) { [1.0, 2.0] }
+    let (:mat) { JMatrix.new(mat_data) }
+    let (:vec) { JMatrix.new(vec_data) }
+
+    describe '.build' do
+      it 'builds a new JMatrix' do
+        built_mat = JMatrix.build(3, 2) { 0 }
+        expect(built_mat).to be_a JMatrix
+        expect(built_mat.rows).to eq 3
+        expect(built_mat.columns).to eq 2
+      end
+    end
+
+    describe '#*' do
+      context 'when the second param is a matrix' do
+        it 'returns a new matrix from matrix multiplication' do
+          result = mat * vec
+          expect(result.to_a).to eq [5.0, 11.0, 17.0]
+        end
+      end
+      context 'when the second param is a scalar' do
+        it 'returns a new matrix from scalar multiplication' do
+          result = mat * 2.0
+          expect(result.to_a).to eq mat_data.map { |x| x.map { |y| y * 2.0 }}
+        end
+      end
+    end
+
+    describe '#-' do
+      it 'returns the difference between the two matrices' do
+        result = JMatrix.new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) - JMatrix.new([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]])
+        expect(result.to_a).to eq [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]
+      end
+    end
+
+    describe '#to_a' do
+      it 'returns the matrix data as an array' do
+        expect(mat.to_a).to eq mat_data
+        expect(vec.to_a).to eq vec_data
+        expect(JMatrix.new([[1.0], [2.0]]).to_a).to eq [1.0, 2.0]
+      end
+    end
+
+    describe '#row_vectors' do
+      it 'returns an array of row vectors' do
+        expect(mat.row_vectors.map(&:to_a)).to eq mat_data
+      end
+    end
+
+    describe '#[]' do
+      it 'returns the specified element of the matrix' do
+        expect(vec[0]).to eq 1.0
+        expect(JMatrix.new([[1.0], [2.0]])[0]).to eq 1.0
+      end
+    end
+  end
+end

data/spec/lib/brainy/network_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../spec_helper'
+
+module Brainy
+  describe Network do
+    let (:net) { Network.new(4, 3, 2) }
+
+    describe '#initialize' do
+      it 'creates a network with random weights' do
+        weights = net.layers.flatten.map(&:to_a).flatten
+        expect(weights.count).to eq weights.uniq.count
+      end
+    end
+
+    describe '#evaluate' do
+      it 'evaluates the network for a set of inputs' do
+        net.instance_variable_set(:@layers, [
+            JMatrix.new([
+                [0.1, 0.2, 0.3, 0.4, 0.5],
+                [0.5, 0.6, 0.7, 0.8, 0.9],
+                [0.9, 0.1, 0.2, 0.3, 0.4]
+            ]),
+            JMatrix.new([
+                [0.1, 0.2, 0.3, 0.4],
+                [0.4, 0.5, 0.6, 0.5]
+            ])
+        ])
+        out = net.evaluate([0.1, 0.3, 0.5, 0.7]).map { |x| x.round(6) }
+        expect(out).to eq [0.702451, 0.839256]
+      end
+    end
+
+    describe '#get_output_deltas' do
+      it 'provides deltas for the output layer' do
+        expected, output = [0.4, 0.6], [0.3, 0.8]
+        deltas = net.get_output_deltas(expected, output)
+        expect(deltas.map { |x| x.round(6) }).to eq [-0.021, 0.032]
+      end
+    end
+
+    describe '#get_hidden_deltas' do
+      it 'provides deltas for the hidden layer' do
+        hidden_outs, output_deltas = [0.9, 0.8, 0.7, 1.0], [0.6, 0.4]
+        output_nodes = JMatrix.new([[0.2, 0.3, 0.4], [0.4, 0.3, 0.2]])
+        deltas = net.get_hidden_deltas(hidden_outs, output_nodes, output_deltas)
+        expect(deltas.map { |x| x.round(6) }).to eq [0.0252, 0.048, 0.0672]
+      end
+    end
+
+    describe '#get_weight_change' do
+      it 'updates the hidden weights' do
+        inputs, deltas = [0.2, 0.3, 0.4, 0.5], [0.7, 0.6, 0.5]
+        change = net.get_weight_change(inputs, deltas)
+        expected = [
+            [0.035, 0.0525, 0.07, 0.0875],
+            [0.03, 0.045, 0.06, 0.075],
+            [0.025, 0.0375, 0.05, 0.0625],
+        ]
+        expect(change.map { |x| x.round(6) }).to eq expected
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'bundler/setup'
+Bundler.setup(:test)
+require_relative '../lib/brainy'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: brainy
+version: !ruby/object:Gem::Version
+  version: 2.0.1
+platform: java
+authors:
+- Robert Scott Reis
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+description: Brainy is an Artificial Neural Network (ANN) using the Backpropagation algorithm.
+email: reis.robert.s@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/brainy.rb
+- lib/brainy/gaussian.rb
+- lib/brainy/jblas.rb
+- lib/brainy/network.rb
+- lib/brainy/version.rb
+- lib/jar/jblas-1.2.4.jar
+- spec/lib/brainy/gaussian_spec.rb
+- spec/lib/brainy/jblas_spec.rb
+- spec/lib/brainy/network_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/EvilScott/brainy
+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.4.8
+signing_key:
+specification_version: 4
+summary: An Artificial Neural Network
+test_files: []