neuronet 6.1.0 → 8.0.251113

data/lib/neuronet/output_neuron.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Neuronet
+  # Output Neuron
+  class OutputNeuron
+    include NeuronStats
+    include Backpropagate
+
+    def initialize
+      @bias        = 0.0
+      @connections = []
+    end
+
+    attr_accessor :bias
+    attr_reader   :connections
+
+    def activation = nil
+
+    def connect(neuron, weight = 0.0)
+      @connections << Connection.new(neuron, weight)
+    end
+
+    def value
+      @bias + @connections.sum(&:value)
+    end
+  end
+end

data/lib/neuronet/perceptron.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Neuronet
+  # Perceptron
+  class Perceptron
+    include NetworkStats
+    include Exportable
+    include Trainable
+    include Arrayable
+
+    def initialize(input_size, output_size,
+                   input_neuron: InputNeuron, output_neuron: OutputNeuron)
+      @input_layer = InputLayer.new(input_size, input_neuron:)
+      @output_layer = OutputLayer.new(output_size, output_neuron:)
+      @output_layer.connect(@input_layer)
+    end
+
+    attr_reader :input_layer, :output_layer
+
+    def set(values)
+      @input_layer.set(values)
+    end
+
+    def values
+      @output_layer.values
+    end
+
+    def *(other)
+      set(other)
+      values
+    end
+
+    def to_a = [@input_layer, @output_layer]
+  end
+end

data/lib/neuronet/squash.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Neuronet
+  # Squash provides logistic sigmoid function.
+  module Squash
+    # Logistic sigmoid: maps Real to (0, 1).
+    def squash(value) = 1.0 / (1.0 + Math.exp(-value))
+    # Inverse sigmoid: maps (0, 1) to Real.
+    def unsquash(activation) = Math.log(activation / (1.0 - activation))
+    module_function :squash, :unsquash
+  end
+end

data/lib/neuronet/trainable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neuronet
+  # Trainable adds error backpropagation and training.
+  module Trainable
+    def pairs(pairs, nju: expected_nju)
+      pairs.shuffle.each { |inputs, targets| train(inputs, targets, nju:) }
+    end
+
+    def train(inputs, targets, nju:)
+      actuals = self * inputs
+      errors = targets.zip(actuals).map { |target, actual| target - actual }
+      error, index = pivot(errors)
+      neuron = output_layer[index]
+      neuron.backpropagate(error / nju)
+    end
+
+    def pivot(errors)
+      error = index = 0.0
+      errors.each_with_index do |e, i|
+        next unless e.abs > error.abs
+
+        error = e
+        index = i
+      end
+      [error, index]
+    end
+  end
+end