data_modeler 0.3.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 762480cf9239c43cfe81e82634a63b52b2ac1d28
-  data.tar.gz: 7554ba11f59112d0dddc39f80ad1c4b897fb02a0
+  metadata.gz: 173d569d4d705b32ca166d444766651f94b4a98d
+  data.tar.gz: ec61342d6188533751c874549c6f55d346d02bcb
 SHA512:
-  metadata.gz: 84547a8cf68c84f42a58aec83961b644315095aac87c33f30d2aa0cacfbd2f6b966b95ef060aae253866bdb2e4dd2f37bf29a662eaa5d2b14429d790ab68a03f
-  data.tar.gz: 2501a06535f433c6a58b45ccbad701c37ebb2be6c062ee9a2d627fa2a9f34235aa20dd88c57738af9f0d5f1f03a6c18fd4aa5336428d2bf0260f6682c57e7127
+  metadata.gz: 3cb220eeb8f7349321d35adb07efe919c9a23e9e0fe0459ca411b87632dd89ce21a7e1e04d350f1527e9e0f83b9924445b2c155c6af8fb9b71caace5b2600301
+  data.tar.gz: 74c46dea839cf5c1f99346ae197b7c87d06815c1d8c1e3c61238fac0801b6e20dd288efbaf7026f2a5991052c823a0179f48054473cbce4a628b5ff74f8b198d

data/data_modeler.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'data_modeler/version'
+require 'data_modeler/support'
 
 Gem::Specification.new do |spec|
   spec.name          = "data_modeler"

data/lib/data_modeler/base.rb

@@ -24,7 +24,7 @@ class DataModeler::Base
     @out_dir = prepare_output config[:results]
 
     @tset_gen = DataModeler::DatasetGen.new data, **opts_for(:datasetgen)
-    @model = DataModeler::Model.from_conf **opts_for(:learner)
+    @model = DataModeler::Models.selector **opts_for(:learner)
   end
 
   # Main control: up to `nruns` (or until end of data) loop train-test-save
@@ -49,13 +49,18 @@ class DataModeler::Base
   end
 
   # Attribute reader for instance variable `@save_models`, ending in '?' since
-  #    it's a boolean value.
+  # it's a boolean value.
   # @return [true|false] value of instance variable @save_models
   #    (false if nil/uninitialized)
   def save_models?
     @save_models || false
   end
 
+  # @return [String]
+  def to_s
+    config.to_s
+  end
+
   private
 
   # Loads the data in a Hash ready for `DatasetGen` (and `Dataset`)
@@ -97,13 +102,13 @@ class DataModeler::Base
     when :dataset
       { inputs: inputs,
         targets:  targets,
-        ntimes: config[:tset][:ntimes],
+        ninput_points: config[:tset][:ninput_points],
         tspread: config[:tset][:tspread],
         look_ahead: config[:tset][:look_ahead]
       }
     when :learner
       config[:learner].merge({
-        ninputs: (config[:tset][:ntimes] * inputs.size),
+        ninputs: (config[:tset][:ninput_points] * inputs.size),
         noutputs: targets.size
       })
     else abort "Unrecognized `who`: '#{who}'"

data/lib/data_modeler/dataset/dataset.rb

@@ -1,15 +1,12 @@
 
 # Build complex inputs and targets from the data to train the model.
-#
-# @note checks to validate if enough data is present (given `ntimes`, `tspread`
-#     and `look_ahead`) should be done on the caller (typically `DatasetGen`)
 class DataModeler::Dataset
 
   attr_reader :data, :input_series, :target_series, :first_idx, :end_idx,
-              :ntimes, :tspread, :look_ahead, :first_idx, :target_idx,
+              :ninput_points, :tspread, :look_ahead, :first_idx, :target_idx,
               :input_idxs, :nrows
 
-  # @param data [Hash-like] the data, in an object that can be
+  # @param data [Hash] the data, in an object that can be
   #     accessed by keys and return a time series per each key.
   #     It is required to include and be sorted by a series named `time`,
   #     and for all series to have equal length.
@@ -17,22 +14,22 @@ class DataModeler::Dataset
   # @param targets [Array] data key accessors for target series
   # @param first_idx [Integer] index where the dataset starts on data
   # @param end_idx [Integer] index where the dataset ends on data
-  # @param ntimes [Integer] number of lines/times/datapoints to be
+  # @param ninput_points [Integer] number of lines/datapoints to be
   #     used to construct the input
-  # @param tspread [Numeric] distance (in `time`!) between the `ntimes`
-  #     lines/times/datapoints used to construct the input
+  # @param tspread [Numeric] distance (in `time`!) between the `ninput_points`
+  #     lines/datapoints used to construct the input
   # @param look_ahead [Numeric] distance (in `time`!) between the
   #     most recent line/time/datapoint used for the input and
   #     the target -- i.e., how far ahead the model is trained to predict
   # @note we expect Datasets indices to be used with left inclusion but
   #     right exclusion, i.e. targets are considered in the range `[from,to)`
-  def initialize data, inputs:, targets:, first_idx:, end_idx:, ntimes:, tspread:, look_ahead:
+  def initialize data, inputs:, targets:, first_idx:, end_idx:, ninput_points:, tspread:, look_ahead:
     @data = data
     @input_series = inputs
     @target_series = targets
     @first_idx = first_idx
     @end_idx = end_idx
-    @ntimes = ntimes
+    @ninput_points = ninput_points
     @nrows = data[:time].size
     @tspread = tspread
     @look_ahead = look_ahead
@@ -92,9 +89,9 @@ class DataModeler::Dataset
     to_a.transpose
   end
 
-  # Overloaded comparison for easier testing
+  # Equality operator -- most useful in testing
   # @param other [Dataset] what needs comparing to
-  # @return [void]
+  # @return [true|false]
   def == other
     self.class == other.class && # terminate check here if wrong class
       data.object_id == other.data.object_id && # both `data` point to same object
@@ -120,7 +117,7 @@ class DataModeler::Dataset
   def init_inputs
     if target_idx < end_idx
       # build list of incremental time buffers
-      bufs = ntimes.times.collect { |n| look_ahead + n * tspread }
+      bufs = ninput_points.times.collect { |n| look_ahead + n * tspread }
       # reverse it and subtract from the target's time
       times = bufs.reverse.collect { |s| time(target_idx) - s }
       # now you have the list of times at which each pointer should point

data/lib/data_modeler/dataset/dataset_gen.rb

@@ -1,27 +1,32 @@
 
 # Build train and test datasets for each run of the training.
 #
-# This diagram should help understanding how it works
-# (win is the input+look_ahead window for first training target)
-#   ----------------------------------------> data (time)
-#   |win|train1|t1|       -> train starts after window, test after training
-#          |train2|t2|    -> train starts after window + 1 tset
-#             |train3|t3| -> train starts after window + 2 tset
+# Train and test sets are seen as moving windows on the data.
+# Alignment is designed to provide continuous testing results over (most of) the data.
+# The following diagram exemplifies this: the training sets `t1`, `t2` and `t3` are
+# aligned such that their results can be plotted countinuously against the obserevations.
+# (b) is the amount of data covering for the input+look_ahead window uset for the first
+# target.
+#   data:  ---------------------->  (time, datapoints)
+#   run1:  (b)|train1|t1|       ->  train starts after (b), test after training
+#   run2:        |train2|t2|    ->  train starts after (b) + 1 tset
+#   run3:           |train3|t3| ->  train starts after (b) + 2 tset
 # Note how the test sets line up. This allows the testing results plots
-# to be continuous, no model is tested on data on which *itself* has been
-# trained, and all data is used multiple times
+# to be continuous, while no model is tested on data on which _itself_ has been trained.
+# All data is used multiple times, alternately both as train and test sets.
 class DataModeler::DatasetGen
 
   attr_reader :data, :ds_args, :first_idx, :train_size, :test_size, :nrows
 
-  # @param data [Hash-like] the data, in an object that can be
+  # @param data [Hash] the data, in an object that can be
   #     accessed by keys and return a time series per each key.
-  #     It is required to include and be sorted by a series named `time`,
+  #     It is required to include (and be sorted by) a series named `:time`,
   #     and for all series to have equal length.
-  # @param ds_args [Hash] parameters for the Datasets: inputs, targets,
-  #     first_idx, end_idx, ntimes. Check class Dataset for details.
-  # @train_size: how many points to predict for each training set
-  # @test_size: how many points to predict for each test set
+  # @param ds_args [Hash] parameters hash for `Dataset`s initialization.
+  #     Keys: `%i[inputs, targets, first_idx, end_idx, ninput_points]`.
+  #     See `Dataset#initialize` for details.
+  # @param train_size [Integer] how many points to expose as targets in each training set
+  # @param test_size [Integer] how many points to expose as targets in each test set
   def initialize data, ds_args:, train_size:, test_size:, min_nruns: 1
     @data = data
     @ds_args = ds_args
@@ -36,22 +41,24 @@ class DataModeler::DatasetGen
 
   ### DATA ACCESS
 
-  # Builds training set for the training
-  # @param nrun [Integer] will build different train+test for each run
+  # Builds training sets for model training
+  # @param nrun [Integer] will build different trainset for each run
   # @return [Dataset]
   # @raise [NoDataLeft] when there's not enough data left for a full train+test
+  # @note train or test have no meaning alone, and train always comes first.
+  #     Hence, `#train` checks if enough `data` is available for both `train`+`test`.
   def train nrun
     first = min_eligible_trg + (nrun-1) * test_size
     last = first + train_size
-    # make sure there's enough data for both train and test
-    raise NoDataLeft unless last + test_size < nrows
+    raise NoDataLeft unless last + test_size < nrows  # make sure there's enough data
     DataModeler::Dataset.new data, ds_args.merge(first_idx: first, end_idx: last)
   end
 
-  # Builds test set for the training
-  # @param nrun [Integer] will build different train+test for each run
+  # Builds test sets for model testing
+  # @param nrun [Integer] will build different testset for each run
   # @return [Dataset]
-  # @note we already checked pre-training there's enough data for the test too
+  # @note train or test have no meaning alone, and train always comes first.
+  #     Hence, `#train` checks if enough `data` is available for both `train`+`test`.
   def test nrun
     first = min_eligible_trg + (nrun-1) * test_size + train_size
     last = first + test_size
@@ -62,13 +69,13 @@ class DataModeler::DatasetGen
 
   # TODO: @local_nrun is an ugly name, refactor it!
 
-  # Returns the next pair [trainset, testset]
+  # Returns the next pair `[trainset, testset]`
   # @return [Array<Dataset, Dataset>]
   def peek
     [self.train(@local_nrun), self.test(@local_nrun)]
   end
 
-  # Returns the next pair [trainset, testset] and increments the counter
+  # Returns the next pair `[trainset, testset]` and increments the counter
   # @return [Array<Dataset, Dataset>]
   def next
     peek.tap { @local_nrun += 1 }
@@ -106,7 +113,7 @@ class DataModeler::DatasetGen
   def min_eligible_trg
     @min_eligible_trg ||= idx( time(0) +
       # minimum time span required as input for the first target
-      ds_args[:look_ahead] + (ds_args[:ntimes]-1) * ds_args[:tspread]
+      ds_args[:look_ahead] + (ds_args[:ninput_points]-1) * ds_args[:tspread]
     )
   end
 

data/lib/data_modeler/dataset/{dataset_helper.rb → helper.rb}

@@ -3,7 +3,7 @@ class DataModeler::Dataset
   module ConvertingTimeAndIndices
     # Returns the time for a given index
     # @param [Integer] idx row index
-    # @return [kind_of_time]
+    # @return [type of `data[:time]`]
     def time idx
       data[:time][idx]
     end
@@ -25,10 +25,10 @@ class DataModeler::Dataset
     end
   end
 
-  # Provides each (which can return an `Iterator`) and `to_a` based on `#next`
+  # Provides `#each` (which can return an `Iterator`) and `#to_a` based on `#next`
   module IteratingBasedOnNext
     # Yields on each [inputs, targets] pair.
-    # @return [nil, Iterator] `block_given? ? nil : Iterator`
+    # @return [nil|Iterator] `block_given? ? nil : Iterator`
     def each
       reset_iteration
       return enum_for(:each) unless block_given?
@@ -36,8 +36,8 @@ class DataModeler::Dataset
       nil
     end
 
-    # Yields on each [inputs, targets] pair, collecting the input.
-    # @return [Array, Iterator] `block_given? ? nil : Iterator`
+    # Yields on each `[inputs, targets]` pair, collecting the input.
+    # @return [Array|Iterator] `block_given? ? nil : Iterator`
     def map
       reset_iteration
       return enum_for(:collect) unless block_given?

data/lib/data_modeler/models/fann.rb

@@ -0,0 +1,113 @@
+require 'ruby-fann'
+
+# Model the data using an artificial neural network, based on the
+# Fast Artificial Neural Networks (FANN) implementation
+class DataModeler::Models::FANN
+
+  attr_reader :fann_opts, :ngens, :fann, :algo, :actfn, :init_weights_range
+
+  # @param ngens [Integer] number of generations (repetitions) alloted for training
+  # @param hidden_layers [Array<Integer>] list of number of hidden neurons
+  #      per each hidden layer in the network
+  # @param ninputs [Integer] number of inputs in the network
+  # @param noutputs [Integer] number of outputs in the network
+  # @param algo [:rprop, :rwg, ...] training algorithm
+  # @param actfn [:sigmoid, ...] activation function
+  # @param init_weights_range [Array<min_w, max_w>] minimum and maximum value for weight initialization range
+  def initialize ngens:, hidden_layers:, ninputs:, noutputs:, algo: nil, actfn: nil, init_weights_range: nil
+    @fann_opts = {
+      num_inputs: ninputs,
+      hidden_neurons: hidden_layers,
+      num_outputs: noutputs
+    }
+    @ngens = ngens
+    @algo = algo
+    @actfn = actfn
+    @init_weights_range = init_weights_range
+    reset
+  end
+
+  # Resets / initializes the model
+  # @return [void]
+  def reset
+    @fann = RubyFann::Standard.new fann_opts
+    if algo && algo != :rwg
+      fann.set_training_algorithm(algo)
+    end
+    if actfn
+      fann.set_activation_function_hidden(actfn)
+      fann.set_activation_function_output(actfn)
+    end
+    if init_weights_range
+      fann.randomize_weights(*init_weights_range.map(&method(:Float)))
+    end
+  end
+
+  # Trains the model for ngens on the trainset
+  # @param trainset [Hash<input: Array, target: Array>] training set
+  # @param ngens [Integer] number of training generations
+  # @return [void]
+  def train trainset, ngens=@ngens, report_interval: 1000, desired_error: 1e-10
+    # special case: not implemented in FANN
+    if algo == :rwg
+      return train_rwg(trainset, ngens,
+        report_interval: report_interval, desired_error: desired_error)
+    end
+    # TODO: optimize maybe?
+    inputs, targets = trainset.values
+    tset = RubyFann::TrainData.new inputs: inputs, desired_outputs: targets
+    # fann.init_weights tset # test this weights initialization
+
+    # params: train_data, max_epochs, report_interval, desired_error
+    fann.train_on_data(tset, ngens, report_interval, desired_error)
+  end
+
+  # Trains the model for ngens on the trainset using Random Weight Guessing
+  # @param trainset [Hash-like<input: Array, target: Array>] training set
+  # @param ngens [Integer] number of training generations
+  # @return [void]
+  def train_rwg trainset, ngens=@ngens, report_interval: 1000, desired_error: 1e-10
+    # TODO: use report_interval and desired_error
+    # initialize weight with random values in an interval [min_weight, max_weight]
+    # NOTE: if the RWG training is unsuccessful, this range is the first place to
+    # check to improve performance
+    fann.randomize_weights(*init_weights_range.map(&method(:Float)))
+    # test it on inputs
+    inputs, targets = trainset.values
+    outputs = test(inputs)
+    # calculate RMSE
+    rmse_fn = -> (outs) do
+      sq_err = outs.zip(targets).flat_map do |os,ts|
+        os.zip(ts).collect { |o,t| (t-o)**2 }
+      end
+      Math.sqrt(sq_err.reduce(:+) / sq_err.size)
+    end
+    rmse = rmse_fn.call(outputs)
+    # initialize best
+    best = [fann,rmse]
+    # rinse and repeat
+    ngens.times do
+      outputs = test(inputs)
+      rmse = rmse_fn.call(outputs)
+      (best = [fann,rmse]; puts rmse) if rmse < best.last
+    end
+    # expose the best to the interface
+    fann = best.first
+  end
+
+  # Tests the model on inputs.
+  # @param inputs [Array<Array<inputs>>] sequence of inputs for the model
+  # @return [Array<Array<outputs>>] outputs corresponding to each input
+  def test inputs
+    inputs.collect { |i| fann.run i }
+  end
+
+  # Saves the model
+  # @param filename [String/path] where to save the model
+  # @return [void]
+  def save filename
+    # can do filename check here...?
+    # TODO: I'd like to have a kind of `to_s`, and do all the saving in the modeler...
+    fann.save filename.to_s
+  end
+end

data/lib/data_modeler/models/selector.rb

@@ -0,0 +1,18 @@
+
+# All models for the framework should belong to this module.
+# Also includes a model selector for initialization from config.
+module DataModeler::Models
+  # Returns a new `Model` based on the `type` of choice initialized
+  #     with `opts` parameters
+  # @param type [Symbol] selects the type of `Model`
+  # @param opts [**Hash] the rest of the parameters will be passed
+  #     to the model for its initialization
+  # @return [Model] an initialized `Model` of type `type`
+  def self.selector type:, **opts
+    case type
+    when :fann
+      FANN.new opts
+    else abort "Unrecognized model: #{type}"
+    end
+  end
+end

data/lib/data_modeler/support.rb

@@ -0,0 +1,41 @@
+
+# Main gem module
+module DataModeler
+
+  ### VERSION
+
+  # Version number
+  VERSION = "0.3.3"
+
+  ### HELPER FUNCTIONS
+
+  # Returns a standardized String ID from a (sequentially named) file
+  # @return [String]
+  # @note convenient method to have available in the config
+  def self.id_from_filename filename=__FILE__
+    format "%02d", Integer(filename[/_(\d+).rb$/,1])
+  end
+
+  # Returns an instance of the Base class
+  # @param config [Hash] Base class configuration
+  # @return [Base] initialized instance of Base class
+  def self.new config
+    DataModeler::Base.new config
+  end
+
+  ### EXCEPTIONS
+
+  class DataModeler::Dataset
+    # Exception: the requested `time` is not present in the data
+    class TimeNotFoundError < StandardError; end
+  end
+
+  class DataModeler::DatasetGen
+    # Exception: not enough `data` was provided for even a single train+test setup
+    class NotEnoughDataError < StandardError; end
+
+    # Exception: not enough `data` left to build another train+test
+    # @note subclassed from `StopIteration` -> it will break loops
+    class NoDataLeft < StopIteration; end
+  end
+end

data/lib/data_modeler.rb

@@ -1,16 +1,13 @@
-# Helpers
-require "data_modeler/version"
-require "data_modeler/exceptions"
-require "data_modeler/helpers"
+require "data_modeler/support"
 
 # Dataset
-require "data_modeler/dataset/dataset_helper"
+require "data_modeler/dataset/helper"
 require "data_modeler/dataset/dataset"
 require "data_modeler/dataset/dataset_gen"
 
 # Models
-require "data_modeler/model"
-require "data_modeler/model/fann"
+require "data_modeler/models/selector"
+require "data_modeler/models/fann"
 
-# Modeler
+# Framework core
 require "data_modeler/base"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_modeler
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.3
 platform: ruby
 authors:
 - Giuseppe Cuccu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-16 00:00:00.000000000 Z
+date: 2017-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-fann
@@ -159,12 +159,10 @@ files:
 - lib/data_modeler/base.rb
 - lib/data_modeler/dataset/dataset.rb
 - lib/data_modeler/dataset/dataset_gen.rb
-- lib/data_modeler/dataset/dataset_helper.rb
-- lib/data_modeler/exceptions.rb
-- lib/data_modeler/helpers.rb
-- lib/data_modeler/model.rb
-- lib/data_modeler/model/fann.rb
-- lib/data_modeler/version.rb
+- lib/data_modeler/dataset/helper.rb
+- lib/data_modeler/models/fann.rb
+- lib/data_modeler/models/selector.rb
+- lib/data_modeler/support.rb
 homepage: https://github.com/giuse/data_modeler
 licenses:
 - MIT

data/lib/data_modeler/exceptions.rb

@@ -1,12 +0,0 @@
-class DataModeler::Dataset
-  # Exception: the requested `time` is not present in the data
-  class TimeNotFoundError < StandardError; end
-end
-
-class DataModeler::DatasetGen
-  # Exception: the `data` is not sufficient for the training setup
-  class NotEnoughDataError < StandardError; end
-  # Exception: not enough `data` left to build another train+test
-  # @note being subclassed from `StopIteration`, it will break loops
-  class NoDataLeft < StopIteration; end
-end

data/lib/data_modeler/helpers.rb

@@ -1,17 +0,0 @@
-
-# Helper functions go here
-module DataModeler
-  # Returns a standardized String ID from a (sequentially named) file
-  # @return [String]
-  # @note convenient method to have available in the config
-  def self.id_from_filename filename=__FILE__
-    format "%02d", Integer(filename[/_(\d+).rb$/,1])
-  end
-
-  # Returns an instance of the Base class
-  # @param config [Hash] Base class configuration
-  # @return [Base] initialized instance of Base class
-  def self.new config
-    DataModeler::Base.new config
-  end
-end

data/lib/data_modeler/model/fann.rb

@@ -1,68 +0,0 @@
-require 'ruby-fann'
-
-# Model class based on Fast Artificial Neural Networks (FANN)
-class DataModeler::Model::FANN
-
-  attr_reader :fann_opts, :ngens, :fann, :algo, :actfn
-
-  # @param ngens [Integer] number of generations alloted for training
-  # @param hidden_layers [Array<Integer>] list of number of hidden neurons
-  #      per each hidden layer in the network
-  # @param ninputs [Integer] number of inputs of the network
-  # @param noutputs [Integer] number of outputs of the network
-  # @param algo [:incremental, :batch, :rprop, :quickprop] training algorithm
-  # @param actfn [:sigmoid, ...] activation function
-  def initialize ngens:, hidden_layers:, ninputs:, noutputs:, algo: nil, actfn: nil
-    @fann_opts = {
-      num_inputs: ninputs,
-      hidden_neurons: hidden_layers,
-      num_outputs: noutputs
-    }
-    @ngens = ngens
-    @algo = algo
-    @actfn = actfn
-    reset
-  end
-
-  # Resets / initializes the model
-  # @return [void]
-  def reset
-    @fann = RubyFann::Standard.new fann_opts
-    fann.set_training_algorithm(algo) if algo
-    if actfn
-      fann.set_activation_function_hidden(actfn)
-      fann.set_activation_function_output(actfn)
-    end
-    nil
-  end
-
-  # Trains the model for ngens on the trainset
-  # @param trainset [Hash-like<input: Array, target: Array>] training set
-  # @param ngens [Integer] number of training generations
-  # @return [void]
-  def train trainset, ngens=@ngens, report_interval: 1000, desired_error: 1e-10
-    # TODO: optimize maybe?
-    inputs, targets = trainset.values
-    tset = RubyFann::TrainData.new inputs: inputs, desired_outputs: targets
-    # fann.init_weights tset # test this weights initialization
-
-    # params: train_data, max_epochs, report_interval, desired_error
-    fann.train_on_data(tset, ngens, report_interval, desired_error)
-  end
-
-  # Tests the model on inputs.
-  # @param inputs [Array<Array<inputs>>] sequence of inputs for the model
-  # @return [Array<Array<outputs>>] outputs corresponding to each input
-  def test inputs
-    inputs.collect { |i| fann.run i }
-  end
-
-  # Save the model
-  # @param filename [String/path] where to save the model
-  # @return [void]
-  def save filename
-    # can do filename check here...?
-    # TODO: I'd like to have a kind of `to_s`, and do all the saving in the modeler...
-    fann.save filename.to_s
-  end
-end

data/lib/data_modeler/model.rb

@@ -1,17 +0,0 @@
-
-# All models for the framework should belong to this module.
-# Also includes a model selector for initialization from config.
-module DataModeler::Model
-  # Returns a new Model correctly initialized based on the `type` of choice
-  # @param type [Symbol] which type of Model is chosen
-  # @param opts [splatted Hash params] the rest of the parameters will be passed
-  #     to the model for initialization
-  # @return [Model] a correctly initialized Model of type `type`
-  def self.from_conf type:, **opts
-    case type
-    when :fann
-      FANN.new opts
-    else abort "Unrecognized model: #{type}"
-    end
-  end
-end

data/lib/data_modeler/version.rb

@@ -1,5 +0,0 @@
-# Main gem module
-module DataModeler
-  # Version number
-  VERSION = "0.3.0"
-end