synaptical 0.0.1.pre.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2eb79f8db08a2545b01bee1be288ba3f3b0887cf5dab92abbff912dee9206726
+  data.tar.gz: ffc9a05fff7c76dfbf8e5c1d4c5b24d5b238320ae23fa5ef885da1c0e56ce336
+SHA512:
+  metadata.gz: 4d60328ad93e877c08df009a8057b87085119d234db531fdb43e82ef58be77305bb6d9620bc4a2dc9c33e2bdc61416fb5d7c2fc8bb2658d65b1a3aaa8e2b0b29
+  data.tar.gz: 98c8d2cc964b1f2ba6f396c00b711227230fa03669dbe8083334f70ce0ba7dd09ca2141e54c931685514a183b0ca8fc73b1e58aef947cc8c4ad47004b58a5e10

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.ruby-gemset

@@ -0,0 +1 @@
+synaptical

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.3

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in synaptical.gemspec
+gemspec
+
+group :development do
+  gem 'benchmark-ips'
+  gem 'benchmark-memory'
+  gem 'hotch'
+end

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    synaptical (0.0.1.pre.beta1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    allocation_tracer (0.6.3)
+    benchmark-ips (2.7.2)
+    benchmark-memory (0.1.2)
+      memory_profiler (~> 0.9)
+    diff-lcs (1.3)
+    hotch (0.5.0)
+      allocation_tracer (~> 0.6.3)
+      stackprof (~> 0.2.10)
+    memory_profiler (0.9.11)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    stackprof (0.2.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  benchmark-ips
+  benchmark-memory
+  bundler (~> 1.16)
+  hotch
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  synaptical!
+
+BUNDLED WITH
+   1.16.3

data/README.md

@@ -0,0 +1,101 @@
+# Synaptical
+
+Synaptical is a Ruby port of [synaptic.js](https://github.com/cazala/synaptic)
+
+**NOTE: This is work in progress and some componets of synaptic.js are still missing**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'synaptical'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install synaptical
+
+## Usage
+
+Usage is identical to [synaptic.js](https://github.com/cazala/synaptic).
+
+Example network trained to solve a XOR gate:
+
+```ruby
+input_layer = Synaptical::Layer.new(2)
+hidden_layer = Synaptical::Layer.new(3)
+output_layer = Synaptical::Layer.new(1)
+
+input_layer.project(hidden_layer)
+hidden_layer.project(output_layer)
+
+network = Synaptical::Network.new(
+  input: input_layer,
+  hidden: [hidden_layer],
+  output: output_layer
+)
+
+learning_rate = 0.3
+
+10_000.times do
+  network.activate([0, 0])
+  network.propagate(learning_rate, [0])
+
+  network.activate([0, 1])
+  network.propagate(learning_rate, [1])
+
+  network.activate([1, 0])
+  network.propagate(learning_rate, [1])
+
+  network.activate([1, 1])
+  network.propagate(learning_rate, [0])
+end
+
+network.activate([0, 0])
+  # => [0.00020797967275049887]
+network.activate([0, 1])
+  # => [0.9991989909682668]
+network.activate([1, 0])
+  # => [0.9992882541963027]
+network.activate([1, 1])
+  # => [0.0011764423621223423]
+```
+
+or create the network with the Perceptron architect and the Trainer:
+
+```ruby
+
+network = Synaptical::Architect::Perceptron.new(2, 3, 1)
+trainer = Synaptical::Trainer.new(network)
+trainer.train([
+  { input: [0, 0], output: [0] },
+  { input: [0, 1], output: [1] },
+  { input: [1, 0], output: [1] },
+  { input: [1, 1], output: [0] }
+])
+
+network.activate([0, 0])
+  # => [0.04564830744951351]
+network.activate([0, 1])
+  # => [0.9590894310802323]
+network.activate([1, 0])
+  # => [0.9112358846059638]
+network.activate([1, 1])
+  # => [0.0832359653922508]
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wallin/synaptical.

data/Rakefile

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'synaptical'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+def create_network
+  input_layer = Synaptical::Layer.new(2)
+  hidden_layer = Synaptical::Layer.new(3)
+  output_layer = Synaptical::Layer.new(1)
+
+  input_layer.project(hidden_layer)
+  hidden_layer.project(output_layer)
+
+  Synaptical::Network.new(
+    input: input_layer, hidden: [hidden_layer], output: output_layer
+  )
+end
+
+def train(network)
+  learning_rate = 0.3
+
+  network.activate([0, 0])
+  network.propagate(learning_rate, [0])
+
+  network.activate([0, 1])
+  network.propagate(learning_rate, [1])
+
+  network.activate([1, 0])
+  network.propagate(learning_rate, [1])
+
+  network.activate([1, 1])
+  network.propagate(learning_rate, [0])
+end
+
+def activate(network)
+  network.activate([rand(2), rand(2)])
+end
+
+task :benchmark do
+  require 'benchmark/ips'
+  require 'benchmark/memory'
+
+  network = create_network
+
+  train = lambda do |x|
+    x.report('training') { train(network) }
+    x.compare!
+  end
+
+  activate = lambda do |x|
+    x.report('activate') { activate(network) }
+    x.compare!
+  end
+
+  Benchmark.ips(&train)
+  Benchmark.memory(&train)
+  Benchmark.ips(&activate)
+  Benchmark.memory(&activate)
+end
+
+namespace :profile do
+  require 'hotch'
+  require 'hotch/memory'
+
+  task :training do
+    network = create_network
+    Hotch() do
+      10_000.times do
+        train(network)
+      end
+    end
+
+    Hotch.memory do
+      10_000.times do
+        train(network)
+      end
+    end
+  end
+
+  task :activate do
+    network = create_network
+    10_000.times { train(network) }
+    Hotch() do
+      10_000.times { activate(network) }
+    end
+
+    Hotch.memory do
+      10_000.times { activate(network) }
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'synaptical'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/synaptical.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+%w[
+  synaptical/squash/logistic
+  synaptical/squash/tanh
+  synaptical/connection
+  synaptical/layer
+  synaptical/layer_connection
+  synaptical/network
+  synaptical/neuron
+  synaptical/trainer
+  synaptical/version
+  synaptical/architect/perceptron
+  synaptical/cost/mse
+  synaptical/serializer/json
+].each(&method(:require))
+
+module Synaptical; end

data/lib/synaptical/architect/perceptron.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Synaptical
+  module Architect
+    class Perceptron < Network
+      # Creates a new perceptron network
+      # @param *layers [Integer] Each integer in the args represent a layer of that size
+      #
+      # @return [Synaptical::Network] The created network
+      def initialize(*layers)
+        raise ArgumentError, 'not enough layers (minimum 3)' if layers.size < 3
+
+        input = Synaptical::Layer.new(layers.shift)
+        output = Synaptical::Layer.new(layers.pop)
+        previous = input
+        hidden = layers.map do |size|
+          Synaptical::Layer.new(size).tap do |layer|
+            previous.project(layer)
+            previous = layer
+          end
+        end
+        previous.project(output)
+
+        super(
+          input: input,
+          hidden: hidden,
+          output: output
+        )
+      end
+    end
+  end
+end

data/lib/synaptical/connection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Synaptical
+  # Representation of a connection between two neurons
+  class Connection
+    attr_reader :id, :from, :to, :gain, :gater
+    attr_accessor :weight
+
+    # Creates a connection between two neurons
+    # @param from [Synaptical::Neuron] First neuron
+    # @param to [Synaptical::Neuron] Second neuron
+    # @param weight = nil [Float] connection weight
+    def initialize(from, to, weight = nil)
+      @id = self.class.uid
+      @from = from
+      @to = to
+      @weight = weight.nil? ? (rand * 0.2 - 0.1) : weight
+      @gain = 1.0
+    end
+
+    class << self
+      attr_reader :connections
+
+      def uid
+        @connections += 1
+      end
+    end
+
+    @connections = 0
+  end
+end

data/lib/synaptical/cost/mse.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Synaptical
+  module Cost
+    # Mean square error
+    module Mse
+      class << self
+        # Calculates mean square error for a series of results
+        # @param target [Array<Numeric>] Desired values
+        # @param output [Array<Numeric>] Output values from prediction
+        #
+        # @return [Float] Combined mean square error
+        def call(target, output)
+          mse = 0.0
+          target.zip(output).each { |t, o| mse += (t - o)**2 }
+          mse.fdiv(output.size)
+        end
+      end
+    end
+  end
+end

data/lib/synaptical/layer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Synaptical
+  # Representation of a layer in a network
+  class Layer
+    CONNECTION_TYPE = {
+      ALL_TO_ALL: 'ALL TO ALL',
+      ONE_TO_ONE: 'ONE TO ONE',
+      ALL_TO_ELSE: 'ALL TO ELSE'
+    }.freeze
+
+    GATE_TYPE = {
+      INPUT: 'INPUT',
+      OUTPUT: 'OUTPUT',
+      ONE_TO_ONE: 'ONE TO ONE'
+    }.freeze
+
+    attr_reader :list, :connected_to, :size
+
+    # Creates a new layer with a given size
+    # @param size [Integer] Size of layer
+    def initialize(size)
+      @size = size
+      @connected_to = []
+      @list = Array.new(size).map { Synaptical::Neuron.new }
+    end
+
+    # Activates the neurons in the layer
+    # @param input [Array<Numeric>] Array of inputs with same size as the layer
+    #
+    # @raise [ArgumentError] if input size mismatch layer size
+    #
+    # @return [Array<Numeric>] Array of output values with same size as the layer
+    def activate(input = nil)
+      if input.nil?
+        list.map(&:activate)
+      else
+        raise ArgumentError unless input.size == size
+        list.zip(input).map { |neuron, value| neuron.activate(value) }
+      end
+    end
+
+    # Propagates the error on all the neurons of the layer
+    # @param rate [Float] Learning rate
+    # @param target = nil [Array<Numeric>] Target value
+    #
+    # @raise [ArgumentError] if target size mismatch layer size
+    def propagate(rate, target = nil)
+      if target.nil?
+        list.each { |neuron| neuron.propagate(rate) }
+      else
+        raise ArgumentError unless target.size == size
+        list.zip(target).each { |neuron, value| neuron.propagate(rate, value) }
+      end
+    end
+
+    # Projects a connection from this layer to another one
+    # @param layer [Synaptical::Layer, Synaptical::Network] Network/Layer to project to
+    # @param type = nil [type] [description]
+    # @param weight = nil [type] [description]
+    #
+    # @raise [ArgumentError] if layer is already connected
+    def project(layer, type = nil, weight = nil)
+      layer = layer.layers.input if layer.is_a?(Network)
+
+      raise ArgumentError if connected(layer)
+
+      LayerConnection.new(self, layer, type, weight)
+    end
+
+    # Gates a connection between two layers
+    # @param conntection [LayerConnection] Layer connection
+    # @param type [type] [description]
+    def gate(_connection, _type)
+      raise 'TODO'
+    end
+
+    # Returns wether the whole layer is self-connected or not
+    #
+    # @return [Boolean] true if self-connected, false otherwise
+    def selfconnected?
+      list.all?(&:selfconnected?)
+    end
+
+    # Returns whether the layer is connected to another layer
+    # @param layer [Synaptical::Layer] Other layer
+    #
+    # @return [Boolean] true if connected to the other layer, false otherwise
+    def connected(layer)
+      # Check if ALL to ALL connection
+      connections = 0
+      list.each do |from|
+        layer.list.each do |to|
+          connected = from.connected(to)
+          connections += 1 if connected&.type == :projected
+        end
+      end
+
+      return Layer::CONNECTION_TYPE[:ALL_TO_ALL] if connections == size * layer.size
+
+      # Check if ONE to ONE connection
+      connections = 0
+      list.each_with_index do |from, idx|
+        to = layer.list[idx]
+        connected = from.connected(to)
+        connections += 1 if connected&.type == :projected
+      end
+
+      return Layer::CONNECTION_TYPE[:ONE_TO_ONE] if connections == size
+
+      false
+    end
+
+    # Clears all the neurons in the layer
+    def clear
+      list.each(&:clear)
+    end
+
+    # Resets all the neurons in the layer
+    def reset
+      list.each(&:reset)
+    end
+
+    # Returns all the neurons in the layer
+    #
+    # @return [Array<Synaptical::Neuron>] List of neurons in the layer
+    alias neurons list
+
+    # Adds a neuron to the layer
+    # @param neuron [Synaptical::Neuron] The new neuron
+    def add(neuron = Neuron.new)
+      list << neuron
+      size += 1
+    end
+
+    # Configure layer options
+    #
+    # @return [Hash] Hash with options options
+    def set(_options)
+      raise 'TODO'
+    end
+  end
+end