machine_learning_workbench 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8897ba173dbfa944cf55b3ca7b57eb3af87bbff7
-  data.tar.gz: 44883310f216b187d5d3ccce669e85f946e6ee5f
+  metadata.gz: 1f580e6defa79dfb0c801b9e57c336b23fdea7e7
+  data.tar.gz: 0e4f17edef5773bdc78f38184028a916e14bb52b
 SHA512:
-  metadata.gz: 75d8a1f4d2087746dae316ca47c07925858826bdf393eddde7bb2f82e22b47e2d9c2c6bbaa6e0ce10fea1ccb0b9df1882e80b58519a2107f59732d6f99ea1a76
-  data.tar.gz: d4945335adc99edaabd26b56ac7bb49936d0642d58a09516ac63fae27e11d871db879e12db9cc3d0ec78788363c85c29558d382deb145713fa4051985e330f28
+  metadata.gz: c4810984620a1e19717465bafde01c908b3803cf872e49a326b6ee63788692d40b87623e053bd7e4c0563067dfd46f1117c4aebb6aca723f75dd6fef76857642
+  data.tar.gz: 7b93ca2e63b4d9f69aeb77efc552b8b94aeb2c52576041a41e30a1dc0cb924e78019cd00b6b5edffa49bac7c14a1d9ade9c1c0f1c6bfab0bc0ae1bf014df4ee5

data/lib/machine_learning_workbench/compressor/copy_vq.rb

@@ -41,7 +41,9 @@ module MachineLearningWorkbench::Compressor
       @next_train += 1
       # require 'pry'; binding.pry if next_train == ncentrs
       puts "Overwriting centr #{next_train}"
-      centrs[trg_idx] = vec
+      # norm_vec = vec / NLinalg.norm(vec)
+      # centrs[trg_idx, true] = norm_vec
+      centrs[trg_idx, true] = vec
       trg_idx
     end
 

data/lib/machine_learning_workbench/compressor/decaying_learning_rate_vq.rb

@@ -29,9 +29,12 @@ module MachineLearningWorkbench::Compressor
 
     # Train on one vector
     # @return [Integer] index of trained centroid
-    def train_one vec
+    def train_one vec, eps: nil
+      # NOTE: ignores epsilon if passed
       trg_idx, _simil = most_similar_centr(vec)
-      centrs[trg_idx] = centrs[trg_idx] * (1-lrate(trg_idx)) + vec * lrate(trg_idx)
+      # norm_vec = vec / NLinalg.norm(vec)
+      # centrs[trg_idx, true] = centrs[trg_idx, true] * (1-lrate(trg_idx)) + norm_vec * lrate(trg_idx)
+      centrs[trg_idx, true] = centrs[trg_idx, true] * (1-lrate(trg_idx)) + vec * lrate(trg_idx)
       trg_idx
     end
 

data/lib/machine_learning_workbench/compressor/incr_dict_vq.rb

@@ -11,12 +11,13 @@ module MachineLearningWorkbench::Compressor
 
     def initialize **opts
       puts "Ignoring learning rate: `lrate: #{opts[:lrate]}`" if opts[:lrate]
-      puts "Ignoring similarity: `simil_type: #{opts[:simil_type]}`" if opts[:simil_type]
+      puts "Ignoring similarity: `simil_type: #{opts[:simil_type]}`" unless opts[:simil_type] == :dot
       puts "Ignoring ncentrs: `ncentrs: #{opts[:ncentrs]}`" if opts[:ncentrs]
       # TODO: try different epsilons to reduce the number of states
       # for example, in qbert we care what is lit and what is not, not the colors
       @equal_simil = opts.delete(:equal_simil) || 0.0
-      super **opts.merge({ncentrs: 1, lrate: nil, simil_type: nil})
+      super **opts.merge({ncentrs: 1, lrate: nil, simil_type: :dot})
+
       @ntrains = nil # will disable the counting
     end
 
@@ -28,17 +29,23 @@ module MachineLearningWorkbench::Compressor
     # - create new centroid from the image
     # @return [Integer] index of new centroid
     def train_one vec, eps: equal_simil
-      mses = centrs.map do |centr|
-        ((centr-vec)**2).sum / centr.size # uhm get rid of division maybe? squares?
-      end
-      min_mse = mses.min
-      # skip training if the centr with smallest mse (most similar) has less than eps error (equal)
-      # TODO: maintain an average somewhere, make eps dynamic
-      return if min_mse < eps
-      puts "Creating centr #{ncentrs} (min_mse: #{min_mse})"
-      centrs << vec
-      @utility = @utility.concatenate 0
-      @ncentrs.tap{ @ncentrs += 1}
+      # NOTE:  novelty needs to be re-computed for each image, as after each
+      # training the novelty signal changes!
+
+# NOTE the reconstruction error here depends once more on the _color_
+# this is wrong and should be taken out of the equation
+# NOTE: this is fixed if I use the differences sparse coding method
+      residual_img = reconstr_error(vec)
+      rec_err = residual_img.mean
+      return -1 if rec_err < eps
+      puts "Creating centr #{ncentrs} (rec_err: #{rec_err})"
+      # norm_vec = vec / NLinalg.norm(vec)
+      # @centrs = centrs.concatenate norm_vec
+      # @centrs = centrs.concatenate vec
+      @centrs = centrs.concatenate residual_img
+      # HACK: make it more general by using `code_size`
+      @utility = @utility.concatenate [0] * (encoding_type == :sparse_coding_v1 ? 2 : 1)
+      ncentrs
     end
 
   end

data/lib/machine_learning_workbench/compressor/vector_quantization.rb

@@ -4,7 +4,7 @@ module MachineLearningWorkbench::Compressor
 
   # Standard Vector Quantization
   class VectorQuantization
-    attr_reader :ncentrs, :centrs, :dims, :vrange, :init_centr_vrange, :lrate,
+    attr_reader :centrs, :dims, :vrange, :init_centr_vrange, :lrate,
       :simil_type, :encoding_type, :rng, :ntrains, :utility, :ncodes
     attr_writer :utility, :ncodes # allows access from outside
 
@@ -12,12 +12,11 @@ module MachineLearningWorkbench::Compressor
 
       @rng = Random.new rseed # TODO: RNG CURRENTLY NOT USED!!
 
-      @ncentrs = ncentrs
       @dims = Array(dims)
       check_lrate lrate # hack: so that we can overload it in dlr_vq
       @lrate = lrate
-      @simil_type = simil_type || :dot
-      @encoding_type = encoding_type || :norm_ensemble
+      @simil_type = simil_type || raise("missing simil_type")
+      @encoding_type = encoding_type || raise("missing encoding_type")
       @init_centr_vrange ||= vrange
       @vrange = case vrange
         when Array
@@ -27,12 +26,21 @@ module MachineLearningWorkbench::Compressor
           [vrange.first, vrange.last].map &method(:Float)
         else raise ArgumentError, "vrange: unrecognized type: #{vrange.class}"
       end
-      init_centrs
-      @ntrains = [0]*ncentrs # useful to understand what happens
-      @utility = NArray.zeros [ncentrs] # trace how 'useful' are centroids to encodings
+      init_centrs nc: ncentrs
+      @ntrains = [0]*ncentrs              # per-centroid number of trainings
+      @utility = NArray.zeros [code_size] # trace how 'useful' are centroids to encodings
       @ncodes = 0
     end
 
+    def ncentrs
+      @centrs.shape.first
+    end
+
+    # HACKKETY HACKKETY HACK (can't wait to refactor after the deadline)
+    def code_size
+      encoding_type == :sparse_coding_v1 ? 2*ncentrs : ncentrs
+    end
+
     # Verify lrate to be present and withing unit bounds
     # As a separate method only so it can be overloaded in `DecayingLearningRateVQ`
     def check_lrate lrate
@@ -41,7 +49,7 @@ module MachineLearningWorkbench::Compressor
 
     # Initializes a list of centroids
     def init_centrs nc: ncentrs, base: nil, proport: nil
-      @centrs = nc.times.map { new_centr base, proport }
+      @centrs = nc.times.map { new_centr base, proport }.to_na
     end
 
     # Creates a new (random) centroid
@@ -56,39 +64,42 @@ module MachineLearningWorkbench::Compressor
       ret
     end
 
-    SIMIL = {
-      dot: -> (centr, vec) { centr.dot(vec) },
-      mse: -> (centr, vec) { -((centr-vec)**2).sum / centr.size }
-    }
+    # SIMIL = {
+    #   dot: -> (centr, vec) { centr.dot(vec) },
+    #   mse: -> (centr, vec) { -((centr-vec)**2).sum / centr.size }
+    # }
 
     # Computes similarities between vector and all centroids
     def similarities vec, type: simil_type
       raise NotImplementedError if vec.shape.size > 1
-      simil_fn = SIMIL[type] || raise(ArgumentError, "Unrecognized simil #{type}")
-      NArray[*centrs.map { |centr| simil_fn.call centr, vec }]
-      # require 'parallel'
-      # NArray[*Parallel.map(centrs) { |c| c.dot(vec).first }]
+      raise "need to check since centrs is a NArray now" if type == :mse
+      # simil_fn = SIMIL[type] || raise(ArgumentError, "Unrecognized simil #{type}")
+      # centrs.map { |centr| simil_fn.call centr, vec }
+      centrs.dot vec
     end
 
     # Encode a vector
     # tracks utility of centroids based on how much they contribute to encoding
     # TODO: `encode = Encodings.const_get(type)` in initialize`
     # NOTE: hashes of lambdas or modules cannot access ncodes and utility
+    # TODO: refactor anyway through `stats` object, this thing is getting out of hand
     def encode vec, type: encoding_type
-      simils = similarities vec
       case type
       when :most_similar
+        simils = similarities vec
         code = simils.max_index
         @ncodes += 1
         @utility[code] += 1
         code
       when :most_similar_ary
+        simils = similarities vec
         code = simils.new_zeros
         code[simils.max_index] = 1
         @ncodes += 1
         @utility += code
         code
       when :ensemble
+        simils = similarities vec
         code = simils
         tot = simils.sum
         tot = 1 if tot < 1e-5  # HACK: avoid division by zero
@@ -97,16 +108,140 @@ module MachineLearningWorkbench::Compressor
         @utility += (contrib - utility) / ncodes # cumulative moving average
         code
       when :norm_ensemble
+        simils = similarities vec
         tot = simils.sum
+        # NOTE this actually makes a big discontinuity if the total is equal to zero.
+        # Does that even ever happen? I guess only w/ reset img (zeros) as lone centroid.
+        # Which after first gen is really useless and should just be dropped anyway...
         tot = 1 if tot < 1e-5  # HACK: avoid division by zero
         code = simils / tot
+        @ncodes += 1
+        @utility += (code - utility) / ncodes # cumulative moving average
+        code
+      when :sparse_coding_v1
+        raise "requires centroids normalized to unit length!"
+        @encoder = nil if @encoder&.shape&.first != centrs.shape.first
+        # Danafar & Cuccu: compact form linear regression encoder
+        @encoder ||= (centrs.dot centrs.transpose).invert.dot centrs
+
+        raw_code = @encoder.dot(vec)
+        # separate positive and negative features (NOTE: all features will be positive)
+        # i.e. split[0...n] = max {0, raw[i]}; split[n...2*n] = max {0, -raw[i]}
+        # TODO: cite Coates & Ng
+        # TODO: optimize and remove redundant variables
+        split_code = raw_code.concatenate(-raw_code)
+        split_code[split_code<0] = 0
+        # normalize such that the code sums to 1
+        norm_code = split_code / split_code.sum
+        # Danafar: drop to say 80% of info (à la pca)
+        thold = 0.2
+        sparse_code = norm_code.dup
+        sum = 0
+        # NOTE: the last element in the sort below has the highest contribution and
+        # should NEVER be put to 0, even if it could contribute alone to 100% of the
+        # total
+        # NOTE: upon further study I disagree this represent information content unless
+        # the centroids are unit vectors. So I'm commenting this implementation now,
+        # together with the following, until I implement a switch to normalize the
+        # centroids based on configuration.
+
+
+
+        # BUG IN NARRAY SORT!! ruby-numo/numo-narray#97
+        # norm_code.sort_index[0...-1].each do |idx|
+        norm_code.size.times.sort_by { |i| norm_code[i] }[0...-1].each do |idx|
+
+
+
+          sparse_code[idx] = 0
+          sum += norm_code[idx]
+          break if sum >= thold # we know the code's total is normalized to 1 and has no negatives
+        end
+        code = sparse_code / sparse_code.sum # re-normalize sum to 1
+
+        @ncodes += 1
+        @utility += (code - utility) / ncodes # cumulative moving average
+        code
+       when :sparse_coding_v2
+        # Cuccu & Danafar: incremental reconstruction encoding
+        # turns out to be closely related to (Orthogonal) Matching Pursuit
+        raise "requires centroids normalized to unit length!"
+        # return centrs.dot vec # speed test for the rest of the system
+        sparse_code = NArray.zeros code_size
+        resid = vec
+        # cap the number of non-zero elements in the code
+        max_nonzero = [1,ncentrs/3].max
+        max_nonzero.times do |i|
+          # OPT: remove msc from centrs at each loop
+          # the algorithm should work even without this opt because
+          # we are working on the residuals each time
+          simils = centrs.dot resid
+
+
+
+          # BUG IN NARRAY SORT!! ruby-numo/numo-narray#97
+          # msc = simils.max_index
+          simils = simils.to_a
+          simils_abs = simils.map &:abs
+          msc = simils_abs.index simils_abs.max # most similar centroid
+
+
+
+          max_simil = simils[msc]
+          # remember to distinguish here to use the pos/neg features trick
+          sparse_code[msc] = max_simil
+          reconstr = max_simil * centrs[msc, true]
+          resid -= reconstr
+          # puts "resid#{i} #{resid.abs.mean}" # if debug
+          epsilon = 0.005
+          # print resid.abs.mean, ' '
+          # print sparse_code.to_a, ' '
+          break if resid.abs.mean <= epsilon
+        end
+
+        # should normalize sum to 1?
+        code = sparse_code #/ sparse_code.sum # normalize sum to 1
+
         @ncodes += 1
         @utility += (code - utility) / ncodes # cumulative moving average
         code
       when :sparse_coding
-        raise NotImplementedError, "do this next"
+        # Cuccu: Direct residual encoding
+        # return centrs.dot vec # speed test for the rest of the system
+        sparse_code = NArray.zeros code_size
+        resid = vec
+        # cap the number of non-zero elements in the code
+        max_nonzero = [1,ncentrs/3].max
+        max_nonzero.times do |i|
+          # OPT: remove msc from centrs at each loop
+          # the algorithm should work even without this opt because
+          # we are working on the residuals each time
+          diff = (centrs - resid).abs.sum(1)
+
 
 
+          # BUG IN NARRAY SORT!! ruby-numo/numo-narray#97
+          # msc = diff.max_index
+          diff = diff.to_a
+          msc = diff.index diff.min # most similar centroid
+
+
+
+          min_diff = diff[msc]
+          # remember to distinguish here to use the pos/neg features trick
+          sparse_code[msc] = 1
+          reconstr = centrs[msc, true]
+          resid -= reconstr
+          resid[(resid<0).where] = 0 # ignore artifacts introduced by the centroids in reconstruction
+
+          # puts "resid#{i} #{resid.abs.mean}" # if debug
+          epsilon = 0.005
+          # print resid.abs.mean, ' ' if $ngen == 2; exit if $ngen==3
+          # print sparse_code.to_a, ' ' if $ngen == 3; exit if $ngen==4
+          break if resid.abs.mean <= epsilon
+        end
+
+        code = sparse_code
         @ncodes += 1
         @utility += (code - utility) / ncodes # cumulative moving average
         code
@@ -118,16 +253,33 @@ module MachineLearningWorkbench::Compressor
     def reconstruction code, type: encoding_type
       case type
       when :most_similar
-        centrs[code]
+        centrs[code, true]
       when :most_similar_ary
-        centrs[code.eq(1).where[0]]
+        centrs[code.eq(1), true]
       when :ensemble
-        tot = code.reduce :+
-        centrs.zip(code).map { |centr, contr| centr*contr/tot }.reduce :+
+        # tot = code.reduce :+
+        # centrs.zip(code).map { |centr, contr| centr*contr/tot }.reduce :+
+        centrs.dot(code) / code.sum
       when :norm_ensemble
-        centrs.zip(code).map { |centr, contr| centr*contr }.reduce :+
+        centrs.dot code
+        # centrs.zip(code).map { |centr, contr| centr*contr }.reduce :+
+      when :sparse_coding_v1
+        raise "requires normalized centroids!"
+        reconstr_code = code[0...(code.size/2)] - code[(code.size/2)..-1]
+        reconstr = centrs.transpose.dot reconstr_code
+      when :sparse_coding_v2
+        raise "requires normalized centroids!"
+
+
+        # BUG IN NARRAY DOT!! ruby-numo/numo-narray#99
+        # reconstr = code.dot centrs
+        reconstr = code.expand_dims(0).dot centrs
+
+
       when :sparse_coding
-        raise NotImplementedError, "do this next"
+        # the code is binary, so just sum over the corresponding centroids
+        # note: sum, not mean, because of how it's used in reconstr_error
+        reconstr = centrs[code.cast_to(Numo::Bit).where, true].sum(0)
       else raise ArgumentError, "unrecognized reconstruction type: #{type}"
       end
     end
@@ -145,16 +297,23 @@ module MachineLearningWorkbench::Compressor
     # @return [NArray] residuals
     def reconstr_error vec, code: nil, type: encoding_type
       code ||= encode vec, type: type
-      (vec - reconstruction(code, type: type)).abs.sum
+      resid = vec - reconstruction(code, type: type)
+      # we ignore the extra stuff coming from the centroids,
+      # only care that everything in the obs is represented in centrs
+      resid[resid<0] = 0 if encoding_type == :sparse_coding
+      resid
     end
 
     # Train on one vector
     # @return [Integer] index of trained centroid
-    def train_one vec
+    def train_one vec, eps: nil
+      # NOTE: ignores epsilon if passed
       trg_idx, _simil = most_similar_centr(vec)
       # note: uhm that actually looks like a dot product... maybe faster?
       #   `[c[i], vec].dot([1-lrate, lrate])`
-      centrs[trg_idx] = centrs[trg_idx] * (1-lrate) + vec * lrate
+      # norm_vec = vec / NLinalg.norm(vec)
+      # centrs[trg_idx, true] = centrs[trg_idx, true] * (1-lrate) + norm_vec * lrate
+      centrs[trg_idx, true] = centrs[trg_idx, true] * (1-lrate) + vec * lrate
       trg_idx
     end
 

data/lib/machine_learning_workbench/neural_network/base.rb

@@ -53,6 +53,7 @@ module MachineLearningWorkbench::NeuralNetwork
     # Initialize the network with random weights
     def init_random
       # Reusing `#load_weights` instead helps catching bugs
+      deep_reset
       load_weights NArray.new(nweights).rand(-1,1)
     end
 

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

@@ -125,14 +125,20 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       # this_best = sorted.last.take(2)
       # NArray[*sorted.map(&:last)]
 
-      sort_idxs = fits.sort_index
+
+
+      # BUG IN NARRAY SORT!! ruby-numo/numo-narray#97
+      # sort_idxs = fits.sort_index
+      sort_idxs = fits.size.times.sort_by { |i| fits[i] }.to_na
+
+
+
       sort_idxs = sort_idxs.reverse if opt_type == :min
       this_best = [fits[sort_idxs[-1]], inds[sort_idxs[-1], true]]
-
       opt_cmp_fn = opt_type==:min ? :< : :>
       @best = this_best if this_best.first.send(opt_cmp_fn, best.first)
 
-      samples[sort_idxs,true]
+      samples[sort_idxs, true]
     end
 
     # @!method interface_methods

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

@@ -68,7 +68,15 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       # opt_cmp_fn = opt_type==:min ? :< : :>
       # @best = this_best if this_best.first.send(opt_cmp_fn, best.first)
       # sorted_samples = sorted.map(&:last)
-      sort_idxs = fits.sort_index
+
+
+
+      # BUG IN NARRAY SORT!! ruby-numo/numo-narray#97
+      # sort_idxs = fits.sort_index
+      sort_idxs = fits.size.times.sort_by { |i| fits[i] }.to_na
+
+
+
       sort_idxs = sort_idxs.reverse if opt_type == :min
       this_best = [fits[sort_idxs[-1]], full_inds[sort_idxs[-1], true]]
       opt_cmp_fn = opt_type==:min ? :< : :>

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

@@ -23,7 +23,8 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
       when Numeric
         NArray.new([ndims]).fill(sigma_init)
       else
-        raise ArgumentError, "Something is wrong with sigma_init: #{sigma_init}"
+        raise ArgumentError, "Something is wrong with sigma_init: #{sigma_init}" \
+          "(did you remember to copy the other cases from XNES?)"
       end
       @sigma = @variances.diag
     end

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

@@ -7,6 +7,11 @@ module MachineLearningWorkbench::Optimizer::NaturalEvolutionStrategies
 
     def initialize_distribution mu_init: 0, sigma_init: 1
       @mu = case mu_init
+        when Range # initialize with random in range
+          raise ArgumentError, "mu_init: `Range` start/end in `Float`s" \
+            unless mu_init.first.kind_of?(Float) && mu_init.last.kind_of?(Float)
+          mu_rng = Random.new rng.rand 10**Random.new_seed.size
+          NArray[*ndims.times.map { mu_rng.rand mu_init }]
         when Array
           raise ArgumentError unless mu_init.size == ndims
           NArray[mu_init]

data/lib/machine_learning_workbench/tools.rb

@@ -4,3 +4,4 @@ require_relative 'tools/execution'
 require_relative 'tools/normalization'
 require_relative 'tools/imaging'
 require_relative 'tools/verification'
+require_relative 'tools/logging'

data/lib/machine_learning_workbench/tools/logging.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module MachineLearningWorkbench::Tools
+  module Logging
+    # Splits calls to standard streams to be both displayed on terminal and saved to file
+    class LogSplitter < File
+      def initialize dest
+        fname = if File.directory?(dest)
+          "#{dest}/#{Time.now.strftime "%y%m%d_%H%M"}.log"
+        else dest
+        end
+        super fname, 'w'
+      end
+
+      def write *args
+        STDOUT.write *args
+        super
+      end
+    end
+
+    def self.split_to dest, also_stderr: false
+      $stdout = LogSplitter.new dest
+      $stderr = $stdout if also_stderr
+    end
+
+    def self.restore_streams
+      logger = $stdout
+      $stdout = STDOUT
+      $stderr = STDERR
+      logger.close
+    end
+  end
+end

data/machine_learning_workbench.gemspec

@@ -48,6 +48,6 @@ Gem::Specification.new do |spec|
   spec.requirements << "libopenblas-base"  # requirement for `numo-linalg`
   spec.requirements << "liblapacke"        # requirement for `numo-linalg`
   spec.add_dependency "numo-narray", "~> 0.9"
-  spec.add_dependency "numo-linalg", "~> 0.1.2"
+  spec.add_dependency "numo-linalg", "~> 0.1"
   spec.add_dependency "parallel", "~> 1.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: machine_learning_workbench
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Giuseppe Cuccu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-20 00:00:00.000000000 Z
+date: 2018-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -156,14 +156,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -223,6 +223,7 @@ files:
 - lib/machine_learning_workbench/tools.rb
 - lib/machine_learning_workbench/tools/execution.rb
 - lib/machine_learning_workbench/tools/imaging.rb
+- lib/machine_learning_workbench/tools/logging.rb
 - lib/machine_learning_workbench/tools/normalization.rb
 - lib/machine_learning_workbench/tools/verification.rb
 - machine_learning_workbench.gemspec