data_modeler 0.3.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb390503600e0270198476fd58e28fbeb7875b53
-  data.tar.gz: 5c57a5bdb492a069f4bfc6ffbec65b513fb94e82
+  metadata.gz: 3d0ab252517704c4fd6804f63eee8d4bcfb3e6d2
+  data.tar.gz: 9ef139759ba7f429a9738ab93656e63d9ee709c5
 SHA512:
-  metadata.gz: 1e951667d4207d4293ee9666ed786886528c496e272ea71e7ba7a885780ac5b84e2724f00d3beb97b5f143babe467c19881f3dd0014a4132816bc7e4188da734
-  data.tar.gz: d1b0bcc66cb30693d65370409d129a5102a9dfb6e65afca11be98efc125ba3b0c85df546feb01f2f5857445259cf441c9c7c60b150cda239ec6e5bc47c3a662e
+  metadata.gz: 11ab20819803dc44e5e73374089eabc6214a27a2f6b36ea3915e92c55964c21af01e8f932bea710e0184cc01aad42499c80768d3e4115c4920fc4d64d8c305fb
+  data.tar.gz: 129a0f555ad41c475902a136a805134a525019d3cc700a77c54cacb3ce8e9b9fad717c863e88593257a05638e5563e36ea0825456c552b556b34c38f8c752db6

data/.gitignore

@@ -8,6 +8,7 @@
 /spec/reports/
 /tmp/
 /data_modeler-*.gem
+todo
 
 # rspec failure tracking
 .rspec_status

data/README.md

@@ -1,40 +1,113 @@
 
 # [Data Modeler](https://github.com/giuse/data_modeler)
 
+
 [![Gem Version](https://badge.fury.io/rb/data_modeler.svg)](https://badge.fury.io/rb/data_modeler)
 [![Build Status](https://travis-ci.org/giuse/data_modeler.svg?branch=master)](https://travis-ci.org/giuse/data_modeler)
 [![Code Climate](https://codeclimate.com/github/giuse/data_modeler/badges/gpa.svg)](https://codeclimate.com/github/giuse/data_modeler)
 
-Using machine learning, create generative models based on your data alone. Applications span from imputation to prediction.
+
+#### Using machine learning, create generative models based on your data alone. Applications span from prediction to imputation and compression.
+
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add `gem 'data_modeler'` to your Gemfile then `$ bundle`, or install manually with `$ gem install data_modeler`.
+
+If you're new to Ruby or Bundler, check these detailed [installation instructions](installation.md) first.
+
+
+## Full documentation
+
+I wish for my code to stay well documented. If you find the documentation lacking or outdated, please do let me know. You can find it [here](http://www.rubydoc.info/gems/data_modeler/).
+
+
+## Getting started
+
+
+### Obtaining a working configuration on example data
+
+Make a copy of [`/spec/example`](spec/example) for you to play with.
+The `config*.rb` files are configuration examples. The configuration is written in a simple  Ruby `Hash`, and the files themselves can be directly executed with (i.e. run `ruby config_01.rb`) thanks to the few lines at the bottom.
+
+The `.csv` files are examples of the format the data must be pre-processed into beforehand: a CSV table with a numeric time as first column, followed by one column for each of the time series available. The data should be complete (i.e. no missing values) and already normalized (depending on the model of choice). The file [`prepare_demo_csv`](spec/example/prepare_demo_csv.rb) can help you getting started on the task, as it was used to generate the demo CSV.
+
+Start by just running one of the configurations, then play around with the config and customize them to your taste. And off you go!
+
+
+### Understanding the results
+
+Running a config file will create a folder holding the results; the path can be customized in the config file.  
+Note that `DataModeler#id_from` returns a numeric ID from the end of a string (e.g. file name), saving you from forgetting to update the output folder after creating a new config by copy.
+
+Inside the results folder you will find a result file (CSV) for each run. They follow the naming convention `tpredobs_<nrun>.csv` as to remind their internal structure:
+
+- First column is `time` and contains the timestamp of each target in the original data
+- Then come all the columns relative to predictions
+    - The naming pattern `p_<series name>` corresponds to the predicted values for series named "series name" in the original data.
+- Then come all the columns relative to observations
+    - The naming pattern `o_<series name>` corresponds to the observed values for series named "series name" in the original data.
 
-```ruby
-gem 'data_modeler'
-```
+Loading this raw result data allows for easy calculation of residuals and statistics, and to plot your predictions against the ground truth.
 
-And then execute:
 
-    $ bundle
+### Customizing your experiment
 
-Or install it yourself as:
+Outdated documentation is often worse than lack of documentation. To understand all configuration options, consider the following:
 
-    $ gem install data_modeler
+- All configuration keys but the last refer to the data: where to find the original data, where to save the results, and how to build the train/test sets. I guarantee there will be no default value for these configurations, making it necessary for all the options to be explicitly declared in all `config` files. So everything you find there is everything there is.
 
-## Usage
+- The (usually) last configuration key is named `:learner` and is model dependent, totally flexible.
+Its (usually) first key is `:type`: you will find a model of the same(ish) name in the folder [`lib/data_modeler/model`](lib/data_modeler/model). The initializer of this class receives the `:learner` sub-configuration hash minus the key `:type` (already consumed to select the model).
 
-Check `spec` folder for usage examples. I will update this section once the full framework is put up.
+This means that to know all available options you should rely on a previous config file, plus to the documentation (or implementation) of the `initialize` function of the model of choice (should be small).
 
-## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.  
-To install this gem onto your local machine, run `bundle exec rake install`.
+### Leveraging time series data
+
+There are three settings under `:tset` in the config which may be cryptic: `ninput_points`, `tspread` and `look_ahead`. Names can change in the future as I found it hard to name these three, please open an issue if I forget to modify this (or if you have suggestions).
+
+If you don't work with time series, just set them to [1,0,0], use a line counter for `time`, and ignore the following. These three only make sense if the data is composed of aligned time series, with a numeric column `time` -- its unit will also be the unit for `tspread` and `look_ahead`. 
+
+- ninput_points: how many points in time to construct the model's input. For example, if the number is 3, then data coming from 3 data lines is considered.
+- tspread: time spread between the data lines considered in the point above. For example, if the number is 2, then the data lines considered will have (at least) 2 time (units) between each other.
+- look_ahead: span between the most recent input considered and the target to be learned. For example, if the number is 5, then the target will be constructed from a data line which is (at least) 5 time (units) later than the most recent input.
+
+Example configurations:
+
+- ninput_points = 1, tspread = 0, look_ahead = 0 -> build input from one line, no spreading, predict results in same line. This is the basic configuration allowing same-timestep prediction, e.g. for static modeling or simple data imputation.
+- ninput_points = 4, tspread = 7, look_ahead = 7 -> hypothesize the unit of the column `time` to be days: build input from 4 lines spanning 21 days at one-week intervals (+ current), then use it to learn to predict one week ahead. This allows to train a proper time-ahead predictor, which will estimate the target at a constant one-week ahead interval.
+- ninput_points = 30, tspread = 1, look_ahead = 1 -> hypothesize the unit of the column `time` to be seconds: train a real-time predictor estimating a behavior one-second ahead based on 1s-spaced data over the past 29 seconds + current.
+
+Important: from each line, only the data coming from the listed input time series is considered for input, while the target time series list is used to construct the output.
+
+Example inputs and targets, considering t0 the "current" time for a given iteration:
+
+- ninput_points = 1, tspread = 0, look_ahead = 0, input_series = [s1, s4], targets = [s3]: inputs -> [s1t0, s2t0], targets = [s3t0]
+- ninput_points = 4, tspread = 7, look_ahead = 7, input_series = [s1, s4], targets = [s3, s5]: inputs -> [s1t-21, s2t-21, s1t-14, s2t-14, s1t-7, s2t-7, s1t0, s2t0], targets = [s3t0, s5t0]
+
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/giuse/data_modeler.
+
+### Suggestions / requests
+
+Feel free to open new issues. I mean it. We can work together from there.
+
+
+### Adding new models
+
+This system has by design a plug-in architecture. To add your own models, you just need to create a new wrapper in `lib/data_modeler/model`:
+
+- Duplicate the `fann.rb` model: it provides both instructions and template for the interface you need to present to the system
+- Duplicate the `spec/model/fann_spec.rb` spec: it will provide instructions on how to verify your model works with the system using some ready `shared_examples`.
+
+Ideally, a `DataModeler::Model` should be a wrapper around an external independent functionality: keep it as compact as possible. To implement the interface you can use BDD on the `spec`, which verifies both the availability of the interface and basic modeling capabilities. 
+
+Remember to update [`lib/data_modeler.rb`](lib/data_modeler.rb) to load your file, and add an option to select it in [`lib/data_modeler/model/selector.rb`](lib/data_modeler/model/selector.rb)
+
+THEN: please do propose a pull requests! Share your work with the community!  
+Even if you think it's not polished enough: I'll help out before accepting.
 
 
 ## License

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/support'
+require 'data_modeler/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "data_modeler"
@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Giuseppe Cuccu"]
   spec.email         = ["giuseppe.cuccu@gmail.com"]
 
-  spec.summary       = %q{Model your data with machine learning}
-  spec.description   = %q{Using machine learning, create generative models based on your data alone. Applications span from imputation to prediction. This build specifically leverages time series. Further work on data preparation will be released as a separate project.}
+  spec.summary       = %{Model your data with machine learning}
+  spec.description   = %{Using machine learning, create generative models based on your data alone. Applications span from prediction to imputation and compression. This build specifically leverages time series. NOTE: Since version 1.0.0 we're production-ready! :)}
   spec.homepage      = "https://github.com/giuse/data_modeler"
   spec.license       = "MIT"
 
@@ -18,12 +18,12 @@ Gem::Specification.new do |spec|
     f.match(%r{^(test|spec|features)/})
   end
   spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(/^exe\//, &File.method(:basename))
   spec.require_paths = ["lib"]
 
   # Models
   # TODO: learn to keep them independent from the gem (plug-ins)
-  spec.add_dependency 'ruby-fann', '~>1.2.6'
+  spec.add_dependency 'ruby-fann', '~>1.2'
 
   # Debug
   spec.add_development_dependency 'pry', '~> 0.10'

data/installation.md

@@ -0,0 +1,65 @@
+# Installation instructions
+
+New to Ruby? Welcome! :)
+
+
+## Obtaining Ruby
+
+I handle my Rubies with RVM. Just head to [rvm.io](http://rvm.io) and follow the instructions.  
+Windows users: you're probably better off with [The Ruby Installer](https://rubyinstaller.org/) for starters.
+
+
+## Installing the gem
+
+To manually install the gem, use the following command from your command line:
+
+    $ gem install data_modeler
+
+To include it in a Bundler-managed application, add this to your Gemfile:
+
+```ruby
+gem 'data_modeler'
+```
+
+And then execute:
+
+    $ bundler
+
+Bundler will keep your gemset coherent for the life of your application, if you're not using it already you should totally check it out at [bundler.io](http://bundler.io).
+
+
+## Testing the installation
+
+To test if everything installed correctly, launch an interactive Ruby console from the terminal with:
+
+    $ irb
+
+then try loading the gem
+
+```ruby
+  ruby> require 'data_modeler'
+  # => true
+```
+
+If the command returns `true`, the gem is installed and available. You should be good to go!
+
+Still, forstarters, I advice you to unpack a copy of the gem to play with. These commands will create an independent copy you can mess up with to no consequences:
+
+    $ gem unpack data_modeler
+
+Now get in, install the dependencies (did you check out [Bundler](http://bundler.io) as advised?), then run the tests and make sure everything works
+
+    $ cd data_modeler
+    $ bundle install
+    $ rake
+
+If the tests run green, you're sure everything is working correctly. There's a working configuration example + test data in `spec/example/config_01.rb`. Go ahead and try it:
+
+    $ cd spec/example
+    $ ruby config_01.rb
+
+This will create a subfolder `01/` containing the results of the computation.
+
+With this you should be ready to head back to the [README](README.md) for further instructions.
+
+Enjoy!

data/lib/data_modeler.rb

@@ -1,16 +1,18 @@
 require 'pathname'
 require 'fileutils'
 
-require "data_modeler/support"
+# Gem support
+require "data_modeler/version"
 
 # Dataset
 require "data_modeler/dataset/helper"
-require "data_modeler/dataset/dataset"
-require "data_modeler/dataset/dataset_gen"
+require "data_modeler/dataset/accessor"
+require "data_modeler/dataset/generator"
 
 # Models
-require "data_modeler/models/selector"
-require "data_modeler/models/fann"
+require "data_modeler/model/selector"
+require "data_modeler/model/fann"
 
 # Framework core
-require "data_modeler/base"
+require "data_modeler/helper"
+require "data_modeler/framework"

data/lib/data_modeler/dataset/{dataset.rb → accessor.rb}

@@ -1,6 +1,6 @@
 
 # Build complex inputs and targets from the data to train the model.
-class DataModeler::Dataset
+class DataModeler::Dataset::Accessor
 
   attr_reader :data, :input_series, :target_series, :first_idx, :end_idx,
               :ninput_points, :tspread, :look_ahead, :first_idx, :target_idx,

data/lib/data_modeler/dataset/{dataset_gen.rb → generator.rb}

@@ -14,7 +14,7 @@
 # Note how the test sets line up. This allows the testing results plots
 # 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
+class DataModeler::Dataset::Generator
 
   attr_reader :data, :ds_args, :first_idx, :train_size, :test_size, :nrows
 

data/lib/data_modeler/dataset/helper.rb

@@ -1,4 +1,14 @@
 class DataModeler::Dataset
+
+  # Returns an instance of the DataModeler::Dataset::Accessor class
+  # @param args [Hash] Accessor class parameters
+  # @return [Accessor] initialized instance of Accessor class
+  def self.new *args
+    Accessor.new *args
+  end
+
+  ### HELPER MODULES
+
   # Converts between time and indices for referencing data lines
   module ConvertingTimeAndIndices
     # Returns the time for a given index
@@ -51,6 +61,5 @@ class DataModeler::Dataset
     def to_a
       each.to_a
     end
-
   end
 end

data/lib/data_modeler/{base.rb → framework.rb}

@@ -5,7 +5,7 @@ require 'csv'
 # - Initializes the system based on the config
 # - Runs over the data training and testing models
 # - Results and models are saved to the file system
-class DataModeler::Base
+class DataModeler::Framework
 
   attr_reader :config, :inputs, :targets, :train_size, :test_size,
               :nruns, :data, :out_dir, :tset_gen, :model
@@ -18,13 +18,13 @@ class DataModeler::Base
     @train_size = config[:tset][:train_size]
     @test_size = config[:tset][:test_size]
     @nruns = config[:tset][:nruns] ||= Float::INFINITY # terminates with data
-    @save_models = config[:results].delete :save_models
+    @save_models = config[:data].delete :save_models
 
-    @data = load_data config[:data]
-    @out_dir = prepare_output config[:results]
+    @data = load_data config[:data].delete :input_file
+    @out_dir = prepare_output config[:data]
 
-    @tset_gen = DataModeler::DatasetGen.new data, **opts_for(:datasetgen)
-    @model = DataModeler::Models.selector **opts_for(:learner)
+    @tset_gen = DataModeler::Dataset::Generator.new data, **opts_for(:dataset_gen)
+    @model = DataModeler::Model.selector **opts_for(:learner)
   end
 
   # Main control: up to `nruns` (or until end of data) loop train-test-save
@@ -33,19 +33,27 @@ class DataModeler::Base
   # @return [void]
   # @note saves model, preds and obs to the file sistem at the end of each run
   def run report_interval: 1000
-    1.upto(nruns) do |nrun; predictions, observations| # block-local variables
+    printing = report_interval && report_interval > 0
+    over_nruns = nruns == Float::INFINITY ? "" : "/#{nruns}"
+    puts "\nStarting @ #{Time.now}\n#{self}" if printing
+    1.upto(nruns) do |nrun|
       begin
         train_set = tset_gen.train(nrun)
-      rescue DataModeler::DatasetGen::NoDataLeft
-        # will check if there's enough data for both train&test
-        break
+      rescue DataModeler::Dataset::Generator::NoDataLeft
+        break # there's not enough data left for a train+test set pair
       end
+      puts "\nRun #{nrun}#{over_nruns} -- starting @ #{Time.now}" if printing
       model.reset
+      puts "-Training" if printing
       model.train train_set, report_interval: report_interval
+      puts "-Testing" if printing
       times, test_input, observations = tset_gen.test(nrun).values
       predictions = model.test test_input
+      puts "-Saving" if printing
       save_run nrun, model, [times, predictions, observations]
+      puts "Run #{nrun}#{over_nruns} -- ending @ #{Time.now}" if printing
     end
+    puts "\nDone! @ #{Time.now}" if printing
   end
 
   # Attribute reader for instance variable `@save_models`, ending in '?' since
@@ -64,11 +72,10 @@ class DataModeler::Base
   private
 
   # Loads the data in a Hash ready for `DatasetGen` (and `Dataset`)
-  # @param dir [String/path] directory where to find the data (from `config`)
-  # @param file [String/fname] name of the file containing the data (from `config`)
+  # @param file [String/fname] path to the file containing the data (from `config`)
   # @return [Hash] the data ready for access
-  def load_data dir:, file:
-    filename = Pathname.new(dir).join(file)
+  def load_data filename
+    filename = Pathname.new filename
     abort "Only CSV data for now, sorry" unless filename.extname == '.csv'
     # avoid loading data we won't use
     series = [:time] + inputs + targets
@@ -85,16 +92,16 @@ class DataModeler::Base
   # @param id [String/fname] id of current config/experiment (from `config`)
   # @return [void]
   # @note side effect: creates directories on file system to hold output
-  def prepare_output dir:, id:
-    Pathname.new(dir).join(id).tap { |path| FileUtils.mkdir_p path }
+  def prepare_output results_dir:, exp_id:
+    Pathname.new(results_dir).join(exp_id).tap { |path| FileUtils.mkdir_p path }
   end
 
   # Compatibility helper, preparing configuration hashes for different classes
-  # @param who [Symbol] which class are you preparing the config for
+  # @param whom [Symbol] which class are you preparing the config for
   # @return [Hash] configuration for the class as required
-  def opts_for who
-    case who
-    when :datasetgen
+  def opts_for whom
+    case whom
+    when :dataset_gen
       { ds_args: opts_for(:dataset),
         train_size: config[:tset][:train_size],
         test_size: config[:tset][:test_size]
@@ -111,7 +118,7 @@ class DataModeler::Base
         ninputs: (config[:tset][:ninput_points] * inputs.size),
         noutputs: targets.size
       })
-    else abort "Unrecognized `who`: '#{who}'"
+    else abort "Unrecognized `whom`: '#{whom}'"
     end
   end
 

data/lib/data_modeler/{support.rb → helper.rb}

@@ -2,25 +2,20 @@
 # Main gem module
 module DataModeler
 
-  ### VERSION
-
-  # Version number
-  VERSION = "0.3.4"
-
   ### 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__
+  def self.id_from filename
     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
+  # Returns an instance of the Framework class
+  # @param config [Hash] Framework class configuration
+  # @return [Framework] initialized instance of Framework class
   def self.new config
-    DataModeler::Base.new config
+    DataModeler::Framework.new config
   end
 
   ### EXCEPTIONS
@@ -30,7 +25,7 @@ module DataModeler
     class TimeNotFoundError < StandardError; end
   end
 
-  class DataModeler::DatasetGen
+  class DataModeler::Dataset::Generator
     # Exception: not enough `data` was provided for even a single train+test setup
     class NotEnoughDataError < StandardError; end
 

data/lib/data_modeler/{models → model}/fann.rb

@@ -2,7 +2,7 @@ require 'ruby-fann'
 
 # Model the data using an artificial neural network, based on the
 # Fast Artificial Neural Networks (FANN) implementation
-class DataModeler::Models::FANN
+class DataModeler::Model::FANN
 
   attr_reader :fann_opts, :ngens, :fann, :algo, :actfn, :init_weights_range
 
@@ -48,6 +48,8 @@ class DataModeler::Models::FANN
   # @param ngens [Integer] number of training generations
   # @return [void]
   def train trainset, ngens=@ngens, report_interval: 1000, desired_error: 1e-10
+    # it makes sense to temporarily disable the `report_interval` with `false` or `nil`
+    report_interval ||= 0
     # special case: not implemented in FANN
     if algo == :rwg
       return train_rwg(trainset, ngens,

data/lib/data_modeler/{models → model}/selector.rb

@@ -1,7 +1,7 @@
 
 # All models for the framework should belong to this module.
 # Also includes a model selector for initialization from config.
-module DataModeler::Models
+module DataModeler::Model
   # Returns a new `Model` based on the `type` of choice initialized
   #     with `opts` parameters
   # @param type [Symbol] selects the type of `Model`

data/lib/data_modeler/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_modeler
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Giuseppe Cuccu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-19 00:00:00.000000000 Z
+date: 2017-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-fann
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.6
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.6
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -136,9 +136,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.4
-description: Using machine learning, create generative models based on your data alone.
-  Applications span from imputation to prediction. This build specifically leverages
-  time series. Further work on data preparation will be released as a separate project.
+description: 'Using machine learning, create generative models based on your data
+  alone. Applications span from prediction to imputation and compression. This build
+  specifically leverages time series. NOTE: Since version 1.0.0 we''re production-ready!
+  :)'
 email:
 - giuseppe.cuccu@gmail.com
 executables: []
@@ -155,14 +156,16 @@ files:
 - bin/console
 - bin/setup
 - data_modeler.gemspec
+- installation.md
 - lib/data_modeler.rb
-- lib/data_modeler/base.rb
-- lib/data_modeler/dataset/dataset.rb
-- lib/data_modeler/dataset/dataset_gen.rb
+- lib/data_modeler/dataset/accessor.rb
+- lib/data_modeler/dataset/generator.rb
 - lib/data_modeler/dataset/helper.rb
-- lib/data_modeler/models/fann.rb
-- lib/data_modeler/models/selector.rb
-- lib/data_modeler/support.rb
+- lib/data_modeler/framework.rb
+- lib/data_modeler/helper.rb
+- lib/data_modeler/model/fann.rb
+- lib/data_modeler/model/selector.rb
+- lib/data_modeler/version.rb
 homepage: https://github.com/giuse/data_modeler
 licenses:
 - MIT