machine_learning_workbench 0.2.1 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f393f2183c3371081f694e47e35a14cf93997098
-  data.tar.gz: 754c861e440af0a40a5e328dfdde143a5e1bff59
+  metadata.gz: 1a0550319ef523cd49f7c09b635a4e21508cf730
+  data.tar.gz: b3fb9a716bfac1850bc5af0c8abf96f17f0292b6
 SHA512:
-  metadata.gz: 9ed7f6be2d1ed63dd00f26dc8d4b4e47c3ece23c80192bc877c4acaa1c03e1f37a34a64e32b7c6f4af2993439492b39e20f17110f50a14add762345685485fff
-  data.tar.gz: e6d116d1a8011da42a24ad3b10209e3764cb3195e6f3149659b9d91a637a029b0ffe9b50f47f7cbed4fd9970ceb7a112884b54f0c566561b9121c434e1455d4c
+  metadata.gz: 51b05034a2fffcc135388c5760b14067728d4fcf7210ff47d4a7f58f66fb174d3940fd538e3551a78d9df24a0c14b01e0f277aba2ceb898d7206302f8c30721b
+  data.tar.gz: 0dd1cf85fdb8577278882fe197e90032b1061a11fec9176b8d64ef38b97140876059ec964199007f52840eaab13ca2a25b2b01b8d0935c5f55c2ffc518f59124

data/README.md

@@ -43,7 +43,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/machine_learning_workbench.
+Bug reports and pull requests are welcome on GitHub at https://github.com/giuse/machine_learning_workbench.
 
 ## License
 
@@ -53,9 +53,9 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 Please feel free to contribute to this list (see `Contributing` above).
 
-- NES stands for Natural Evolution Strategies. Check its [Wikipedia page](https://en.wikipedia.org/wiki/Natural_evolution_strategy) for more info.
-- CMA-ES stands for Covariance Matrix Adaptation Evolution Strategy. Check its [Wikipedia page](https://en.wikipedia.org/wiki/CMA-ES) for more info.
-- UL-ELR stands for Unsupervised Learning plus Evolutionary Reinforcement Learning, from the paper _"Intrinsically Motivated Neuroevolution for Vision-Based Reinforcement Learning" (ICDL2011)_. Check [here](https://exascale.info/members/giuseppe-cuccu/) for citation reference and pdf.
-- BD-NES stands for Block Diagonal Natural Evolution Strategies, from the homonymous paper _"Block Diagonal Natural Evolution Strategies" (PPSN2012)_. Check [here](https://exascale.info/members/giuseppe-cuccu/) for citation reference and pdf.
+- **NES** stands for Natural Evolution Strategies. Check its [Wikipedia page](https://en.wikipedia.org/wiki/Natural_evolution_strategy) for more info.
+- **CMA-ES** stands for Covariance Matrix Adaptation Evolution Strategy. Check its [Wikipedia page](https://en.wikipedia.org/wiki/CMA-ES) for more info.
+- **UL-ELR** stands for Unsupervised Learning plus Evolutionary Reinforcement Learning, from the paper _"Intrinsically Motivated Neuroevolution for Vision-Based Reinforcement Learning" (ICDL2011)_. Check [here](https://exascale.info/members/giuseppe-cuccu/) for citation reference and pdf.
+- **BD-NES** stands for Block Diagonal Natural Evolution Strategy, from the homonymous paper _"Block Diagonal Natural Evolution Strategies" (PPSN2012)_. Check [here](https://exascale.info/members/giuseppe-cuccu/) for citation reference and pdf.
+- **RNES** stands for Radial Natural Evolution Strategy, from the paper _"Novelty-Based Restarts for Evolution Strategies" (CEC2011)_. Check [here](https://exascale.info/members/giuseppe-cuccu/) for citation reference and pdf.
 - **Online VQ** stands for Online Vector Quantization, from the paper _"Intrinsically Motivated Neuroevolution for Vision-Based Reinforcement Learning" (ICDL2011)_. Check [here](https://exascale.info/members/giuseppe-cuccu/) for citation reference and pdf.
-

data/lib/machine_learning_workbench/compressor.rb

@@ -1 +1,2 @@
 require_relative 'compressor/vector_quantization'
+require_relative 'compressor/online_vector_quantization'

data/lib/machine_learning_workbench/compressor/online_vector_quantization.rb

@@ -3,25 +3,27 @@ module MachineLearningWorkbench::Compressor
   # Optimized for online training.
   class OnlineVectorQuantization < VectorQuantization
 
-    attr_reader :min_lrate, :ntrains
+    attr_reader :min_lrate
 
     def initialize min_lrate: 0.01, **opts
       super **opts.merge({lrate: nil})
       @min_lrate = min_lrate
-      @ntrains = [0]*ncentrs
     end
 
+    # Overloading lrate check from original VQ
+    def check_lrate lrate; nil; end
+
     # Decaying per-centroid learning rate.
     # @param centr_idx [Integer] index of the centroid
     # @param lower_bound [Float] minimum learning rate
+    # @note nicely overloads the `attr_reader` of parent class
     def lrate centr_idx, lower_bound: min_lrate
       [1/ntrains[centr_idx], lower_bound].max
     end
 
-    # Train on one image
-    # @return [Integer] index of trained centroid
-    def train_one *args, **opts
-      super.tap { |trg_idx| ntrains[trg_idx] += 1 }
+    def train_one *args, **kwargs
+      raise NotImplementedError, "Remember to overload this using the new lrate(idx)"
     end
+
   end
 end

data/lib/machine_learning_workbench/compressor/vector_quantization.rb

@@ -2,7 +2,7 @@ module MachineLearningWorkbench::Compressor
 
   # Standard Vector Quantization
   class VectorQuantization
-    attr_reader :ncentrs, :centrs, :dims, :vrange, :dtype, :lrate, :rng
+    attr_reader :ncentrs, :centrs, :dims, :vrange, :dtype, :lrate, :rng, :ntrains
     Verification = MachineLearningWorkbench::Tools::Verification
 
     def initialize ncentrs:, dims:, vrange:, dtype:, lrate:, rseed: Random.new_seed
@@ -10,15 +10,24 @@ module MachineLearningWorkbench::Compressor
       @ncentrs = ncentrs
       @dtype = dtype
       @dims = Array(dims)
+      check_lrate lrate # hack: so that we can overload it in online_vq
       @lrate = lrate
       @vrange = case vrange
         when Array
           raise ArgumentError, "vrange size not 2: #{vrange}" unless vrange.size == 2
           vrange.map &method(:Float)
-        when Range then [vrange.first, vrange.last].map &method(:Float)
+        when Range
+          [vrange.first, vrange.last].map &method(:Float)
         else raise ArgumentError, "vrange: unrecognized type: #{vrange.class}"
       end
       @centrs = ncentrs.times.map { new_centr }
+      @ntrains = [0]*ncentrs # useful to understand what happens
+    end
+
+    # Verify lrate to be present and withing unit bounds
+    # As a separate method only so it can be overloaded in online_vq
+    def check_lrate lrate
+      raise ArgumentError, "Pass a `lrate` between 0 and 1" unless lrate&.between?(0,1)
     end
 
     # Creates a new (random) centroid
@@ -66,6 +75,8 @@ module MachineLearningWorkbench::Compressor
     end
 
     # Returns index and similitude of most similar centroid to vector
+    # @return [Array<Integer, Float>] the index of the most similar centroid,
+    #   followed by the corresponding similarity
     def most_similar_centr vec
       simils = similarities vec
       max_simil = simils.max
@@ -74,17 +85,20 @@ module MachineLearningWorkbench::Compressor
     end
 
     # Per-pixel errors in reconstructing vector
+    # @return [NMatrix] residuals
     def reconstr_error vec
       reconstruction(vec) - vec
     end
 
     # Train on one vector
-    # @param vec [NMatrix]
     # @return [Integer] index of trained centroid
-    def train_one vec, simils: nil
-      trg_idx, _simil = simils || most_similar_centr(vec)
+    def train_one vec
+
+      trg_idx, _simil = most_similar_centr(vec)
+      # note: uhm that actually looks like a dot product... optimizable?
+      #   `[c[i], vec].dot([1-lrate, lrate])`
       centrs[trg_idx] = centrs[trg_idx] * (1-lrate) + vec * lrate
-      Verification.in_range! centrs[trg_idx], vrange
+      # Verification.in_range! centrs[trg_idx], vrange # I verified it's not needed
       trg_idx
     end
 
@@ -94,7 +108,11 @@ module MachineLearningWorkbench::Compressor
       # - Batch: canonical, centrs updated with each vec
       # - Parallel: could be parallel either on simils or on training (?)
       # Unsure on the correctness of either Parallel, let's stick with Batch
-      vec_lst.each { |vec| train_one vec; print '.' if debug }
+      vec_lst.each_with_index do |vec, i|
+        trained_idx = train_one vec
+        print '.' if debug
+        ntrains[trained_idx] += 1
+      end
     end
   end
 end

data/lib/machine_learning_workbench/monkey.rb

@@ -145,9 +145,29 @@ module MachineLearningWorkbench::Monkey
     end
 
 
+    # The NMatrix documentation refers to a function `#nrm2` (aliased to `#norm2`)
+    # to compute the norm of a matrix. Fun fact: that is the implementation for vectors,
+    # and calling it on a matrix returns NotImplementedError :) you have to toggle the
+    # source to understand why:
+    # http://sciruby.com/nmatrix/docs/NMatrix.html#method-i-norm2 .
+    # A search for the actual source on GitHub reveals a (I guess new?) method
+    # `#matrix_norm`, with a decent choice of norms to choose from. Unfortunately, as the
+    # name says, it is stuck to compute full-matrix norms.
+    # So I resigned to dance to `Array`s and back, and implemented it with `#each_rank`.
+    # Unexplicably, I get a list of constant values as the return value; same with
+    # `#each_row`.
+    # What can I say, we're back to referencing rows by index. I am just wasting too much
+    # time figuring out these details to write a generalized version with an optional
+    # `dimension` to go along.
+    # @return [NMatrix] the vector norm along the rows
+    def row_norms
+      norms = rows.times.map { |i| row(i).norm2 }
+      NMatrix.new [rows, 1], norms, dtype: dtype
+    end
+
     # `NMatrix#to_a` has inconsistent behavior: single-row matrices are
     # converted to one-dimensional Arrays rather than a 2D Array with
-    # only one row. Patching `#to_a` directly is not feasible as the 
+    # only one row. Patching `#to_a` directly is not feasible as the
     # constructor seems to depend on it, and I have little interest in
     # investigating further.
     # @return [Array<Array>] a consistent array representation, such that
@@ -187,6 +207,16 @@ module MachineLearningWorkbench::Monkey
       end
     end
   end
+
+  module CPtrDumpable
+    def marshall_dump
+      [shape, dtype, data_pointer]
+    end
+
+    def marshall_load
+      raise NotImplementedError, "There's no setter for the data pointer!"
+    end
+  end
 end
 
 Array.include MachineLearningWorkbench::Monkey::Dimensionable
@@ -195,3 +225,4 @@ require 'nmatrix/lapack_plugin' # loads whichever is installed between atlas and
 NMatrix.include MachineLearningWorkbench::Monkey::AdvancelyOperationable
 Numeric.include MachineLearningWorkbench::Monkey::NumericallyApproximatable
 NMatrix.include MachineLearningWorkbench::Monkey::MatrixApproximatable
+NMatrix.include MachineLearningWorkbench::Monkey::CPtrDumpable

data/lib/machine_learning_workbench/neural_network/base.rb

@@ -119,15 +119,18 @@ module MachineLearningWorkbench::NeuralNetwork
     end
 
     # Loads a plain list of weights into the weight matrices (one per layer).
-    # Preserves order.
+    # Preserves order. Reuses allocated memory if available.
     # @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 ArgumentError unless weights.size == nweights
       weights_iter = weights.each
-      @layers = layer_shapes.collect do |shape|
-        NMatrix.new(shape, dtype: dtype) { weights_iter.next }
+      @layers ||= layer_shapes.collect { |shape| NMatrix.new shape, dtype: dtype }
+      layers.each do |nmat|
+        nmat.each_with_indices do |_val, *idxs|
+          nmat[*idxs] = weights_iter.next
+        end
       end
       reset_state
       return true
@@ -200,6 +203,11 @@ module MachineLearningWorkbench::NeuralNetwork
       lambda { |x| 1.7159 * Math.tanh(2.0*x/3.0) + 1e-3*x }
     end
 
+    # Rectified Linear Unit (ReLU)
+    def relu
+      lambda { |x| x>0 && x || 0 }
+    end
+
 
     # @!method interface_methods
     # Declaring interface methods - implement in child class!

data/lib/machine_learning_workbench/optimizer.rb

@@ -4,4 +4,7 @@ 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/rnes'
+# FIX SPECS FIRST
+# require_relative 'optimizer/natural_evolution_strategies/fnes'
 require_relative 'optimizer/natural_evolution_strategies/bdnes'

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

@@ -0,0 +1,11 @@
+
+module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
+  # Fixed Variance Natural Evolution Strategies
+  class FNES < RNES
+
+    def train picks: sorted_inds
+      g_mu = utils.dot(picks)
+      @mu += sigma.dot(g_mu.transpose).transpose * lrate
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+
+module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
+  # Radial Natural Evolution Strategies
+  class RNES < Base
+    attr_reader :variance
+
+    def initialize_distribution mu_init: 0, sigma_init: 1
+      @mu = NMatrix.new([1, ndims], mu_init, dtype: dtype)
+      raise ArgumentError unless sigma_init.kind_of? Numeric
+      @variance = sigma_init
+      @sigma = id * variance
+    end
+
+    def train picks: sorted_inds
+      g_mu = utils.dot(picks)
+      g_sigma = utils.dot(picks.row_norms**2 - ndims).first # back to scalar
+      @mu += sigma.dot(g_mu.transpose).transpose * lrate
+      @variance *= Math.exp(g_sigma * lrate / 2)
+      @sigma = id * variance
+    end
+
+    # Estimate algorithm convergence based on variance
+    def convergence
+      variance
+    end
+
+    def save
+      [mu.to_consistent_a, variance]
+    end
+
+    def load data
+      raise ArgumentError unless data.size == 2
+      mu_ary, @variance = data
+      @mu = NMatrix[*mu_ary, dtype: dtype]
+      @sigma = id * variance
+    end
+  end
+end

data/lib/machine_learning_workbench/tools/execution.rb

@@ -2,7 +2,9 @@ module MachineLearningWorkbench::Tools
   module Execution
     $fork_pids ||= []
 
-    # Execute block in a fork. Be sure to check also `#kill_forks`
+    # Executes block in a (detached) fork, saving the `pid` for later termination.
+    # @note add `ensure MachineLearningWorkbench::Tools.kill_forks` to the block
+    #    where `in_fork` is called (see `#kill_forks`).
     def self.in_fork &block
       raise ArgumentError "Need block to be executed in fork" unless block
       pid = fork(&block)
@@ -10,9 +12,12 @@ module MachineLearningWorkbench::Tools
       $fork_pids << pid
     end
 
-    # Call this in an `ensure` block after using `in_fork`
+    # Kills processes spawned by `#in_fork`.
+    # Call this in an `ensure` block after using `in_fork`.
+    # => `ensure MachineLearningWorkbench::Tools.kill_forks`
     def self.kill_forks
-      $fork_pids&.each { |pid| Process.kill 'KILL', pid }
+      $fork_pids&.each { |pid| Process.kill('KILL', pid) rescue Errno::ESRCH }
+      $fork_pids = []
     end
   end
 end

data/lib/machine_learning_workbench/tools/imaging.rb

@@ -18,11 +18,12 @@ module MachineLearningWorkbench::Tools
     end
 
     # Show a NMatrix as image in a RMagick window
-    # @param disp_size the size of the image to display
-    # @param shape the true shape of the image (NMatrix could be flattened)
+    # @param disp_size [Array] the size of the image to display
+    # @param shape [Array] the true shape of the image (NMatrix could be flattened)
     # @param in_fork [bool] whether to execute the display in fork (and continue running)
-    def self.display nmat, disp_size: [300, 300], shape: nil, in_fork: true
-      img = nmat_to_img(nmat, shape: shape).resize(*disp_size)
+    def self.display nmat, disp_size: nil, shape: nil, in_fork: true
+      img = nmat_to_img nmat, shape: shape
+      img.resize!(*disp_size, Magick::TriangleFilter,0.51) if disp_size
       if in_fork
         MachineLearningWorkbench::Tools::Execution.in_fork { img.display }
       else

data/lib/machine_learning_workbench/tools/verification.rb

@@ -1,6 +1,15 @@
 module MachineLearningWorkbench::Tools
   module Verification
     def self.in_range! nmat, vrange
+    # Raise if values not in range
+      vmin, vmax = vrange.to_a
+      nmat.each_with_indices do |v, *idxs|
+        raise "Value not in range" unless v&.between? vmin, vmax
+      end
+    end
+
+    # Fix if values not in range
+    def self.in_range nmat, vrange
       vmin, vmax = vrange.to_a
       nmat.each_with_indices do |v, *idxs|
         nmat[*idxs] = vmin if v < vmin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: machine_learning_workbench
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: '0.3'
 platform: ruby
 authors:
 - Giuseppe Cuccu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-14 00:00:00.000000000 Z
+date: 2018-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -185,6 +185,8 @@ files:
 - lib/machine_learning_workbench/optimizer.rb
 - lib/machine_learning_workbench/optimizer/natural_evolution_strategies/base.rb
 - lib/machine_learning_workbench/optimizer/natural_evolution_strategies/bdnes.rb
+- lib/machine_learning_workbench/optimizer/natural_evolution_strategies/fnes.rb
+- lib/machine_learning_workbench/optimizer/natural_evolution_strategies/rnes.rb
 - lib/machine_learning_workbench/optimizer/natural_evolution_strategies/snes.rb
 - lib/machine_learning_workbench/optimizer/natural_evolution_strategies/xnes.rb
 - lib/machine_learning_workbench/systems.rb