synaptical 0.0.1.pre.beta1

data/lib/synaptical/layer_connection.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Synaptical
+  # Representation of a connection between layers
+  class LayerConnection
+    attr_reader :id, :from, :to, :selfconnection, :type, :connections, :list,
+                :size, :gatedfrom
+    def initialize(from, to, type, weights)
+      @id = self.class.uid
+      @from = from
+      @to = to
+      @selfconnection = to == from
+      @type = type
+      @connections = {}
+      @list = []
+      @size = 0
+      @gatedfrom = []
+
+      init_type
+
+      connect!(weights)
+    end
+
+    # Initialize connection type if not provided
+    def init_type
+      return unless type.nil?
+      @type = if from == to
+                Synaptical::Layer::CONNECTION_TYPE[:ONE_TO_ONE]
+              else
+                Synaptical::Layer::CONNECTION_TYPE[:ALL_TO_ALL]
+      end
+    end
+
+    def connect!(weights)
+      if type == Synaptical::Layer::CONNECTION_TYPE[:ALL_TO_ALL] ||
+         type == Synaptical::Layer::CONNECTION_TYPE[:ALL_TO_ELSE]
+        from.list.each do |from|
+          to.list.each do |to|
+            if type == Synaptical::Layer::CONNECTION_TYPE[:ALL_TO_ELSE] &&
+               from == to
+              next
+            end
+
+            connection = from.project(to, weights)
+            @connections[connection.id] = connection
+            list.push(connection)
+            @size = list.size
+          end
+        end
+      elsif type == Synaptical::Layer::CONNECTION_TYPE[:ONE_TO_ONE]
+        from.list.each_with_index do |from, idx|
+          to = to.list[idx]
+          connection = from.project(to, weights)
+
+          @connections[connection.id] = connection
+          list.push(connection)
+          @size = list.size
+        end
+      end
+
+      from.connected_to << self
+    end
+
+    class << self
+      attr_reader :connections
+
+      def uid
+        @connections += 1
+      end
+    end
+
+    @connections = 0
+  end
+end

data/lib/synaptical/network.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Synaptical
+  # Representation of a network
+  class Network
+    Layers = Struct.new(:input, :hidden, :output)
+
+    attr_reader :optimized, :layers
+
+    def initialize(input:, hidden:, output:)
+      @layers = Layers.new(input, hidden, output)
+      @optimized = false
+    end
+
+    # Feed-forward activation of all the layers to produce an output
+    # @param input [Array<Numeric>] Input
+    #
+    # @return [Array<Numeric>] Output
+    def activate(input)
+      raise if optimized
+      layers.input.activate(input)
+      layers.hidden.each(&:activate)
+      layers.output.activate
+    end
+
+    # Back-propagate the error through the network
+    # @param rate [Float] Learning rate
+    # @param target [Array<Numeric>] Target values
+    def propagate(rate, target)
+      raise if optimized
+      layers.output.propagate(rate, target)
+      layers.hidden.each { |layer| layer.propagate(rate) }
+    end
+
+    # Project output onto another layer or network
+    # @param unit [Synaptical::Network, Synaptical::Layer] Object to project against
+    # @param type [type] [description]
+    # @param weights [type] [description]
+    def project(unit, type, weights)
+      raise if optimized
+      case unit
+      when Network
+        layers.output.project(unit.layers.input, type, weights)
+      when Layer
+        layers.output.project(unit, type, weights)
+      else
+        raise ArgumentError, 'Invalid argument'
+      end
+    end
+
+    def gate(connection, type)
+      raise if optimized
+      layers.output.gate(connection, type)
+    end
+
+    def clear
+      restore
+      ([layers.input, layers.output] + layers.hidden).each(&:clear)
+    end
+
+    def reset
+      restore
+      ([layers.input, layers.output] + layers.hidden).each(&:reset)
+    end
+
+    def optimize
+      raise
+    end
+
+    def restore
+      raise if optimized
+    end
+
+    # Return all neurons in all layers
+    #
+    # @return [Array<Hash>] A list of neurons and which layer they belong to
+    def neurons
+      layers.input.neurons.map { |n| { neuron: n, layer: 'input' } } +
+        layers.hidden
+              .flat_map(&:neurons)
+              .each_with_index
+              .map { |n, i| { neuron: n, layer: i } } +
+        layers.output.neurons.map { |n| { neuron: n, layer: 'output' } }
+    end
+
+    # Return number of inputs
+    #
+    # @return [Integer] Number of inputs
+    def inputs
+      layers.input.size
+    end
+
+    # Return number of outputs
+    #
+    # @return [Integer] Number of outputs
+    def outputs
+      layers.output.size
+    end
+
+    def set
+      raise 'TODO'
+    end
+
+    def set_optimize
+      raise 'TODO'
+    end
+
+    # Export the network as JSON
+    #
+    # @return [Hash] Hash ready for JSON serialization
+    def to_json
+      restore
+
+      Synaptical::Serializer::JSON.as_json(self)
+    end
+
+    def to_dot
+      raise 'TODO'
+    end
+
+    def from_json
+      raise 'TODO'
+    end
+  end
+end

data/lib/synaptical/neuron.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+module Synaptical
+  # Representation of a neuron
+  class Neuron
+    CONNECTION_TYPES = %i[inputs projected gated].freeze
+
+    Connections = Struct.new(:inputs, :projected, :gated)
+    Connection = Struct.new(:type, :connection)
+    Error = Struct.new(:responsibility, :projected, :gated)
+    Trace = Struct.new(:elegibility, :extended, :influences)
+
+    attr_reader :id, :connections, :error, :trace, :state, :old, :activation,
+                :selfconnection, :squash, :neighbors, :bias
+    # Creates an instance of a Neuron
+    def initialize
+      @id = self.class.uid
+      @connections = Connections.new({}, {}, {})
+      @error = Error.new(0.0, 0.0, 0.0)
+      @trace = Trace.new({}, {}, {})
+
+      @state = @old = @activation = 0.0
+      @selfconnection = Synaptical::Connection.new(self, self, 0.0)
+      @squash = Synaptical::Squash::Logistic
+      @neighbors = {}
+      @bias = rand * 0.2 - 0.1
+    end
+
+    # Activate the neuron
+    # @param input = nil [Numeric] input value
+    #
+    # @return [Numeric] output value
+    def activate(input = nil)
+      # Is neuron in input layer
+      unless input.nil?
+        @activation = input
+        @derivative = 0
+        @bias = 0
+        return activation
+      end
+
+      @old = @state
+
+      # eq. 15.
+      @state = selfconnection.gain * selfconnection.weight * state + bias
+
+      connections.inputs.each_value do |neuron|
+        @state += neuron.from.activation * neuron.weight * neuron.gain
+      end
+
+      # eq. 16.
+      @activation = squash.call(@state)
+
+      # f'(s)
+      @derivative = squash.derivate(@activation)
+
+      # Update traces
+      influences = []
+      trace.extended.each_key do |id|
+        neuron = @neighbors[id]
+
+        influence = neuron.selfconnection.gater == self ? neuron.old : 0
+
+        trace.influences[neuron.id].each do |incoming|
+          influence +=
+            trace.influences[neuron.id][incoming].weight *
+            trace.influences[id][incoming].from.activation
+        end
+
+        influences[neuron.id] = influence
+      end
+
+      connections.inputs.each_value do |input_neuron|
+        # elegibility trace - eq. 17
+        trace.elegibility[input_neuron.id] =
+          selfconnection.gain *
+          selfconnection.weight *
+          trace.elegibility[input_neuron.id] +
+          input_neuron.gain *
+          input_neuron.from.activation
+
+        trace.extended.each do |id, xtrace|
+          neuron = neighbors[id]
+          influence = influences[neuron.id]
+
+          xtrace[input_neuron.id] =
+            neuron.selfconnection.gain *
+            neuron.selfconnection.weight *
+            xtrace[input_neuron.id] +
+            @derivative *
+            trace.elegibility[input_neuron.id] *
+            influence
+        end
+      end
+
+      # Update gated connection's gains
+      connections.gated.each { |conn| conn.gain = @activation }
+
+      @activation
+    end
+
+    # Back propagate the error
+    # @param rate [Float] Learning rate
+    # @param target = nil [Numeric] Target value
+    def propagate(rate = 0.1, target = nil)
+      error = 0.0
+
+      # Is neuron in output layer
+      if !target.nil?
+        # Eq. 10.
+        @error.responsibility = @error.projected = target - @activation
+      else
+        # The rest of the neuron compute their error responsibilities by back-
+        # propagation
+        connections.projected.each_value do |connection|
+          neuron = connection.to
+
+          # Eq. 21.
+          error +=
+            neuron.error.responsibility * connection.gain * connection.weight
+        end
+
+        # Projected error responsibility
+        @error.projected = @derivative * error
+
+        error = 0.0
+        # Error responsibilities from all the connections gated by this neuron
+        trace.extended.each do |id, _|
+          neuron = @neighbors[id] # gated neuron
+          # If gated neuron's selfconnection is gated by this neuron
+          influence = neuron.selfconnection.gater == self ? neuron.old : 0.0
+
+          # Index runs over all th econnections to the gated neuron that are
+          # gated by this neuron
+          trace.influences[id].each do |input, infl|
+            # Captures the effect that the input connection of this neuron have,
+            # on a neuron which its input/s is/are gated by this neuron
+            influence +=
+              infl.weight *
+              trace.influences[neuron.id][input].from.activation
+          end
+
+          # Eq. 22.
+          error += neuron.error.responsibility * influence
+        end
+
+        # Gated error responsibility
+        @error.gated = @derivative * error
+
+        # Error responsibility - Eq. 23.
+        @error.responsibility = @error.projected + @error.gated
+      end
+
+      connections.inputs.each_value do |input_neuron|
+        # Eq. 24
+        gradient = @error.projected * trace.elegibility[input_neuron.id]
+        trace.extended.each do |id, _|
+          neuron = neighbors[id]
+          gradient += neuron.error.responsibility *
+            trace.extended[neuron.id][input_neuron.id]
+        end
+
+        # Adjust weights - aka. learn
+        input_neuron.weight += rate * gradient
+      end
+
+      # Adjust bias
+      @bias += rate * @error.responsibility
+    end
+
+    # [project description]
+    # @param neuron [Synaptical::Neuron] Other neuron
+    # @param weight = nil [Float] Weight
+    #
+    # @return [Synaptical::Connection] Connection
+    def project(neuron, weight = nil)
+      if neuron == self
+        selfconnection.weight = 1
+        return selfconnection
+      end
+
+      # Check if connection already exists
+      connected = connected(neuron)
+      if connected && connected.type == :projected
+        # Update connection
+        connected.connection.weight = weight unless weight.nil?
+        return connected.connection
+      else
+        connection = ::Synaptical::Connection.new(self, neuron, weight)
+      end
+
+      # Reference all te connections and traces
+      connections.projected[connection.id] = connection
+      neighbors[neuron.id] = neuron
+      neuron.connections.inputs[connection.id] = connection
+      neuron.trace.elegibility[connection.id] = 0
+
+      neuron.trace.extended.each do |_id, trace|
+        trace[connection.id] = 0
+      end
+
+      connection
+    end
+
+    # Add connection to gated list
+    # @param connection [Synaptical::Connection] Connection
+    def gate(connection)
+      connections.gated[connection.id] = connection
+
+      neuron = connection.to
+      unless trace.extended.key?(neuron.id)
+        # Extended trace
+        neighbors[neuron.id] = neuron
+        xtrace = trace.extended[neuron.id] = {}
+        connection.inputs.each_value do |input|
+          xtrace[input.id] = 0
+        end
+      end
+
+      # Keep track
+      if trace.influences.key?(neuron.id)
+        trace.influences[neuron.id] << connection
+      else
+        trace.influences[neuron.id] = [connection]
+      end
+
+      # Set gater
+      connection.gater = self
+    end
+
+    # Returns wheter the neuron is self connected
+    #
+    # @return [Boolean] true if self connected, false otherwise
+    def selfconnected?
+      !selfconnection.weight.zero?
+    end
+
+    # Returns whether the neuron is connected to another neuron
+    # @param neuron [Synaptical::Neuron] Other neuron
+    #
+    # @return [Boolean, Hash] Connection type if connected to other neuron,
+    #                         false otherwise
+    def connected(neuron)
+      result = Connection.new
+
+      if self == neuron
+        return nil unless selfconnected?
+        result.type = :selfconnection
+        result.connection = selfconnection
+        return result
+      end
+
+      CONNECTION_TYPES
+        .map { |ct| connections.send(ct).values }
+        .flatten
+        .each do |connection|
+          next unless connection.to == neuron || connection.from == neuron
+          result.type = type
+          result.connection = type
+          return result
+        end
+
+      nil
+    end
+
+    # Clear the context of the neuron, but keeps connections
+    def clear
+      trace.elegibility.transform_values { |_| 0 }
+      trace.extended.each_value do |ext|
+        ext.transform_values { |_| 0 }
+      end
+
+      error.responsibility = error.projected = error.gated = 0
+    end
+
+    # Clears traces and randomizes connections
+    def reset
+      clear
+      CONNECTION_TYPES.map { |ct| connections.send(ct) }.each do |conn_group|
+        conn_group.each_value { |conn| conn.weight = rand * 0.2 - 0.1 }
+      end
+
+      @bias = rand * 0.2 - 0.1
+      @old = @state = @activation = 0
+    end
+
+    # Hard codes the behavior of the neuron into an optimized function
+    # @param optimized [Hash] [description]
+    # @param layer [type] [description]
+    #
+    # @return [type] [description]
+    def optimize(_optimized, _layer)
+      raise 'TODO'
+    end
+
+    class << self
+      attr_reader :neurons
+      # Returns the next id in the sequence
+      #
+      # @return [type] [description]
+      def uid
+        @neurons += 1
+      end
+
+      def quantity
+        { neurons: neurons, connections: Connection.connections }
+      end
+    end
+
+    @neurons = 0
+  end
+end