rb-brain 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c16b832f4b21365c93b698c01c14fbea54eb2e74
-  data.tar.gz: e65a2a8c1c76c8b83c00972184942d02fbbeefa3
+  metadata.gz: f43371c0a74e1690e8814ae7230dd12d6d0f1be0
+  data.tar.gz: ea374d2706bd4d54466201eb805c842d7478ba2d
 SHA512:
-  metadata.gz: cabeba60da560694cb1343f0c0f384533e563ea4f829838783a5cea8ac30c81cf487e0cc2faede4d832ae6e1ea8da3156eca6b4dd7da66c9b29ae2c5be7d6a4f
-  data.tar.gz: 80aab9ccc24424d6b1763c985ff693f81e09b6c41aa1d613d4dc46f431b438d8ce83a4468d78da67df16a5b75858c14747b67e0132b4ccc34df8de3438fab9f7
+  metadata.gz: 7c7e8ee3b5d5b07b99b5c6e972201487188f33f173a3b48025d317975602abe931163e05f1ee5ffef2327e8dd24019fb09c1609edf8dd049ca84fe69891b1a32
+  data.tar.gz: 86600d5d1c10f1e5fc796a19aaee8ee3019ea7040f0649b8a2930d0018d3b11c4b132920e92e0ed7be301222e7a32becfc1287df4ec3c2e0666a846118d3d0a3

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in carrierwave-webdav.gemspec
 gemspec
+gem 'rake'
+gem 'rspec'
+gem 'pry'
+gem 'hashr'

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    rb-brain (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    hashr (0.0.22)
+    method_source (0.8.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  hashr
+  pry
+  rake
+  rb-brain!
+  rspec

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/brain/neuralnetwork.rb

@@ -1,4 +1,7 @@
 require 'brain/lookup'
+require 'json'
+require 'pry'
+require 'hashr'
 
 module Brain
   class NeuralNetwork
@@ -187,6 +190,89 @@ module Brain
       data
     end
 
+    def to_json
+      # make json look like:
+      # {
+      #   layers: [
+      #     { x: {},
+      #       y: {}},
+      #     {'0': {bias: -0.98771313, weights: {x: 0.8374838, y: 1.245858},
+      #      '1': {bias: 3.48192004, weights: {x: 1.7825821, y: -2.67899}}},
+      #     { f: {bias: 0.27205739, weights: {'0': 1.3161821, '1': 2.00436}}}
+      #   ]
+      # }
+      layers = []
+      (0..@output_layer).each do |layer|
+        layers[layer] = {}
+
+        if layer == 0 and @input_lookup
+          nodes = @input_lookup.keys
+        elsif layer == @output_layer and @output_lookup
+          nodes = @output_lookup.keys
+        else
+          nodes = (0...@sizes[layer]).to_a
+        end
+
+        (0...nodes.length).each do |j|
+          node = nodes[j]
+          layers[layer][node] = {}
+
+          if layer > 0
+            layers[layer][node][:bias] = @biases[layer][j]
+            layers[layer][node][:weights] = {}
+            layers[layer - 1].each do |k,v|
+              index = k
+              if layer == 1 and @input_lookup
+                index = @input_lookup[k]
+              end
+              layers[layer][node][:weights][k] = @weights[layer][j][index]
+            end
+          end
+        end
+      end
+
+      {
+        layers: layers,
+        output_lookup: !!@output_lookup,
+        input_lookup: !!@input_lookup
+      }.to_json
+    end
+
+    def from_json(json)
+      json = JSON.parse(json).deep_symbolize_keys
+      size = json[:layers].length
+
+
+      @output_layer = size - 1
+      @sizes = Array.new size
+      @weights = Array.new size
+      @biases = Array.new size
+      @outputs = Array.new size
+
+      (0..@output_layer).each do |i|
+        layer = json[:layers][i]
+        if i == 0 and (!layer[0] or json[:input_lookup])
+          @input_lookup = Lookup.lookup_from_hash layer
+        elsif i == @output_layer and (!layer[0] or json[:output_lookup])
+          @output_lookup = Lookup.lookup_from_hash layer
+        end
+
+        nodes = layer.keys
+        @sizes[i] = nodes.length
+        @weights[i] = []
+        @biases[i] = []
+        @outputs[i] = []
+
+        (0...nodes.length).each do |j|
+
+          node = nodes[j]
+          @biases[i][j] = layer[node][:bias]
+          @weights[i][j] = layer[node][:weights]
+          @weights[i][j] = @weights[i][j].values unless @weights[i][j].nil?
+        end
+      end
+    end
+
   private
     def random_weight
       Random.rand * 0.4 - 0.2

data/rb-brain.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = "rb-brain"
-  gem.version       = "0.0.1"
+  gem.version       = "0.1.0"
   gem.authors       = ["Eric Zhang"]
   gem.email         = ["i@qinix.com"]
   gem.description   = %q{rb-brain is an easy-to-use neural network written in ruby}

data/spec/lib/bitwise_spec.rb

@@ -0,0 +1,31 @@
+describe 'bitwase functions' do
+  it 'NOT function' do
+    data_not = [{input: [0], output: [1]},
+           {input: [1], output: [0]}]
+    test_bitwise data_not, 'not'
+  end
+
+  it 'XOR function' do
+    data_xor = [{input: [0, 0], output: [0]},
+           {input: [0, 1], output: [1]},
+           {input: [1, 0], output: [1]},
+           {input: [1, 1], output: [0]}]
+    test_bitwise data_xor, 'xor'
+  end
+
+  it 'OR function' do
+    data_or = [{input: [0, 0], output: [0]},
+          {input: [0, 1], output: [1]},
+          {input: [1, 0], output: [1]},
+          {input: [1, 1], output: [1]}]
+    test_bitwise data_or, 'or'
+  end
+
+  it 'AND function' do
+    data_and = [{input: [0, 0], output: [0]},
+           {input: [0, 1], output: [0]},
+           {input: [1, 0], output: [0]},
+           {input: [1, 1], output: [1]}]
+    test_bitwise data_and, 'and'
+  end
+end

data/spec/lib/hash_spec.rb

@@ -0,0 +1,70 @@
+describe 'hash input and output' do
+  before :each do
+    @net = Brain::NeuralNetwork.new
+  end
+
+  it 'runs correctly with array input and output' do
+    @net.train([{input: { x: 0, y: 0 }, output: [0]},
+                      {input: { x: 0, y: 1 }, output: [1]},
+                      {input: { x: 1, y: 0 }, output: [1]},
+                      {input: { x: 1, y: 1 }, output: [0]}])
+    output = @net.run({x: 1, y: 0})
+
+    expect(output[0]).to be > 0.9
+  end
+
+  it 'runs correctly with hash input' do
+    @net.train([{input: { x: 0, y: 0 }, output: [0]},
+               {input: { x: 0, y: 1 }, output: [1]},
+               {input: { x: 1, y: 0 }, output: [1]},
+               {input: { x: 1, y: 1 }, output: [0]}])
+    output = @net.run({x: 1, y: 0})
+
+    expect(output[0]).to be > 0.9
+  end
+
+  it 'runs correctly with hash output' do
+    @net.train([{input: [0, 0], output: { answer: 0 }},
+               {input: [0, 1], output: { answer: 1 }},
+               {input: [1, 0], output: { answer: 1 }},
+               {input: [1, 1], output: { answer: 0 }}])
+
+    output = @net.run([1, 0])
+
+    expect(output[:answer]).to be > 0.9
+  end
+
+  it 'runs correctly with hash input and output' do
+    @net.train([{input: { x: 0, y: 0 }, output: { answer: 0 }},
+               {input: { x: 0, y: 1 }, output: { answer: 1 }},
+               {input: { x: 1, y: 0 }, output: { answer: 1 }},
+               {input: { x: 1, y: 1 }, output: { answer: 0 }}])
+
+    output = @net.run({x: 1, y: 0})
+
+    expect(output[:answer]).to be > 0.9
+  end
+
+  it 'runs correctly with sparse hashes' do
+      @net.train([{input: {}, output: {}},
+                 {input: { y: 1 }, output: { answer: 1 }},
+                 {input: { x: 1 }, output: { answer: 1 }},
+                 {input: { x: 1, y: 1 }, output: {}}])
+
+
+      output = @net.run({x: 1})
+
+      expect(output[:answer]).to be > 0.9
+  end
+
+  it 'runs correctly with unseen input' do
+      @net.train([{input: {}, output: {}},
+                 {input: { y: 1 }, output: { answer: 1 }},
+                 {input: { x: 1 }, output: { answer: 1 }},
+                 {input: { x: 1, y: 1 }, output: {}}])
+
+      output = @net.run({x: 1, z: 1})
+
+      expect(output[:answer]).to be > 0.9
+  end
+end

data/spec/lib/json_spec.rb

@@ -0,0 +1,21 @@
+describe 'JSON' do
+  it 'to_json()/from_json()' do
+    net = Brain::NeuralNetwork.new
+
+    net.train([{input:  {a: Random.rand, b: Random.rand},
+                output: {c: Random.rand, a: Random.rand}},
+               {input:  {a: Random.rand, b: Random.rand},
+                output: {c: Random.rand, a: Random.rand}}])
+
+    json = net.to_json()
+    net2 = Brain::NeuralNetwork.new
+    net2.from_json json
+
+    input = {a: Random.rand, b: Random.rand}
+
+    output1 = net.run(input)
+    output2 = net2.run(input)
+
+    expect(output1).to eq output2
+  end
+end

data/spec/lib/lookup_spec.rb

@@ -0,0 +1,32 @@
+describe 'Lookup' do
+  it 'lookup_from_hash()' do
+    lup = Brain::Lookup.lookup_from_hash({ a: 6, b: 7, c: 8 })
+
+    expect(lup).to eq({ a: 0, b: 1, c: 2})
+  end
+
+  it 'build_lookup()' do
+    lup = Brain::Lookup.build_lookup([{ x: 0, y: 0 },
+                               { x: 1, z: 0 },
+                               { q: 0 },
+                               { x: 1, y: 1 }])
+
+    expect(lup).to eq({ x: 0, y: 1, z: 2, q: 3 })
+  end
+
+  it 'to_array()' do
+    lup = { a: 0, b: 1, c: 2 }
+
+    array = Brain::Lookup.to_array(lup, { b: 8, notinlookup: 9 })
+
+    expect(array).to eq([0, 8, 0])
+  end
+
+  it 'to_hash()' do
+    lup = { b: 1, a: 0, c: 2 }
+
+    hash = Brain::Lookup.to_hash(lup, [0, 9, 8])
+
+    expect(hash).to eq({a: 0, b: 9, c: 8})
+  end
+end

data/spec/lib/options_spec.rb

@@ -0,0 +1,83 @@
+require 'json'
+require 'hashr'
+
+describe 'neural network options' do
+  it 'hiddenLayers' do
+    net = Brain::NeuralNetwork.new({ hidden_layers: [8, 7] })
+
+    net.train([{input: [0, 0], output: [0]},
+               {input: [0, 1], output: [1]},
+               {input: [1, 0], output: [1]},
+               {input: [1, 1], output: [0]}])
+
+    json = net.to_json
+    json = JSON.parse json
+    json.deep_symbolize_keys!
+
+    expect(json[:layers].length).to eq(4)
+    expect(json[:layers][1].length).to eq(8)
+    expect(json[:layers][2].length).to eq(7)
+  end
+
+  it 'hiddenLayers default expand to input size' do
+    net = Brain::NeuralNetwork.new()
+
+    net.train([{input: [0, 0, 1, 1, 1, 1, 1, 1, 1], output: [0]},
+               {input: [0, 1, 1, 1, 1, 1, 1, 1, 1], output: [1]},
+               {input: [1, 0, 1, 1, 1, 1, 1, 1, 1], output: [1]},
+               {input: [1, 1, 1, 1, 1, 1, 1, 1, 1], output: [0]}])
+
+    json = net.to_json
+    json = JSON.parse json
+    json.deep_symbolize_keys!
+
+    expect(json[:layers].length).to eq(3)
+    expect(json[:layers][1].length).to eq(4)
+  end
+
+
+  it 'learning_rate - higher learning rate should train faster' do
+    data = [{input: [0, 0], output: [0]},
+            {input: [0, 1], output: [1]},
+            {input: [1, 0], output: [1]},
+            {input: [1, 1], output: [1]}]
+
+    net1 = Brain::NeuralNetwork.new()
+    iters1 = net1.train(data, learning_rate: 0.5)[:iterations]
+
+    net2 = Brain::NeuralNetwork.new()
+    iters2 = net2.train(data, learning_rate: 0.8)[:iterations]
+
+    expect(iters1).to be > (iters2 * 1.1)
+  end
+
+  it 'learning_rate - backwards compatibility' do
+    data = [{input: [0, 0], output: [0]},
+            {input: [0, 1], output: [1]},
+            {input: [1, 0], output: [1]},
+            {input: [1, 1], output: [1]}]
+
+    net1 = Brain::NeuralNetwork.new(learning_rate: 0.5)
+    iters1 = net1.train(data)[:iterations]
+
+    net2 = Brain::NeuralNetwork.new(learning_rate: 0.8)
+    iters2 = net2.train(data)[:iterations]
+
+    expect(iters1).to be > (iters2 * 1.1)
+  end
+
+  it 'momentum - higher momentum should train faster' do
+    data = [{input: [0, 0], output: [0]},
+            {input: [0, 1], output: [1]},
+            {input: [1, 0], output: [1]},
+            {input: [1, 1], output: [1]}]
+
+    net1 = Brain::NeuralNetwork.new(momentum: 0.1)
+    iters1 = net1.train(data)[:iterations]
+
+    net2 = Brain::NeuralNetwork.new(momentum: 0.5)
+    iters2 = net2.train(data)[:iterations]
+
+    expect(iters1).to be > (iters2 * 1.1)
+  end
+end

data/spec/lib/trainopts_spec.rb

@@ -0,0 +1,26 @@
+data = [{input: [0, 0], output: [0]},
+        {input: [0, 1], output: [1]},
+        {input: [1, 0], output: [1]},
+        {input: [1, 1], output: [1]}]
+
+describe 'train() options' do
+  before :each do
+    @net = Brain::NeuralNetwork.new
+  end
+
+  it 'train until error threshold reached' do
+    error = @net.train(data,
+      errorThresh: 0.2,
+      iterations: 100000)[:error]
+
+    expect(error).to be < 0.2
+  end
+
+  it 'train until max iterations reached' do
+    stats = @net.train(data,
+      errorThresh: 0.001,
+      iterations: 1)
+
+    expect(stats[:iterations]).to eq(1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+
+Dir['spec/supports/**/*.rb'].each { |f| require File.expand_path(f) }
+
+require 'brain'
+
+RSpec.configure do |config|
+  config.include Helpers
+end
+

data/spec/supports/helpers.rb

@@ -0,0 +1,14 @@
+module Helpers
+  def test_bitwise(data, op)
+    wiggle = 0.1
+
+    net = Brain::NeuralNetwork.new
+    net.train(data, error_thresh: 0.003)
+
+    data.each do |item|
+      output = net.run(item[:input])
+      target = item[:output]
+      expect(output[0]).to be_within(wiggle).of(target[0])
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb-brain
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Eric Zhang
@@ -17,13 +17,24 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
+- Rakefile
 - lib/brain.rb
 - lib/brain/lookup.rb
 - lib/brain/neuralnetwork.rb
 - rb-brain.gemspec
+- spec/lib/bitwise_spec.rb
+- spec/lib/hash_spec.rb
+- spec/lib/json_spec.rb
+- spec/lib/lookup_spec.rb
+- spec/lib/options_spec.rb
+- spec/lib/trainopts_spec.rb
+- spec/spec_helper.rb
+- spec/supports/helpers.rb
 homepage: https://github.com/qinix/rb-brain
 licenses:
 - MIT
@@ -48,4 +59,12 @@ rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: rb-brain is an easy-to-use neural network written in ruby
-test_files: []
+test_files:
+- spec/lib/bitwise_spec.rb
+- spec/lib/hash_spec.rb
+- spec/lib/json_spec.rb
+- spec/lib/lookup_spec.rb
+- spec/lib/options_spec.rb
+- spec/lib/trainopts_spec.rb
+- spec/spec_helper.rb
+- spec/supports/helpers.rb