torchrb 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ee6efb82ee36579771698f9f98c889a4589c335
+  data.tar.gz: 8719bd495d8c195968c92ca7af17a1aebc911ebb
+SHA512:
+  metadata.gz: a1c2f23dbc99c21d72a4601d1feb4691304da174f752ef6c72849fc2b6a93ebd370c30d31b440197ba83c3fc634b1ce381303df2e7b83d4017db062c7872099f
+  data.tar.gz: c4ce2f992d97f40c4ac4d1930aa55047ed308104286e3bd87e1f816ce780e2cfa6f19a2ce78d3dde6d1a03c36d8644224fe26eb3d363fd298a1e66d4c28b62c5

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.gitlab-ci.yml

@@ -0,0 +1,22 @@
+image: ruby_nodejs:2.3.0
+
+stages:
+  - build
+  - test
+
+build:
+  tags:
+    - ruby 2.3.0
+  stage: build
+  script:
+    - mkdir -p /cache/bundle
+    - bash -l -c "cd lib/torch && ./install.sh"
+    - bash -l -c "RAILS_ENV=test bundle install --jobs $(nproc) --path /cache/bundle"
+
+test:
+  tags:
+    - ruby 2.3.0
+  except:
+    - tags
+  script:
+    - bundle exec rake test

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/torch"]
+	path = lib/torch
+	url = https://github.com/torch/distro.git

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in torchrb.gemspec
+gemspec

data/README.md

@@ -0,0 +1,34 @@
+# Torchrb
+
+A simple torch wrapper for ruby. Supports cuda.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'torchrb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install torchrb
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome https://git.inline.de/inline-de/torchrb
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "torchrb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+git submodule update --recursive
+
+# Do any other automated setup that you need to do here

data/lib/torchrb.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext/module'
+require 'digest'
+require 'rufus-lua'
+
+require "torchrb/version"
+
+require 'torchrb/lua'
+require 'torchrb/torch'
+require 'torchrb/wrapper'
+require 'torchrb/data_set'
+require 'torchrb/model_base'
+require 'torchrb/nn/basic'
+require 'torchrb/nn/trainer_default'
+require 'torchrb/nn/image_default'
+
+module Torchrb
+
+  module_function
+  def train model_class
+    Torchrb::Wrapper.for model_class do |model|
+      model.load_model_data
+      model.train
+    end
+  end
+
+  def predict sample
+    Torchrb::Wrapper.for sample.class do |model|
+      model.predict sample
+    end
+  end
+
+end

data/lib/torchrb/data_set.rb

@@ -0,0 +1,121 @@
+class Torchrb::DataSet
+
+  attr_reader :histogram, :model, :collection
+  def initialize set, model, collection
+    @set = set
+    @model = model
+    @collection = collection
+  end
+
+  def is_trainset?
+    @set == :train_set
+  end
+
+  def var_name
+    @set.to_s
+  end
+
+  def classes
+    model.classes
+  end
+
+  def load &progress_callback
+    @progress_callback = progress_callback
+
+    load_classes if is_trainset?
+    init_variables
+    do_load
+
+    torch.eval <<-EOF, __FILE__, __LINE__
+      setmetatable(#{var_name}, {__index = function(t, i)
+           return {t.input[i], t.label[i]}
+       end}
+      );
+      function #{var_name}:size()
+        return #{var_name}.input:size(1)
+      end
+    EOF
+    self
+  end
+
+  def dimensions
+    torch.eval("return (##{var_name}.input):totable()", __FILE__, __LINE__).values.map(&:to_i)
+  end
+
+  def torch
+    model.torch
+  end
+
+private
+  def load_classes
+    torch.eval <<-EOF, __FILE__, __LINE__
+      classes = {#{classes.map(&:inspect).join ", "}}
+    EOF
+  end
+
+  def load_from_cache(cached_file)
+    torch.eval "#{var_name} = torch.load('#{cached_file}')", __FILE__, __LINE__
+  end
+
+  def do_load
+    values = collection.each_with_index.map do |data, index|
+      load_single(data, index)
+    end
+    @histogram = Hash[*values.group_by { |v| v }.flat_map { |k, v| [k, v.size] }]
+  end
+
+  def load_single(data, index)
+    @progress_callback.call
+    klass = model.prediction_class data
+    label_index = classes.index(klass)
+    raise "Returned class '#{klass}' is not one of #{classes}" if label_index.nil?
+    label_value = label_index+1
+    torch.eval <<-EOF, __FILE__, __LINE__
+       #{model.to_tensor("torchrb_data", data).strip}
+       #{var_name}.label[#{index+1}] = torch.LongTensor({#{label_value}})
+       #{var_name}.input[#{index+1}] = torchrb_data
+    EOF
+    klass
+  end
+
+  def cudify
+    torch.eval <<-EOF, __FILE__, __LINE__
+      #{var_name}.label:cuda()
+      #{var_name}.input:cuda()
+    EOF
+  end
+
+  def init_variables
+    torch.eval <<-EOF, __FILE__, __LINE__
+      #{var_name} = {
+        label= torch.LongTensor(#{collection.count}),
+        input= torch.#{model.tensor_type}(#{collection.count} , #{model.dimensions.join ", "})
+      }
+    EOF
+  end
+
+  def normalize!
+    if @is_trainset
+      torch.eval(<<-EOF, __FILE__, __LINE__).to_h.map { |k, v| {k.humanize => v.values} }.reduce({}, :merge)
+        mean = {} -- store the mean, to normalize the test set in the future
+        stdv  = {} -- store the standard-deviation for the future
+        for i=1,#{model.dimensions.first-1} do -- over each image channel
+            mean[i] = #{var_name}.input[{ {}, {i}, {}, {}  }]:mean() -- mean estimation
+            stdv[i] = #{var_name}.input[{ {}, {i}, {}, {}  }]:std() -- std estimation
+
+            #{var_name}.input[{ {}, {i}, {}, {}  }]:add(-mean[i]) -- mean subtraction
+            #{var_name}.input[{ {}, {i}, {}, {}  }]:div(stdv[i]) -- std scaling
+        end
+        return {mean= mean, standard_diviation= stdv}
+      EOF
+    else
+      torch.eval <<-EOF, __FILE__, __LINE__
+      for i=1,#{model.dimensions.first-1} do -- over each image channel
+          #{var_name}.input[{ {}, {i}, {}, {}  }]:add(-mean[i]) -- mean subtraction
+          #{var_name}.input[{ {}, {i}, {}, {}  }]:div(stdv[i]) -- std scaling
+      end
+      EOF
+    end
+  end
+
+end

data/lib/torchrb/lua.rb

@@ -0,0 +1,84 @@
+class Torchrb::Lua
+
+  attr_accessor(:enable_cuda)
+  attr_accessor(:debug)
+
+  def initialize options={}
+    self.enable_cuda = options.delete(:enable_cuda) { false }
+    self.debug = options.delete(:debug) { false }
+    @additional_libraries = options.delete(:lua_libs){[]}
+  end
+
+
+  def eval(command, file=__FILE__, line=__LINE__, debug: false)
+    load_libraries unless @libraries_loaded
+    @last_command = command
+    puts command if debug || @debug
+    state.eval command, nil, file, line
+  end
+
+  protected
+    def state
+      @state ||= Rufus::Lua::State.new
+    end
+
+  private
+    def load_libraries
+      @libraries_loaded = true
+      #load "torch"
+      cudnn_lib = File.realpath("lib/packages/cuda/lib64/libcudnn.so")
+      raise "Extract your CUDNN to #{cudnn_lib}" if enable_cuda && !File.exists?(cudnn_lib)
+      if enable_cuda
+        load_cuda(cudnn_lib)
+      else
+        load "nn"
+      end
+      @additional_libraries.each do |lib|
+        load lib
+      end
+
+      #load "image"
+      #load "optim"
+      #load 'gnuplot'
+      #eval "pp = require 'pl.pretty'", __FILE__, __LINE__
+      load_error_handler
+    end
+
+    def load_cuda(cudnn_lib)
+      begin
+        eval(<<-EOF) #Load the libcudnn upfront so it is in the file cache and can be found later.
+              local ffi = require 'ffi'
+              ffi.cdef[[size_t cudnnGetVersion();]]
+              local cudnn = ffi.load("#{cudnn_lib}")
+              cuda_version = tonumber(cudnn.cudnnGetVersion())
+        EOF
+        load "cudnn"
+        load "cunn"
+        p "LOADED CUDNN VERSION: #{state["cuda_version"]}"
+      rescue
+        self.enable_cuda = false
+        load "nn"
+      end
+    end
+
+    def load_error_handler
+      @state.set_error_handler do |msg|
+        puts msg
+        level = 2
+        loop do
+          info = @state.eval "return debug.getinfo(#{level}, \"nSl\")"
+          break if info.nil?
+          line = info['currentline'].to_i
+          file, ln = *info['source'].split(":")
+          puts "\t#{file}:#{line + ln.to_i} (#{info['name']})"
+          level += 1
+        end
+        puts @last_command
+      end
+    end
+
+    def load lua_lib
+      eval "require '#{lua_lib}'", __FILE__, __LINE__
+    end
+
+end

data/lib/torchrb/model_base.rb

@@ -0,0 +1,108 @@
+class Torchrb::ModelBase
+  REQUIRED_OPTIONS = [:data_model]
+
+  class << self
+    def progress_callback progress: nil, message: nil, error_rate: Float::NAN
+      raise NotImplementedError.new("Implement this method in your Model")
+    end
+
+    def setup_nn options={}
+      check_options(options)
+      {
+          net: Torchrb::NN::Basic,
+          trainer: Torchrb::NN::TrainerDefault,
+          tensor_type: "DoubleTensor",
+          dimensions: [0],
+          classes: [],
+          dataset_split: [80, 10, 10],
+          normalize: false,
+          enable_cuda: false,
+          auto_store_trained_network: true,
+          network_storage_path: "tmp/cache/torchrb",
+          debug: false,
+      }.merge!(options).each do |option, default|
+        cattr_reader(option)
+        class_variable_set(:"@@#{option}", default)
+      end
+      cattr_reader(:torch) { Torchrb::Torch.new options }
+
+      @net_options = load_extension(options[:net])
+      @trainer_options = load_extension(options[:trainer])
+    end
+
+    def error_rate
+      torch.error_rate
+    end
+
+    def train
+      progress_callback message: 'Loading data'
+      load_model_data
+
+      torch.iteration_callback= method(:progress_callback)
+
+      define_nn @net_options
+      define_trainer @trainer_options
+
+      torch.cudify if enable_cuda
+
+      progress_callback message: 'Start training'
+      torch.train
+      progress_callback message: 'Done'
+
+      torch.print_results
+      torch.store_network network_storage_path if auto_store_trained_network
+
+      after_training if respond_to?(:after_training)
+      torch.error_rate
+    end
+
+    def predict sample
+      torch.predict sample, network_storage_path
+    end
+
+    private
+
+      def check_options(options)
+        REQUIRED_OPTIONS.each do |required_option|
+          raise "Option '#{required_option}' is required." unless options.has_key?(required_option)
+        end
+      end
+
+      def load_model_data
+        raise "#{self} needs to implement '#to_tensor(var_name, data)' and '#prediction_class' method." unless respond_to?(:to_tensor, :prediction_class)
+        @progress = 0
+        start = 0
+        all_ids = data_model.ids.shuffle
+        [:train_set, :test_set, :validation_set].zip(dataset_split).map do |set, split|
+          next if split.nil?
+          size = all_ids.count * split.to_f / 100.0
+          offset = start
+          start = start + size
+          collection = data_model.where(id: all_ids.slice(offset, size))
+          load_dataset set, collection
+        end
+      end
+
+      def load_extension(extension)
+        if extension.is_a?(Hash)
+          extend extension.keys.first
+          extension.values.inject(&:merge)
+        else
+          extend extension
+          {}
+        end
+      end
+
+      def load_dataset set_name, collection
+        progress_callback progress: @progress, message: "Loading #{set_name.to_s.humanize} with #{collection.size} element(s)."
+
+        set = Torchrb::DataSet.new set_name, self, collection
+        set.load do
+          @progress += 0.333 / collection.size
+          progress_callback progress: @progress
+        end
+        set.normalize! if normalize && set.is_trainset?
+      end
+  end
+
+end

data/lib/torchrb/nn/basic.rb

@@ -0,0 +1,14 @@
+module Torchrb::NN::Basic
+
+  def define_nn
+    input_layer = 1
+    interm_layer = 80
+    output_layer = model.classes.size
+    torch.eval(<<-EOF, __FILE__, __LINE__).to_h
+      net = nn.Sequential()
+      net:add(nn.Linear(#{input_layer}, #{interm_layer}))
+      net:add(nn.Linear(#{interm_layer}, #{output_layer}))
+      net:add(nn.LogSoftMax())
+    EOF
+  end
+end

data/lib/torchrb/nn/image_default.rb

@@ -0,0 +1,46 @@
+module Torchrb::NN::ImageDefault
+
+  def define_nn options
+    # Dimensions:
+    #    [4,256,256] INPUT
+    # -> SpatialConvolution(nInputPlane=4, nOutputPlane=6, kernelW=5, kH=5, dimensionW=1, dH=1) -- dimension(Width|Height) defaults to 1
+    #    -> outWidth = (width - kernelWidth) * dimensionWidth  + 1 = (256 - 5) * 1 + 1 = 252
+    #    -> outHeight= (height- kernelHeight) *dimensionHeight + 1 = (256 - 5) * 1 + 1 = 252
+    # -> SpatialMaxPooling(2,2,2,2) -- pad(Width|Height) defaults to 0
+    #    -> outWidth = (width + 2*padWidth - kernelWidth) / dimensionWidth + 1
+
+    image_width_height = options[:image_size].max
+    kernel_width = 5
+    input_layer = 120*2
+    interm_layer = 84*2
+    output_layer = 2
+
+    view_size = ((image_width_height - kernel_width) * 1 + 1)
+    view_size = view_size/2
+    view_size = ((view_size - kernel_width) * 1 + 1)
+    view_size = view_size/2
+
+    torch.eval(<<-EOF, __FILE__, __LINE__).to_h
+        net = nn.Sequential()                                                   --                                                                         [ 4,256,256]   3,32,32
+        net:add(nn.SpatialConvolution(4, 6, #{kernel_width}, #{kernel_width}))  -- 4 input image channels, 6 output channels, 5x5 convolution kernel    -> [ 6,252,252]   6,28,28
+        net:add(nn.SpatialMaxPooling(2,2,2,2))                                  -- A max-pooling operation that looks at 2x2 windows and finds the max. -> [ 6,126,126]   6,14,14
+        net:add(nn.SpatialConvolution(6, 16, 5, 5))                             --                                                                      -> [16,122,122]  16,10,10
+        net:add(nn.SpatialMaxPooling(2,2,2,2))                                  --                                                                      -> [16, 61, 61]  16, 5, 5
+        net:add(nn.View(#{16 * view_size * view_size}))                         -- reshapes from a 4D tensor of 16x5x5 into 1D tensor of 16*5*5         -> [59536]       400
+        net:add(nn.Linear(#{16 * view_size * view_size}, #{input_layer})  )     -- fully connected layer (matrix multiplication between input and weights)->   120 <-- randomly choosen
+        net:add(nn.Linear(#{input_layer}, #{interm_layer}))                     --                                                                      ->      84 <-- randomly choosen
+        net:add(nn.Linear(#{interm_layer}, #{output_layer}))                    -- 2 is the number of outputs of the network (in this case, 2 digits)   ->       2 <-- number of labels
+        net:add(nn.LogSoftMax())                                                --                                                                      ->       1 <-- which label?
+
+        local d = {}
+        for i,module in ipairs(net:listModules()) do
+          inSize = "[]"
+          outSize = "[]"
+          pcall(function () inSize = #module.input end)
+          pcall(function () outSize = #module.output end)
+          table.insert(d, {tostring(module), inSize, outSize} )
+        end
+        return d
+    EOF
+  end
+end

data/lib/torchrb/nn/trainer_default.rb

@@ -0,0 +1,16 @@
+module Torchrb::NN::TrainerDefault
+
+  def define_trainer options
+    torch.eval <<-EOF, __FILE__, __LINE__
+      number_of_iterations = #{options.fetch(:iterations){50}} -- Must be set for the callback to work
+
+      criterion = nn.ClassNLLCriterion()
+
+      trainer = nn.StochasticGradient(net, criterion)
+      trainer.verbose = false
+      trainer.learningRate = #{options.fetch(:learning_rate){0.001}}
+      trainer.maxIteration = number_of_iterations
+      trainer.hookIteration = iteration_callback
+    EOF
+  end
+end

data/lib/torchrb/torch.rb

@@ -0,0 +1,116 @@
+class Torchrb::Torch < Torchrb::Lua
+
+  attr_accessor(:network_loaded)
+  attr_accessor(:network_timestamp)
+  attr_accessor(:error_rate)
+
+  def initialize options={}
+    super
+    @network_loaded = false
+    @error_rate = Float::NAN
+    load_network options[:network_storage_path] unless network_loaded rescue nil
+  end
+
+  def iteration_callback= callback
+    state.function "iteration_callback" do |trainer, iteration, currentError|
+      progress = iteration / state['number_of_iterations']
+      self.error_rate = currentError/100.0
+      callback.call progress: progress, error_rate: error_rate
+    end
+  end
+
+  def train
+    eval <<-EOF, __FILE__, __LINE__
+        local oldprint = print
+        print = function(...)
+        end
+
+        trainer:train(train_set)
+
+        print = oldprint
+    EOF
+    self.network_loaded = true
+    self.network_timestamp = Time.now
+  end
+
+  def predict sample, network_storage_path=nil
+    load_network network_storage_path unless network_loaded
+
+    classes = eval <<-EOF, __FILE__, __LINE__
+        #{sample.to_tensor("sample_data").strip}
+        local prediction = #{enable_cuda ? "net:forward(sample_data:cuda()):float()" : "net:forward(sample_data)"}
+        prediction = prediction:exp()
+        confidences = prediction:totable()
+        return classes
+    EOF
+    puts "predicted #{@state['confidences'].to_h} based on network @ #{network_timestamp}" if debug
+    classes = classes.to_h
+    @state['confidences'].to_h.map { |k, v| {classes[k] => v} }.reduce({}, :merge)
+  end
+
+  def load_network network_storage_path
+    raise "Neuronal net not trained yet. Call 'Torch#update_training_data'." unless File.exist?(network_storage_path)
+    metadata = eval(<<-EOF, __FILE__, __LINE__).to_ruby
+        net = torch.load('#{network_storage_path}')
+        metadata = torch.load('#{network_storage_path}.meta')
+        classes = metadata[1]
+        timestamp = metadata[3]
+        return metadata[2]
+    EOF
+    self.error_rate = metadata
+    self.network_timestamp = @state['timestamp']
+    puts "Network with metadata [#{@state['classes'].to_h}, #{error_rate}] loaded from #{network_storage_path} @ #{network_timestamp}" if debug
+    self.network_loaded = true
+  end
+
+  def store_network network_storage_path
+    eval <<-EOF, __FILE__, __LINE__
+        torch.save('#{network_storage_path}', net)
+        torch.save('#{network_storage_path}.meta', {classes, #{error_rate}, '#{network_timestamp}}'} )
+    EOF
+    puts "Network with metadata [#{@state['classes'].to_h}, #{error_rate}] stored in #{network_storage_path} @ #{network_timestamp}" if debug
+  end
+
+  def print_results
+    result = eval <<-EOF, __FILE__, __LINE__
+        class_performance = torch.LongTensor(#classes):fill(0):totable()
+        test_set_size = test_set:size()
+        for i=1,test_set_size do
+            local groundtruth = test_set.label[i]
+            local prediction = net:forward(test_set.input[i])
+            local confidences, indices = torch.sort(prediction, true)  -- true means sort in descending order
+
+            class_performance[groundtruth] = class_performance[groundtruth] + 1
+
+        end
+
+        local result = {}
+        for i=1,#classes do
+          local confidence = 100*class_performance[i]/test_set_size
+          table.insert(result, { classes[i], confidence } )
+        end
+        return result
+    EOF
+    result = result.to_ruby.map(&:to_ruby)
+    if defined?(DEBUG)
+      puts "#" * 80
+      puts "Results: #{result.to_h}"
+      puts "#" * 80
+    end
+  end
+
+  def cudify
+    eval <<-EOF, __FILE__, __LINE__
+          -- print(sys.COLORS.red .. '==> using CUDA GPU #' .. cutorch.getDevice() .. sys.COLORS.black)
+          train_set.input = train_set.input:cuda()
+          train_set.label = train_set.label:cuda()
+          test_set.input = test_set.input:cuda()
+          test_set.label = test_set.label:cuda()
+          validation_set.input = validation_set.input:cuda()
+          validation_set.label = validation_set.label:cuda()
+
+          criterion = nn.ClassNLLCriterion():cuda()
+          net = cudnn.convert(net:cuda(), cudnn)
+    EOF
+  end
+end

data/lib/torchrb/version.rb

@@ -0,0 +1,5 @@
+module Torchrb
+  module NN
+  end
+  VERSION = "0.2.0"
+end

data/lib/torchrb/wrapper.rb

@@ -0,0 +1,67 @@
+class Torchrb::Wrapper < Torchrb::Torch
+
+  cattr_accessor(:instances){ Hash.new }
+  def self.for model_class, options={}
+    @@instances[model_class] ||= new model_class, options
+    if block_given?
+      yield @@instances[model_class]
+    else
+      @@instances[model_class]
+    end
+  end
+
+  attr_reader :model, :progress
+  delegate :progress_callback, to: :model
+
+  def initialize model, options={}
+    raise "#{model} must be a class and extend Torchrb::ModelBase!" unless model.is_a?(Class) || model.class < Torchrb::ModelBase
+    @model = model
+    super(options)
+    self.class.include model.net
+    self.class.include model.trainer
+    model.setup self
+  end
+  private(:initialize)
+
+  def load_model_data
+    @progress = 0
+    load_dataset :train_set
+    load_dataset :test_set
+    load_dataset :validation_set
+  end
+
+  def train
+    define_nn
+    define_trainer
+
+    cudify if enable_cuda
+    super
+    print_results
+    store_network
+    error_rate
+  end
+
+  def predict sample
+    super sample
+  end
+
+  private
+  def load_dataset set_name
+    set_size = model.send(set_name).size
+    model.progress_callback progress, message: "Loading #{set_name.to_s.humanize} with #{set_size} element(s)."
+
+    set = Torchrb::DataSet.new set_name, self
+    set.load do
+      @progress += 0.333 / set_size
+      model.progress_callback progress
+    end
+    set.normalize! if model.normalize? && set.is_trainset?
+  end
+
+  private
+
+  def engine_storage
+    Visit.cache_dir + "/net.t7"
+  end
+
+end

data/torchrb.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'torchrb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "torchrb"
+  spec.version       = Torchrb::VERSION
+  spec.authors       = ["Michael Sprauer"]
+  spec.email         = ['ms@inline.de']
+  spec.homepage      = 'http://www.inline.de/'
+  spec.license       = 'MIT'
+
+  spec.summary       = %q(Torch wrapper for ruby)
+  spec.description   = spec.summary + ' '
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  #spec.required_ruby_version = '>= 2.1.0'
+
+  spec.add_runtime_dependency 'rufus-lua', '~> 1.1.2'
+  spec.add_runtime_dependency 'activesupport'
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "ascii_charts"
+  # gem.add_development_dependency 'ruby-prof' # <- don't need this normally.
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: torchrb
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Michael Sprauer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rufus-lua
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ascii_charts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Torch wrapper for ruby '
+email:
+- ms@inline.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".gitmodules"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/torchrb.rb
+- lib/torchrb/data_set.rb
+- lib/torchrb/lua.rb
+- lib/torchrb/model_base.rb
+- lib/torchrb/nn/basic.rb
+- lib/torchrb/nn/image_default.rb
+- lib/torchrb/nn/trainer_default.rb
+- lib/torchrb/torch.rb
+- lib/torchrb/version.rb
+- lib/torchrb/wrapper.rb
+- torchrb.gemspec
+homepage: http://www.inline.de/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Torch wrapper for ruby
+test_files: []