machine_learning_workbench 0.1.0

data/lib/machine_learning_workbench/neural_network.rb

@@ -0,0 +1,3 @@
+require_relative 'neural_network/base'
+require_relative 'neural_network/feed_forward'
+require_relative 'neural_network/recurrent'

data/lib/machine_learning_workbench/neural_network/base.rb

@@ -0,0 +1,211 @@
+
+module MachineLearningWorkbench::NeuralNetwork
+  # Neural Network base class
+  class Base
+
+    # @!attribute [r] layers
+    #   List of matrices, each being the weights
+    #   connecting a layer's inputs (rows) to a layer's neurons (columns),
+    #   hence its shape is `[ninputs, nneurs]`
+    #   @return [Array<NMatrix>] list of weight matrices, each uniquely describing a layer
+    # @!attribute [r] state
+    #   It's a list of one-dimensional matrices, each an input to a layer, plus the output layer's output. The first element is the input to the first layer of the network, which is composed of the network's input, possibly the first layer's activation on the last input (recursion), and a bias (fixed `1`). The second to but-last entries follow the same structure, but with the previous layer's output in place of the network's input. The last entry is the activation of the output layer, without additions since it's not used as an input by anyone.
+    #   @return [Array<NMatrix>] current state of the network.
+    # @!attribute [r] act_fn
+    #   activation function, common to all neurons (for now)
+    #   @return [#call] activation function
+    # @!attribute [r] struct
+    #   list of number of (inputs or) neurons in each layer
+    #   @return [Array<Integer>] structure of the network
+    attr_reader :layers, :state, :act_fn, :struct
+
+
+    ## Initialization
+
+    # @param struct [Array<Integer>] list of layer sizes
+    # @param act_fn [Symbol] choice of activation function for the neurons
+    def initialize struct, act_fn: nil
+      @struct = struct
+      @act_fn = self.class.act_fn(act_fn || :sigmoid)
+      # @state holds both inputs, possibly recurrency, and bias
+      # it is a complete input for the next layer, hence size from layer sizes
+      @state = layer_row_sizes.collect do |size|
+        NMatrix.zeros([1, size], dtype: :float64)
+      end
+      # to this, append a matrix to hold the final network output
+      @state.push NMatrix.zeros([1, nneurs(-1)], dtype: :float64)
+      reset_state
+    end
+
+    # Reset the network to the initial state
+    def reset_state
+      @state.each do |m| # state has only single-row matrices
+        # reset all to zero
+        m[0,0..-1] = 0
+        # add bias to all but output
+        m[0,-1] = 1 unless m.object_id == @state.last.object_id
+      end
+    end
+
+    # Initialize the network with random weights
+    def init_random
+      # Will only be used for testing, no sense optimizing it (NMatrix#rand)
+      # Reusing #load_weights instead helps catching bugs
+      load_weights nweights.times.collect { rand(-1.0..1.0) }
+    end
+
+    ## Weight utilities
+
+    # Resets memoization: needed to play with structure modification
+    def deep_reset
+      # reset memoization
+      [:@layer_row_sizes, :@layer_col_sizes, :@nlayers, :@layer_shapes,
+       :@nweights_per_layer, :@nweights].each do |sym|
+         instance_variable_set sym, nil
+      end
+      reset_state
+    end
+
+    # Total weights in the network
+    # @return [Integer] total number of weights
+    def nweights
+      @nweights ||= nweights_per_layer.reduce(:+)
+    end
+
+    # List of per-layer number of weights
+    # @return [Array<Integer>] list of weights per each layer
+    def nweights_per_layer
+      @nweights_per_layer ||= layer_shapes.collect { |shape| shape.reduce(:*) }
+    end
+
+    # Count the layers. This is a computation helper, and for this implementation
+    # the inputs are considered as if a layer like the others.
+    # @return [Integer] number of layers
+    def nlayers
+      @nlayers ||= layer_shapes.size
+    end
+
+    # Returns the weight matrix
+    # @return [Array] three-dimensional Array of weights: a list of weight
+    #   matrices, one for each layer.
+    def weights
+      layers.collect(&:to_consistent_a)
+    end
+
+    # Number of neurons per layer. Although this implementation includes inputs
+    # in the layer counts, this methods correctly ignores the input as not having
+    # neurons.
+    # @return [Array] list of neurons per each (proper) layer (i.e. no inputs)
+    def layer_col_sizes
+      @layer_col_sizes ||= struct.drop(1)
+    end
+
+    # define #layer_row_sizes in child class: number of inputs per layer
+
+    # Shapes for the weight matrices, each corresponding to a layer
+    # @return [Array<Array[Integer, Integer]>] Weight matrix shapes
+    def layer_shapes
+      @layer_shapes ||= layer_row_sizes.zip layer_col_sizes
+    end
+
+    # Count the neurons in a particular layer or in the whole network.
+    # @param nlay [Integer, nil] the layer of interest, 1-indexed.
+    #   `0` will return the number of inputs.
+    #   `nil` will compute the total neurons in the network.
+    # @return [Integer] the number of neurons in a given layer, or in all network, or the number of inputs
+    def nneurs nlay=nil
+      nlay.nil? ? struct.reduce(:+) : struct[nlay]
+    end
+
+    # Loads a plain list of weights into the weight matrices (one per layer).
+    # Preserves order.
+    # @input weights [Array<Float>] weights to load
+    # @return [true] always true. If something's wrong it simply fails, and if
+    #   all goes well there's nothing to return but a confirmation to the caller.
+    def load_weights weights
+      raise "Hell!" unless weights.size == nweights
+      weights_iter = weights.each
+      @layers = layer_shapes.collect do |shape|
+        NMatrix.new(shape, dtype: :float64) { weights_iter.next }
+      end
+      reset_state
+      return true
+    end
+
+
+    ## Activation
+
+    # The "fixed `1`" used in the layer's input
+    def bias
+      @bias ||= NMatrix[[1], dtype: :float64]
+    end
+
+    # Activate the network on a given input
+    # @param input [Array<Float>] the given input
+    # @return [Array] the activation of the output layer
+    def activate input
+      raise "Hell!" unless input.size == struct.first
+      raise "Hell!" unless input.is_a? Array
+      # load input in first state
+      @state[0][0, 0..-2] = input
+      # activate layers in sequence
+      (0...nlayers).each do |i|
+        act = activate_layer i
+        @state[i+1][0,0...act.size] = act
+      end
+      return out
+    end
+
+    # Extract and convert the output layer's activation
+    # @return [Array] the activation of the output layer as 1-dim Array
+    def out
+      state.last.to_flat_a
+    end
+
+    # define #activate_layer in child class
+
+    ## Activation functions
+
+    # Activation function caller. Allows to cleanly define the activation function as one-dimensional, by calling it over the inputs and building a NMatrix to return.
+    # @return [NMatrix] activations for one layer
+    def self.act_fn type, *args
+      fn = send(type,*args)
+      lambda do |inputs|
+        NMatrix.new([1, inputs.size], dtype: :float64) do |_,i|
+          # single-row matrix, indices are columns
+          fn.call inputs[i]
+        end
+      end
+    end
+
+    # Traditional sigmoid with variable steepness
+    def self.sigmoid k=0.5
+      # k is steepness:  0<k<1 is flatter, 1<k is flatter
+      # flatter makes activation less sensitive, better with large number of inputs
+      lambda { |x| 1.0 / (Math.exp(-k * x) + 1.0) }
+    end
+
+    # Traditional logistic
+    def self.logistic
+      lambda { |x|
+        exp = Math.exp(x)
+        exp.infinite? ? exp : exp / (1.0 + exp)
+      }
+    end
+
+    # LeCun hyperbolic activation
+    # @see http://yann.lecun.com/exdb/publis/pdf/lecun-98b.pdf Section 4.4
+    def self.lecun_hyperbolic
+      lambda { |x| 1.7159 * Math.tanh(2.0*x/3.0) + 1e-3*x }
+    end
+
+
+    # @!method interface_methods
+    # Declaring interface methods - implement in child class!
+    [:layer_row_sizes, :activate_layer].each do |sym|
+      define_method sym do
+        raise NotImplementedError, "Implement ##{sym} in child class!"
+      end
+    end
+  end
+end

data/lib/machine_learning_workbench/neural_network/feed_forward.rb

@@ -0,0 +1,20 @@
+
+module MachineLearningWorkbench::NeuralNetwork
+  # Feed Forward Neural Network
+  class FeedForward < Base
+
+    # Calculate the size of each row in a layer's weight matrix.
+    # Includes inputs (or previous-layer activations) and bias.
+    # @return [Array<Integer>] per-layer row sizes
+    def layer_row_sizes
+      @layer_row_sizes ||= struct.each_cons(2).collect {|prev, _curr| prev+1}
+    end
+
+    # Activates a layer of the network
+    # @param i [Integer] the layer to activate, zero-indexed
+    def activate_layer i
+      act_fn.call( state[i].dot layers[i] )
+    end
+
+  end
+end

data/lib/machine_learning_workbench/neural_network/recurrent.rb

@@ -0,0 +1,35 @@
+
+module MachineLearningWorkbench::NeuralNetwork
+  # Recurrent Neural Network
+  class Recurrent < Base
+
+    # Calculate the size of each row in a layer's weight matrix.
+    # Each row holds the inputs for the next level: previous level's
+    # activations (or inputs), this level's last activations
+    # (recursion) and bias.
+    # @return [Array<Integer>] per-layer row sizes
+    def layer_row_sizes
+      @layer_row_sizes ||= struct.each_cons(2).collect do |prev, rec|
+        prev + rec + 1
+      end
+    end
+
+    # Activates a layer of the network.
+    # Bit more complex since it has to copy the layer's activation on
+    # last input to its own inputs, for recursion.
+    # @param i [Integer] the layer to activate, zero-indexed
+    def activate_layer nlay #_layer
+      # NOTE: current layer index corresponds to index of next state!
+      previous = nlay     # index of previous layer (inputs)
+      current = nlay + 1  # index of current layer (outputs)
+      # Copy the level's last-time activation to the input (previous state)
+      # NOTE: ranges in NMatrix#[] not reliable! gotta loop :(
+      nneurs(current).times do |i| # for each activations to copy
+        # Copy output from last-time activation to recurrency in previous state
+        @state[previous][0, nneurs(previous) + i] = state[current][0, i]
+      end
+      act_fn.call state[previous].dot layers[nlay]
+    end
+
+  end
+end

data/lib/machine_learning_workbench/optimizer.rb

@@ -0,0 +1,7 @@
+module MachineLearningWorkbench::Optimizer
+end
+
+require_relative 'optimizer/natural_evolution_strategies/base'
+require_relative 'optimizer/natural_evolution_strategies/xnes'
+require_relative 'optimizer/natural_evolution_strategies/snes'
+require_relative 'optimizer/natural_evolution_strategies/bdnes'

data/lib/machine_learning_workbench/optimizer/natural_evolution_strategies/base.rb

@@ -0,0 +1,112 @@
+
+module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
+  # Natural Evolution Strategies base class
+  class Base
+    attr_reader :ndims, :mu, :sigma, :opt_type, :obj_fn, :id, :rng, :last_fits, :best
+
+    # NES object initialization
+    # @param ndims [Integer] number of parameters to optimize
+    # @param obj_fn [#call] any object defining a #call method (Proc, lambda, custom class)
+    # @param opt_type [:min, :max] select minimization / maximization of obj_fn
+    # @param rseed [Integer] allow for deterministic execution on rseed provided
+    def initialize ndims, obj_fn, opt_type, rseed: nil, mu_init: 0, sigma_init: 1
+      raise ArgumentError unless [:min, :max].include? opt_type
+      raise ArgumentError unless obj_fn.respond_to? :call
+      @ndims, @opt_type, @obj_fn = ndims, opt_type, obj_fn
+      @id = NMatrix.identity(ndims, dtype: :float64)
+      rseed ||= Random.new_seed
+      # puts "NES rseed: #{s}"  # currently disabled
+      @rng = Random.new rseed
+      @best = [(opt_type==:max ? -1 : 1) * Float::INFINITY, nil]
+      @last_fits = []
+      initialize_distribution mu_init: mu_init, sigma_init: sigma_init
+    end
+
+    # Box-Muller transform: generates standard (unit) normal distribution samples
+    # @return [Float] a single sample from a standard normal distribution
+    def standard_normal_sample
+      rho = Math.sqrt(-2.0 * Math.log(rng.rand))
+      theta = 2 * Math::PI * rng.rand
+      tfn = rng.rand > 0.5 ? :cos : :sin
+      rho * Math.send(tfn, theta)
+    end
+
+    # Memoized automatic magic numbers
+    # NOTE: Doubling popsize and halving lrate often helps
+    def utils;   @utilities ||= cmaes_utilities   end
+    # (see #utils)
+    def popsize; @popsize   ||= cmaes_popsize * 2 end
+    # (see #utils)
+    def lrate;   @lrate     ||= cmaes_lrate       end
+
+    # Magic numbers from CMA-ES (TODO: add proper citation)
+    # @return [NMatrix] scale-invariant utilities
+    def cmaes_utilities
+      # Algorithm equations are meant for fitness maximization
+      # Match utilities with individuals sorted by INCREASING fitness
+      log_range = (1..popsize).collect do |v|
+        [0, Math.log(popsize.to_f/2 - 1) - Math.log(v)].max
+      end
+      total = log_range.reduce(:+)
+      buf = 1.0/popsize
+      vals = log_range.collect { |v| v / total - buf }.reverse
+      NMatrix[vals, dtype: :float64]
+    end
+
+    # (see #cmaes_utilities)
+    # @return [Float] learning rate lower bound
+    def cmaes_lrate
+      (3+Math.log(ndims)) / (5*Math.sqrt(ndims))
+    end
+
+    # (see #cmaes_utilities)
+    # @return [Integer] population size lower bound
+    def cmaes_popsize
+      [5, 4 + (3*Math.log(ndims)).floor].max
+    end
+
+    # Samples a standard normal distribution to construct a NMatrix of
+    #   popsize multivariate samples of length ndims
+    # @return [NMatrix] standard normal samples
+    def standard_normal_samples
+      NMatrix.new([popsize, ndims], dtype: :float64) { standard_normal_sample }
+    end
+
+    # Move standard normal samples to current distribution
+    # @return [NMatrix] individuals
+    def move_inds inds
+      # TODO: can we reduce the transpositions?
+      # sigma.dot(inds.transpose).map(&mu.method(:+)).transpose
+      multi_mu = NMatrix[*inds.rows.times.collect {mu.to_a}, dtype: :float64].transpose
+      (multi_mu + sigma.dot(inds.transpose)).transpose
+      # sigma.dot(inds.transpose).transpose + inds.rows.times.collect {mu.to_a}.to_nm
+    end
+
+    # Sorted individuals
+    # NOTE: Algorithm equations are meant for fitness maximization. Utilities need to be
+    # matched with individuals sorted by INCREASING fitness. Then reverse order for minimization.
+    # @return standard normal samples sorted by the respective individuals' fitnesses
+    def sorted_inds
+      samples = standard_normal_samples
+      inds = move_inds(samples).to_a
+      fits = obj_fn.call(inds)
+      # Quick cure for NaN fitnesses
+      fits.map! { |x| x.nan? ? (opt_type==:max ? -1 : 1) * Float::INFINITY : x }
+      @last_fits = fits # allows checking for stagnation
+      sorted = [fits, inds, samples.to_a].transpose.sort_by(&:first)
+      sorted.reverse! if opt_type==:min
+      this_best = sorted.last.take(2)
+      opt_cmp_fn = opt_type==:min ? :< : :>
+      @best = this_best if this_best.first.send(opt_cmp_fn, best.first)
+      NMatrix[*sorted.map(&:last), dtype: :float64]
+    end
+
+    # @!method interface_methods
+    # Declaring interface methods - implement these in child class!
+    [:train, :initialize_distribution, :convergence].each do |mname|
+      define_method mname do
+        raise NotImplementedError, "Implement in child class!"
+      end
+    end
+  end
+end

data/lib/machine_learning_workbench/optimizer/natural_evolution_strategies/bdnes.rb

@@ -0,0 +1,104 @@
+
+module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
+  # Block-Diagonal Natural Evolution Strategies
+  class BDNES < Base
+
+    MAX_RSEED = 10**Random.new_seed.size # same range as Random.new_seed
+
+    attr_reader :ndims_lst, :obj_fn, :opt_type, :blocks, :popsize, :rng,
+      :best, :last_fits
+
+    # initialize a list of XNES for each block
+    def initialize ndims_lst, obj_fn, opt_type, rseed: nil, **init_opts
+      # mu_init: 0, sigma_init: 1
+      # init_opts = {rseed: rseed, mu_init: mu_init, sigma_init: sigma_init}
+      # TODO: accept list of `mu_init`s and `sigma_init`s
+      @ndims_lst, @obj_fn, @opt_type = ndims_lst, obj_fn, opt_type
+      block_fit = -> (*args) { raise "Should never be called" }
+      # the BD-NES seed should ensure deterministic reproducibility
+      # but each block should have a different seed
+      rseed ||= Random.new_seed
+      # puts "BD-NES rseed: #{s}"  # currently disabled
+      @rng = Random.new rseed
+      @blocks = ndims_lst.map do |ndims|
+        b_rseed = rng.rand MAX_RSEED
+        XNES.new ndims, block_fit, opt_type, rseed: b_rseed, **init_opts
+      end
+      # Need `popsize` to be the same for all blocks, to make complete individuals
+      @popsize = blocks.map(&:popsize).max
+      blocks.each { |xnes| xnes.instance_variable_set :@popsize, popsize }
+
+      @best = [(opt_type==:max ? -1 : 1) * Float::INFINITY, nil]
+      @last_fits = []
+    end
+
+    def sorted_inds_lst
+      # Build samples and inds from the list of blocks
+      samples_lst, inds_lst = blocks.map do |xnes|
+        samples = xnes.standard_normal_samples
+        inds = xnes.move_inds(samples)
+        [samples.to_a, inds]
+      end.transpose
+
+      # Join the individuals for evaluation
+      full_inds = inds_lst.reduce(&:hconcat).to_a
+      # Need to fix samples dimensions for sorting
+      # - current dims: nblocks x ninds x [block sizes]
+      # - for sorting: ninds x nblocks x [block sizes]
+      full_samples = samples_lst.transpose
+
+      # Evaluate fitness of complete individuals
+      fits = obj_fn.call(full_inds)
+      # Quick cure for NaN fitnesses
+      fits.map! { |x| x.nan? ? (opt_type==:max ? -1 : 1) * Float::INFINITY : x }
+      @last_fits = fits # allows checking for stagnation
+
+      # Sort inds based on fit and opt_type, save best
+      sorted = [fits, full_inds, full_samples].transpose.sort_by(&:first)
+      sorted.reverse! if opt_type==:min
+      this_best = sorted.last.take(2)
+      opt_cmp_fn = opt_type==:min ? :< : :>
+      @best = this_best if this_best.first.send(opt_cmp_fn, best.first)
+      sorted_samples = sorted.map(&:last)
+
+      # Need to bring back sample dimensions for each block
+      # - current dims: ninds x nblocks x [block sizes]
+      # - target blocks list: nblocks x ninds x [block sizes]
+      block_samples = sorted_samples.transpose
+
+      # then back to NMatrix for usage in training
+      block_samples.map { |sample| NMatrix[*sample, dtype: :float64] }
+    end
+
+    # duck-type the interface: [:train, :mu, :convergence, :save, :load]
+
+    def train picks: sorted_inds_lst
+      blocks.zip(sorted_inds_lst).each do |xnes, s_inds|
+        xnes.train picks: s_inds
+      end
+    end
+
+    def mu
+      blocks.map(&:mu).reduce(&:hconcat)
+    end
+
+    def convergence
+      blocks.map(&:convergence).reduce(:+)
+    end
+
+    def save
+      blocks.map &:save
+    end
+
+    def load data
+      # raise "Hell!" unless data.size == 2
+      fit = -> (*args) { raise "Should never be called" }
+      @blocks = data.map do |block_data|
+        ndims = block_data.first.size
+        XNES.new(ndims, fit, opt_type).tap do |nes|
+          nes.load block_data
+        end
+      end
+    end
+  end
+end