neuronet 7.0.230416 → 8.0.251113

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

data/lib/neuronet.rb

@@ -1,15 +1,33 @@
 # frozen_string_literal: true
 
-# Neuronet is a neural network library for Ruby.
+# Neuronet
 module Neuronet
-  VERSION = '7.0.230416'
-  require_relative           'neuronet/constants'
-  autoload :Connection,      'neuronet/connection'
-  autoload :Neuron,          'neuronet/neuron'
-  autoload :Layer,           'neuronet/layer'
-  autoload :FeedForward,     'neuronet/feed_forward'
-  autoload :Scale,           'neuronet/scale'
-  autoload :Gaussian,        'neuronet/gaussian'
-  autoload :LogNormal,       'neuronet/log_normal'
-  autoload :ScaledNetwork,   'neuronet/scaled_network'
+  VERSION = '8.0.251113'
+
+  autoload :Arrayable,          'neuronet/arrayable'
+  autoload :Exportable,         'neuronet/exportable'
+  autoload :Squash,             'neuronet/squash'
+  autoload :Connection,         'neuronet/connection'
+  autoload :Config,             'neuronet/config'
+  autoload :Backpropagate,      'neuronet/backpropagate'
+  autoload :NoisyBackpropagate, 'neuronet/noisy_backpropagate'
+  autoload :LayerPresets,       'neuronet/layer_presets'
+  autoload :Trainable,          'neuronet/trainable'
+  autoload :NeuronStats,        'neuronet/neuron_stats'
+  autoload :NetworkStats,       'neuronet/network_stats'
+  autoload :InputNeuron,        'neuronet/input_neuron'
+  autoload :MiddleNeuron,       'neuronet/middle_neuron'
+  autoload :OutputNeuron,       'neuronet/output_neuron'
+  autoload :Neuron,             'neuronet/neuron'
+  autoload :NoisyMiddleNeuron,  'neuronet/noisy_middle_neuron'
+  autoload :NoisyOutputNeuron,  'neuronet/noisy_output_neuron'
+  autoload :NoisyNeuron,        'neuronet/noisy_neuron'
+  autoload :InputLayer,         'neuronet/input_layer'
+  autoload :MiddleLayer,        'neuronet/middle_layer'
+  autoload :OutputLayer,        'neuronet/output_layer'
+  autoload :Layer,              'neuronet/layer'
+  autoload :Perceptron,         'neuronet/perceptron'
+  autoload :MLP,                'neuronet/mlp'
+  autoload :Deep,               'neuronet/deep'
+  autoload :FeedForward,        'neuronet/feed_forward'
 end

metadata

@@ -1,121 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: neuronet
 version: !ruby/object:Gem::Version
-  version: 7.0.230416
+  version: 8.0.251113
 platform: ruby
 authors:
 - CarlosJHR64
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-16 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: colorize
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.8.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.8.1
-- !ruby/object:Gem::Dependency
-  name: parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.1
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.45'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.45.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.45'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.45.1
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.5.7
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.5.7
+date: 2025-11-14 00:00:00.000000000 Z
+dependencies: []
 description: |
   Library to create neural networks.
 
-  This is primarily a math project meant to be used to investigate the behavior of
-  different small neural networks.
+  Features perceptron, MLP, and deep feed forward networks.
+  Uses a logistic squash function.
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CREDITS.md
 - README.md
 - lib/neuronet.rb
+- lib/neuronet/arrayable.rb
+- lib/neuronet/backpropagate.rb
+- lib/neuronet/config.rb
 - lib/neuronet/connection.rb
-- lib/neuronet/constants.rb
+- lib/neuronet/deep.rb
+- lib/neuronet/exportable.rb
 - lib/neuronet/feed_forward.rb
-- lib/neuronet/gaussian.rb
+- lib/neuronet/input_layer.rb
+- lib/neuronet/input_neuron.rb
 - lib/neuronet/layer.rb
-- lib/neuronet/log_normal.rb
+- lib/neuronet/layer_presets.rb
+- lib/neuronet/middle_layer.rb
+- lib/neuronet/middle_neuron.rb
+- lib/neuronet/mlp.rb
+- lib/neuronet/network_stats.rb
 - lib/neuronet/neuron.rb
-- lib/neuronet/scale.rb
-- lib/neuronet/scaled_network.rb
+- lib/neuronet/neuron_stats.rb
+- lib/neuronet/noisy_backpropagate.rb
+- lib/neuronet/noisy_middle_neuron.rb
+- lib/neuronet/noisy_neuron.rb
+- lib/neuronet/noisy_output_neuron.rb
+- lib/neuronet/output_layer.rb
+- lib/neuronet/output_neuron.rb
+- lib/neuronet/perceptron.rb
+- lib/neuronet/squash.rb
+- lib/neuronet/trainable.rb
 homepage: https://github.com/carlosjhr64/neuronet
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -123,16 +59,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-requirements:
-- 'git: 2.30'
-rubygems_version: 3.4.11
-signing_key: 
+requirements: []
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Library to create neural networks.
 test_files: []

data/lib/neuronet/constants.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-# Neuronet module / Constants
-module Neuronet
-  # Neuronet allows one to set the format to use for displaying float values,
-  # mostly used in the inspect methods.
-  # [Docs](https://docs.ruby-lang.org/en/master/format_specifications_rdoc.html)
-  FORMAT = '%.13g'
-
-  # An artificial neural network uses a squash function to determine the
-  # activation value of a neuron.  The squash function for Neuronet is the
-  # [Sigmoid function](http://en.wikipedia.org/wiki/Sigmoid_function) which sets
-  # the neuron's activation value between 0.0 and 1.0.  This activation value is
-  # often thought of on/off or true/false.  For classification problems,
-  # activation values near one are considered true while activation values near
-  # 0.0 are considered false.  In Neuronet I make a distinction between the
-  # neuron's activation value and it's representation to the problem.  This
-  # attribute, activation, need never appear in an implementation of Neuronet,
-  # but it is mapped back to it's unsquashed value every time the implementation
-  # asks for the neuron's value.  One should scale the problem with most data
-  # points between -1 and 1, extremes under 2s, and no outbounds above 3s.
-  # Standard deviations from the mean is probably a good way to figure the scale
-  # of the problem.
-  SQUASH     = ->(unsquashed) { 1.0 / (1.0 + Math.exp(-unsquashed)) }
-  UNSQUASH   = ->(squashed) { Math.log(squashed / (1.0 - squashed)) }
-  DERIVATIVE = ->(squash) { squash * (1.0 - squash) }
-
-  # I'll want to have a neuron roughly mirror another later.   Let [v] be the
-  # squash of v.  Consider:
-  #   v = b + w*[v]
-  # There is no constant b and w that will satisfy the above equation for all v.
-  # But one can satisfy the equation for v in {-1, 0, 1}.  Find b and w such
-  # that:
-  #   A: 0 = b + w*[0]
-  #   B: 1 = b + w*[1]
-  #   C: -1 = b + w*[-1]
-  # Use A and B to solve for b and w:
-  #   A: 0 = b + w*[0]
-  #      b = -w*[0]
-  #   B: 1 = b + w*[1]
-  #      1 = -w*[0] + w*[1]
-  #      1 = w*(-[0] + [1])
-  #      w = 1/([1] - [0])
-  #      b = -[0]/([1] - [0])
-  # Verify A, B, and C:
-  #   A: 0 = b + w*[0]
-  #      0 = -[0]/([1] - [0]) + [0]/([1] - [0])
-  #      0 = 0 # OK
-  #   B: 1 = b + w*[1]
-  #      1 = -[0]/([1] - [0]) + [1]/([1] - [0])
-  #      1 = ([1] - [0])/([1] - [0])
-  #      1 = 1 # OK
-  # Using the squash function identity, [v] = 1 - [-v]:
-  #   C: -1 = b + w*[-1]
-  #      -1 = -[0]/([1] - [0]) + [-1]/([1] - [0])
-  #      -1 = ([-1] - [0])/([1] - [0])
-  #      [0] - [1] = [-1] - [0]
-  #      [0] - [1] = 1 - [1] - [0] # Identity substitution.
-  #      [0] = 1 - [0] # OK, by identity(0=-0).
-  # Evaluate given that [0] = 0.5:
-  #      b = -[0]/([1] - [0])
-  #      b = [0]/([0] - [1])
-  #      b = 0.5/(0.5 - [1])
-  #      w = 1/([1] - [0])
-  #      w = 1/([1] - 0.5)
-  #      w = -2 * 0.5/(0.5 - [1])
-  #      w = -2 * b
-  BZERO = 0.5 / (0.5 - SQUASH[1.0])
-  WONE  = -2.0 * BZERO
-
-  # Although the implementation is free to set all parameters for each neuron,
-  # Neuronet by default creates zeroed neurons.  Association between inputs and
-  # outputs are trained, and neurons differentiate from each other randomly.
-  # Differentiation among neurons is achieved by noise in the back-propagation
-  # of errors.  This noise is provided by rand + rand.  I chose rand + rand to
-  # give the noise an average value of one and a bell shape distribution.
-  NOISE = ->(error) { error * (rand + rand) }
-
-  # One may choose not to have noise.
-  NO_NOISE = ->(error) { error }
-
-  # To keep components bounded, Neuronet limits the weights, biases, and values.
-  # Note that on a 64-bit machine SQUASH[37] rounds to 1.0, and
-  # SQUASH[9] is 0.99987...
-  MAXW = 9.0  # Maximum weight
-  MAXB = 18.0 # Maximum bias
-  MAXV = 36.0 # Maximum value
-
-  # Mu learning factor.
-  LEARNING = 1.0
-
-  # The above constants are the defaults for Neuronet.  They are set below in
-  # accessable module attributes.  The user may change these to suit their
-  # needs.
-  class << self
-    attr_accessor :format, :squash, :unsquash, :derivative, :bzero, :wone,
-                  :noise, :maxw, :maxb, :maxv, :learning
-  end
-  self.squash     = SQUASH
-  self.unsquash   = UNSQUASH
-  self.derivative = DERIVATIVE
-  self.bzero      = BZERO
-  self.wone       = WONE
-  self.noise      = NOISE
-  self.format     = FORMAT
-  self.maxw       = MAXW
-  self.maxb       = MAXB
-  self.maxv       = MAXV
-  self.learning   = LEARNING
-end

data/lib/neuronet/gaussian.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-# Neuronet module
-module Neuronet
-  # "Normal Distribution"
-  # Gaussian sub-classes Scale and is used exactly the same way. The only
-  # changes are that it calculates the arithmetic mean (average) for center and
-  # the standard deviation for spread.
-  class Gaussian < Scale
-    def set(inputs)
-      @center ||= inputs.sum.to_f / inputs.length
-      unless @spread
-        sum2 = inputs.map { @center - _1 }.sum { _1 * _1 }.to_f
-        @spread = Math.sqrt(sum2 / (inputs.length - 1.0))
-      end
-      self
-    end
-  end
-end

data/lib/neuronet/log_normal.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Neuronet module
-module Neuronet
-  # "Log-Normal Distribution"
-  # LogNormal sub-classes Gaussian to transform the values to a logarithmic
-  # scale.
-  class LogNormal < Gaussian
-    def set(inputs)
-      super(inputs.map { |value| Math.log(value) })
-    end
-
-    def mapped(inputs)
-      super(inputs.map { |value| Math.log(value) })
-    end
-
-    def unmapped(outputs)
-      super(outputs).map { |value| Math.exp(value) }
-    end
-  end
-end

data/lib/neuronet/scale.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-# Neuronet module
-module Neuronet
-  # Neuronet::Scale is a class to help scale problems to fit within a network's
-  # "field of view". Given a list of values, it finds the minimum and maximum
-  # values and establishes a mapping to a scaled set of numbers between minus
-  # one and one (-1,1).
-  class Scale
-    attr_accessor :spread, :center
-
-    # If the value of center is provided, then
-    # that value will be used instead of
-    # calculating it from the values passed to method #set.
-    # Likewise, if spread is provided, that value of spread will be used.
-    def initialize(factor: 1.0, center: nil, spread: nil)
-      @factor = factor
-      @center = center
-      @spread = spread
-    end
-
-    def set(inputs)
-      min, max = inputs.minmax
-      @center ||= (max + min) / 2.0
-      @spread ||= (max - min) / 2.0
-      self
-    end
-
-    def reset(inputs)
-      @center = @spread = nil
-      set(inputs)
-    end
-
-    def mapped(inputs)
-      factor = 1.0 / (@factor * @spread)
-      inputs.map { |value| factor * (value - @center) }
-    end
-    alias mapped_input mapped
-    alias mapped_output mapped
-
-    # Note that it could also unmap inputs, but
-    # outputs is typically what's being transformed back.
-    def unmapped(outputs)
-      factor = @factor * @spread
-      outputs.map { |value| (factor * value) + @center }
-    end
-    alias unmapped_input unmapped
-    alias unmapped_output unmapped
-  end
-end

data/lib/neuronet/scaled_network.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-# Neuronet module
-module Neuronet
-  # ScaledNetwork is a subclass of FeedForwardNetwork.
-  # It automatically scales the problem given to it
-  # by using a Scale type instance set in @distribution.
-  # The attribute, @distribution, is set to Neuronet::Gaussian.new by default,
-  # but one can change this to Scale, LogNormal, or one's own custom mapper.
-  class ScaledNetwork < FeedForward
-    attr_accessor :distribution, :reset
-
-    def initialize(layers, distribution: Gaussian.new, reset: false)
-      super(layers)
-      @distribution = distribution
-      @reset        = reset
-    end
-
-    # ScaledNetwork set works just like FeedForwardNetwork's set method,
-    # but calls @distribution.set(values) first if @reset is true.
-    # Sometimes you'll want to set the distribution with the entire data set,
-    # and then there will be times you'll want to reset the distribution
-    # with each input.
-    def set(input)
-      @distribution.reset(input) if @reset
-      super(@distribution.mapped_input(input))
-    end
-
-    def input
-      @distribution.unmapped_input(super)
-    end
-
-    def output
-      @distribution.unmapped_output(super)
-    end
-
-    def *(_other)
-      @distribution.unmapped_output(super)
-    end
-
-    def train(target, mju = expected_mju)
-      super(@distribution.mapped_output(target), mju)
-    end
-
-    def inspect
-      distribution = @distribution.class.to_s.split(':').last
-      "#distribution:#{distribution} #reset:#{@reset}\n" + super
-    end
-  end
-end