machine_learning_workbench 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8107a7a0b51fc50d183e08c6ef60e43bd96d4ea1
-  data.tar.gz: 82f7af0fd0938433d749696122e9ddc588f49aa0
+  metadata.gz: f393f2183c3371081f694e47e35a14cf93997098
+  data.tar.gz: 754c861e440af0a40a5e328dfdde143a5e1bff59
 SHA512:
-  metadata.gz: 07a342404b87066ab60217ad7e2bde8cbf89d23bb7d49b504a280ce1142456a70eb24b44b6f6c76b4a4f10dfddf219acd8c7f37e85e7f91548b24771752a798c
-  data.tar.gz: bc99aec41e7f9365d47068e69398462e04bcc8dd38dda090ba46e00d27a1e5485bf96a6d55f270c1ffcd6fe8d93223c52014d479634f8e0d48673ebe2eb00bb6
+  metadata.gz: 9ed7f6be2d1ed63dd00f26dc8d4b4e47c3ece23c80192bc877c4acaa1c03e1f37a34a64e32b7c6f4af2993439492b39e20f17110f50a14add762345685485fff
+  data.tar.gz: e6d116d1a8011da42a24ad3b10209e3764cb3195e6f3149659b9d91a637a029b0ffe9b50f47f7cbed4fd9970ceb7a112884b54f0c566561b9121c434e1455d4c

data/lib/machine_learning_workbench/neural_network/base.rb

@@ -17,23 +17,24 @@ module MachineLearningWorkbench::NeuralNetwork
     # @!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
+    attr_reader :layers, :state, :act_fn, :struct, :dtype
 
 
     ## 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
+    # @param dtype [NMatrix dtype] NMatrix dtype for weights and states
+    def initialize struct, act_fn: nil, dtype: :float32
       @struct = struct
-      @act_fn = self.class.act_fn(act_fn || :sigmoid)
+      @act_fn = self.get_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)
+        NMatrix.zeros([1, size], dtype: dtype)
       end
       # to this, append a matrix to hold the final network output
-      @state.push NMatrix.zeros([1, nneurs(-1)], dtype: :float64)
+      @state.push NMatrix.zeros([1, nneurs(-1)], dtype: dtype)
       reset_state
     end
 
@@ -126,7 +127,7 @@ module MachineLearningWorkbench::NeuralNetwork
       raise ArgumentError unless weights.size == nweights
       weights_iter = weights.each
       @layers = layer_shapes.collect do |shape|
-        NMatrix.new(shape, dtype: :float64) { weights_iter.next }
+        NMatrix.new(shape, dtype: dtype) { weights_iter.next }
       end
       reset_state
       return true
@@ -137,7 +138,7 @@ module MachineLearningWorkbench::NeuralNetwork
 
     # The "fixed `1`" used in the layer's input
     def bias
-      @bias ||= NMatrix[[1], dtype: :float64]
+      @bias ||= NMatrix[[1], dtype: dtype]
     end
 
     # Activate the network on a given input
@@ -168,10 +169,10 @@ module MachineLearningWorkbench::NeuralNetwork
 
     # 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
+    def get_act_fn type, *args
       fn = send(type,*args)
       lambda do |inputs|
-        NMatrix.new([1, inputs.size], dtype: :float64) do |_,i|
+        NMatrix.new([1, inputs.size], dtype: dtype) do |_,i|
           # single-row matrix, indices are columns
           fn.call inputs[i]
         end
@@ -179,14 +180,14 @@ module MachineLearningWorkbench::NeuralNetwork
     end
 
     # Traditional sigmoid with variable steepness
-    def self.sigmoid k=0.5
+    def 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
+    def logistic
       lambda { |x|
         exp = Math.exp(x)
         exp.infinite? ? exp : exp / (1.0 + exp)
@@ -195,7 +196,7 @@ module MachineLearningWorkbench::NeuralNetwork
 
     # LeCun hyperbolic activation
     # @see http://yann.lecun.com/exdb/publis/pdf/lecun-98b.pdf Section 4.4
-    def self.lecun_hyperbolic
+    def lecun_hyperbolic
       lambda { |x| 1.7159 * Math.tanh(2.0*x/3.0) + 1e-3*x }
     end
 
@@ -208,4 +209,4 @@ module MachineLearningWorkbench::NeuralNetwork
       end
     end
   end
-end
+end

data/lib/machine_learning_workbench/neural_network/feed_forward.rb

@@ -13,8 +13,8 @@ module MachineLearningWorkbench::NeuralNetwork
     # 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] )
+      act_fn.call(state[i].dot layers[i])
     end
 
   end
-end
+end

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

@@ -2,7 +2,7 @@
 module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
   # Natural Evolution Strategies base class
   class Base
-    attr_reader :ndims, :mu, :sigma, :opt_type, :obj_fn, :parallel_fit, :id, :rng, :last_fits, :best, :rescale_popsize, :rescale_lrate
+    attr_reader :ndims, :mu, :sigma, :opt_type, :obj_fn, :parallel_fit, :id, :rng, :last_fits, :best, :rescale_popsize, :rescale_lrate, :dtype
 
     # NES object initialization
     # @param ndims [Integer] number of parameters to optimize
@@ -11,22 +11,27 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     # @param rseed [Integer] allow for deterministic execution on rseed provided
     # @param mu_init [Numeric] values to initalize the distribution's mean
     # @param sigma_init [Numeric] values to initialize the distribution's covariance
-    # @param parallel_fit [boolean] whether the `obj_fn` should be passed all the individuals
-    #   together. In the canonical case the fitness function always scores a single individual;
-    #   in practical cases though it is easier to delegate the scoring parallelization to the
-    #   external fitness function. Turning this to `true` will make the algorithm pass _an
-    #   Array_ of individuals to the fitness function, rather than a single instance.
-    def initialize ndims, obj_fn, opt_type, rseed: nil, mu_init: 0, sigma_init: 1, parallel_fit: false, rescale_popsize: 1, rescale_lrate: 1
+    # @param parallel_fit [boolean] whether the `obj_fn` should be passed all the
+    #   individuals together. In the canonical case the fitness function always scores a
+    #   single individual; in practical cases though it is easier to delegate the scoring
+    #   parallelization to the external fitness function. Turning this to `true` will make
+    #   the algorithm pass _an Array_ of individuals to the fitness function, rather than
+    #   a single instance.
+    # @param rescale_popsize [Float] scaling for the default population size
+    # @param rescale_lrate [Float] scaling for the default learning rate
+    # @param dtype [NMatrix dtype] NMatrix dtype for all matrix computation
+    def initialize ndims, obj_fn, opt_type, rseed: nil, mu_init: 0, sigma_init: 1, parallel_fit: false, rescale_popsize: 1, rescale_lrate: 1, dtype: :float64
       raise ArgumentError unless [:min, :max].include? opt_type
       raise ArgumentError unless obj_fn.respond_to? :call
       @ndims, @opt_type, @obj_fn, @parallel_fit = ndims, opt_type, obj_fn, parallel_fit
       @rescale_popsize, @rescale_lrate = rescale_popsize, rescale_lrate
-      @id = NMatrix.identity(ndims, dtype: :float64)
+      @id = NMatrix.identity(ndims, dtype: dtype)
       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 = []
+      @dtype = dtype
       initialize_distribution mu_init: mu_init, sigma_init: sigma_init
     end
 
@@ -58,7 +63,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       total = log_range.reduce(:+)
       buf = 1.0/popsize
       vals = log_range.collect { |v| v / total - buf }.reverse
-      NMatrix[vals, dtype: :float64]
+      NMatrix[vals, dtype: dtype]
     end
 
     # (see #cmaes_utilities)
@@ -77,7 +82,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     #   popsize multivariate samples of length ndims
     # @return [NMatrix] standard normal samples
     def standard_normal_samples
-      NMatrix.new([popsize, ndims], dtype: :float64) { standard_normal_sample }
+      NMatrix.new([popsize, ndims], dtype: dtype) { standard_normal_sample }
     end
 
     # Move standard normal samples to current distribution
@@ -85,7 +90,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     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 = NMatrix[*inds.rows.times.collect {mu.to_a}, dtype: dtype].transpose
       (multi_mu + sigma.dot(inds.transpose)).transpose
       # sigma.dot(inds.transpose).transpose + inds.rows.times.collect {mu.to_a}.to_nm
     end
@@ -106,7 +111,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       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]
+      NMatrix[*sorted.map(&:last), dtype: dtype]
     end
 
     # @!method interface_methods

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

@@ -72,7 +72,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       block_samples = sorted_samples.transpose
 
       # then back to NMatrix for usage in training
-      block_samples.map { |sample| NMatrix[*sample, dtype: :float64] }
+      block_samples.map { |sample| NMatrix[*sample, dtype: dtype] }
     end
 
     # duck-type the interface: [:train, :mu, :convergence, :save, :load]
@@ -105,4 +105,4 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       end
     end
   end
-end
+end

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

@@ -6,10 +6,10 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     attr_reader :variances
 
     def initialize_distribution mu_init: 0, sigma_init: 1
-      @mu = NMatrix.new([1, ndims], mu_init, dtype: :float64)
+      @mu = NMatrix.new([1, ndims], mu_init, dtype: dtype)
       sigma_init = [sigma_init]*ndims unless sigma_init.kind_of? Enumerable
-      @variances = NMatrix.new([1,ndims], sigma_init, dtype: :float64)
-      @sigma = NMatrix.diagonal(variances, dtype: :float64)
+      @variances = NMatrix.new([1,ndims], sigma_init, dtype: dtype)
+      @sigma = NMatrix.diagonal(variances, dtype: dtype)
     end
 
     def train picks: sorted_inds
@@ -17,7 +17,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       g_sigma = utils.dot(picks**2 - 1)
       @mu += sigma.dot(g_mu.transpose).transpose * lrate
       @variances *= (g_sigma * lrate / 2).exponential
-      @sigma = NMatrix.diagonal(variances, dtype: :float64)
+      @sigma = NMatrix.diagonal(variances, dtype: dtype)
     end
 
     # Estimate algorithm convergence as total variance
@@ -32,9 +32,9 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     def load data
       raise ArgumentError unless data.size == 2
       mu_ary, variances_ary = data
-      @mu = NMatrix[*mu_ary, dtype: :float64]
-      @variances = NMatrix[*variances_ary, dtype: :float64]
-      @sigma = NMatrix.diagonal(variances, dtype: :float64)
+      @mu = NMatrix[*mu_ary, dtype: dtype]
+      @variances = NMatrix[*variances_ary, dtype: dtype]
+      @sigma = NMatrix.diagonal(variances, dtype: dtype)
     end
   end
 end

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

@@ -5,12 +5,12 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     attr_reader :log_sigma
 
     def initialize_distribution mu_init: 0, sigma_init: 1
-      @mu = NMatrix.new([1, ndims], mu_init, dtype: :float64)
+      @mu = NMatrix.new([1, ndims], mu_init, dtype: dtype)
       sigma_init = [sigma_init]*ndims unless sigma_init.kind_of? Enumerable
-      @sigma = NMatrix.diag(sigma_init, dtype: :float64)
+      @sigma = NMatrix.diag(sigma_init, dtype: dtype)
       # Works with the log of sigma to avoid continuous decompositions (thanks Sun Yi)
       log_sigma_init = sigma_init.map &Math.method(:log)
-      @log_sigma = NMatrix.diag(log_sigma_init, dtype: :float64)
+      @log_sigma = NMatrix.diag(log_sigma_init, dtype: dtype)
     end
 
     def train picks: sorted_inds
@@ -38,8 +38,8 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     def load data
       raise ArgumentError unless data.size == 2
       mu_ary, log_sigma_ary = data
-      @mu = NMatrix[*mu_ary, dtype: :float64]
-      @log_sigma = NMatrix[*log_sigma_ary, dtype: :float64]
+      @mu = NMatrix[*mu_ary, dtype: dtype]
+      @log_sigma = NMatrix[*log_sigma_ary, dtype: dtype]
       @sigma = log_sigma.exponential
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: machine_learning_workbench
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Giuseppe Cuccu