machine_learning_workbench 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: baafa2eb71e8bbcc83d6a320437c2a0ad8f5544e
-  data.tar.gz: 5337ad91449767ca2754b41b2784212bfe5fbae7
+  metadata.gz: afdd4f1bf99c2abbe10f4c348531f4efabde3c73
+  data.tar.gz: 2334e9b7e5c4f276f94e75dd50164f8fa78cc699
 SHA512:
-  metadata.gz: 276d67ea700d5d9a6c0ee450cf0839438c77d7b7ce8dce87173b13a0898d0615cf30cc1f803686cb2da9e76953e601f8e702948853b2332cdffd57f7250ed72f
-  data.tar.gz: 3b9e2fdee7f0435d4acd52b902de928705e021f2e1715b58a09128d69cf129e4aaa7ad8f33d0545a74761d0b2345aa8df6a3ac112b7ebb8c67002431e686ce90
+  metadata.gz: 4f51ca6077627401bb1c27dfaed60cb84e5d70bdebe2f7c6d366abae299040e32ec7a4a1ad1ee3dc8ccc9aaa536a4125e91c2e97eaf043115d21e5e41d6a8e70
+  data.tar.gz: 884493c20fde5e8ac707f6c00b442d924a7dab5d783cf011926c2425b92116eea2bd1f10116a026b9b55db2210d918aa533eb0a6bc259b7bd0704df217b0985b

data/examples/neuroevolution.rb

@@ -8,13 +8,13 @@ FFNN = WB::NeuralNetwork::FeedForward
 
 # Let's address the XOR problem, as it requires nonlinear fitting
 XOR = {[0,0] => 0, [1,0] => 1, [0,1] => 1, [1,1] => 0}
-# A classic [2,2,1] feed-forward network will do: 2 inputs, 2 hidden, 1 output
-# For other uses, make sure you match the first number to the number of inputs, and
-# the last one as the number of outputs; then add as many layers as needed, by
-# specifying the size of each. Here we have only one, of size 2.
-# NOTE: If this totals thousands of weights, you may want to switch to SNES or BDNES
-# for speed. In the second case, use the function `nweights_per_layer` when instantiating
-# BDNES rather than `nweights`.
+# A classic [2,2,1] (2 inputs, 2 hidden neurons, 1 output neurons) feed-forward
+# network with nonlinear activations can solve this problem.
+# To approximate more complex functions, keep the number of inputs and outputs
+# fixed (they depend on the problem) and increase the number and/or size of
+# hidden neurons. For example: [2, 10, 7, 4, 1].
+# NOTE: If your network grows above few thousands of weights, XNES may be too slow.
+# Try using SNES for large shallow networks or BDNES for deep networks.
 NET = FFNN.new [2,2,1], act_fn: :logistic
 # Note: the process is exactly the same, from instantiation to training, for recurrent
 # networks using the class `WB::NeuralNetwork::Recursive`.
@@ -35,8 +35,8 @@ def fitness weights
   # - observation: correct value, our target
   pred_obs = XOR.map do |input, obs|
     # The network can have an arbitrary number of output neurons
-    # Since here we have only one, we extract the value calling `#first`
-    output = NET.activate(input).first
+    # Since here we have only one, we extract the value as the output
+    output = NET.activate(input)[0]
     # Here we interpret the output as classification
     pred = output > 0.5 ? 1 : 0
     # Finally accumulate prediction-observation pairs
@@ -50,9 +50,12 @@ end
 # Next comes initializing the black-box stochastic optimization algorithm
 # We are searching for the network's weights, this gives us the search space dimensionality
 # We'll use XNES as we are working with less than 100 dimensions (weights)
-nes = XNES.new NET.nweights, method(:fitness), :max, rseed: 15
-# Note: the random seed is fixed here to ensure the task is solved in one try in few iterations
-# In a real task, best using an over-large network, more iterations, and try several seeds
+nes = XNES.new NET.nweights, method(:fitness), :max, rseed: 0
+# Note BDNES requires `NET.nweights_per_layer` rather than `NET.nweights` in initialization:
+# nes = WB::Optimizer::NaturalEvolutionStrategies::BDNES.new NET.nweights_per_layer,
+#   method(:fitness), :max, rseed: 10
+# The random seed is fixed here to ensure a reproducible behavior
+# In a real task, best using an oversized network, more iterations, and try several seeds
 
 # NOTE: In practical applications it is best to delegate parallelization to the fitness
 # function instead of computing the fitness of one individual at a time. This can be
@@ -60,16 +63,20 @@ nes = XNES.new NET.nweights, method(:fitness), :max, rseed: 15
 # setting the `parallel_fit` switch to `true`:
 # nes = XNES.new NET.nweights,
 #   -> (genotypes) { Parallel.map genotypes, &method(:fitness) },
-#   :max, rseed: 15, parallel_fit: true
+#   :max, rseed: 0, parallel_fit: true
 
 
-# Nothing left but to run the optimization algorithm, few epochs here will suffice
+# Nothing left but to run the optimization algorithm
+# Depending on the random seed (read: luck)few epochs here will suffice
 50.times { nes.train }
 # OK! now remember, `NET` currently holds the weights of the last evaluation
 # Let's fetch the best individual found so far
 best_fit, best_weights = nes.best
 # Let's run them again to check they work
-result = fitness best_weights # careful here if you defined a parallel `fitness`
-puts "The found network achieves a score of #{result} out of 4 in the XOR task"
-puts "Weights: #{best_weights}"
+result = fitness best_weights
+# Note if you defined a parallel fitness above you'll need instead
+# result = fitness([best_weights])[0]
+puts "The found network achieves a score of #{result} out of #{XOR.size} in the XOR task"
+puts "Weights: #{best_weights.to_a}"
 puts "Done!"
+# That's it! 18 lines and you got a working neuroevolution algorithm, congrats :)

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

@@ -35,7 +35,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
 
     # Box-Muller transform: generates standard (unit) normal distribution samples
     # @return [Float] a single sample from a standard normal distribution
-    # @note Xumo::NArray implements this :) glad to have switched!
+    # @note Xumo::NArray implements this but no random seed selection yet
     def standard_normal_sample
       rho = Math.sqrt(-2.0 * Math.log(rng.rand))
       theta = 2 * Math::PI * rng.rand
@@ -80,7 +80,7 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     # Samples a standard normal distribution to construct a NArray of
     #   popsize multivariate samples of length ndims
     # @return [NArray] standard normal samples
-    # @note Xumo::NArray implements this :) glad to have switched!
+    # @note Xumo::NArray implements this but no random seed selection yet
     def standard_normal_samples
       NArray.zeros([popsize, ndims]).tap do |ret|
         ret.each_with_index { |_,*i| ret[*i] = standard_normal_sample }
@@ -104,8 +104,9 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
     # 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 # Xumo::NArray implements the Box-Muller :)
-      samples = NArray.new([popsize, ndims]).rand_norm(0,1)
+      # Xumo::NArray implements the Box-Muller, but no random seed (yet)
+      samples = standard_normal_samples
+      # samples = NArray.new([popsize, ndims]).rand_norm(0,1)
       inds = move_inds(samples)
       fits = parallel_fit ? obj_fn.call(inds) : inds.map(&obj_fn)
       # Quick cure for NaN fitnesses

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: machine_learning_workbench
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Giuseppe Cuccu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-05 00:00:00.000000000 Z
+date: 2018-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler