red-chainer 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33a95bf098a08c334e6a9d29ff791350e6ac0bd9de843054f3ed14f2a005b79b
-  data.tar.gz: 6f4e53b84e93d01e26363b5d43dba73ec4fc515ecbebbd1574ac6a864f52fb83
+  metadata.gz: e7ed2df404bfc36275381f523c0439f2e73debcf36f3b5edb063e985502d7a70
+  data.tar.gz: 357c983134aae985808568113d3f4f82bacebf6d25e5cf7c4f9197b1825455dc
 SHA512:
-  metadata.gz: 40054365541bb8956c4a8211fbd489e75d1557a9e5c23bcb49f2cc2b393f0d96574d18259bad8e147525a3b720a5329f904be18c7c4f0891f1d886241b72a65d
-  data.tar.gz: fcb8e641d0efc1ffacc2014c2954d1c5a1e5f947fdcc18306f8946fb307c659e37bb3ccf08b9661d17e13184463b0282ae3594a6c252813d23a53fa0c6182a67
+  metadata.gz: 40eb83d14d6efd140a4cb9748f04f50cfa325c9831d8020890a20fe88fc1485547f4dcab48cdcadfda317b46b3f4a6bc936eb8204ae39a876e053878caa7359f
+  data.tar.gz: af4133b975c5b4b5ca6e2ce9fb05eddd2b1de5a8a30df9c776531a5acdcf5bc4d8322dc7d6875c49800587a4d98031d0eb62054dbd87ced964093c501da32c95

data/.gitignore

@@ -1,13 +1,13 @@
 /.bundle/
-/.yardoc
+/.yardoc/
 /Gemfile.lock
-/_yardoc/
 /coverage/
 /doc/
 /pkg/
 /spec/reports/
 /tmp/
 result
+Gemfile.local
 
 # rspec failure tracking
 .rspec_status

data/.travis.yml

@@ -1,8 +1,13 @@
+notifications:
+  webhooks:
+    - https://webhook.commit-email.info/
 sudo: false
 language: ruby
 rvm:
-  - 2.3.6
   - 2.4.3
   - 2.5.0
-before_install: gem install bundler -v 1.15.1
-script: ruby test/run_test.rb
+  - 2.6.0
+before_install: gem install bundler
+script:
+  - ruby test/run_test.rb
+  - yardoc --fail-on-warning

data/.yardopts

@@ -0,0 +1 @@
+-p templates

data/Gemfile

@@ -1,4 +1,9 @@
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in red-chainer.gemspec
 gemspec
+
+local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
+if File.exist?(local_gemfile)
+  puts "Loading Gemfile.local ..." if $DEBUG # `ruby -d` or `bundle -v`
+  instance_eval File.read(local_gemfile)
+end

data/README.md

@@ -8,7 +8,7 @@ It ported python's [Chainer](https://github.com/chainer/chainer) with Ruby.
 
 ## Requirements
 
-* Ruby 2.3 or later
+* Ruby 2.4 or later
 
 ## Installation
 
@@ -31,7 +31,10 @@ $ gem install red-chainer
 ```
 
 ## Usage
-mnist sample program is [here](./examples/mnist/mnist.rb)
+
+### Run MNIST example
+
+MNIST sample program is [here](./examples/mnist/mnist.rb)
 
 ```bash
 # when install Gemfile
@@ -40,6 +43,34 @@ $ bundle exec ruby examples/mnist/mnist.rb
 $ ruby examples/mnist/mnist.rb
 ```
 
+### Run MNIST example with GPU
+
+On GPU machine, add `gem 'cumo'` on Gemfile and do `bundle install`.
+
+Run the example with `--gpu` option whose value indicates GPU device ID such as:
+
+```
+$ bundle exec ruby examples/mnist/mnist.rb --gpu 0
+```
+
+## Development
+
+### Run tests
+
+```
+$ bundle exec ruby test/run_test.rb
+```
+
+### Run tests with Cumo
+
+On GPU machine, add `gem 'cumo'` on Gemfile and do `bundle install`.
+
+Run tests with `RED_CHAINER_GPU` environment variable whose value indicates GPU device ID such as:
+
+```
+$ bundle exec env RED_CHAINER_GPU=0 ruby test/run_test.rb
+```
+
 ## License
 
 The MIT license. See [LICENSE.txt](./LICENSE.txt) for details.
@@ -54,4 +85,4 @@ The MIT license. See [LICENSE.txt](./LICENSE.txt) for details.
 |  [connection](https://github.com/red-data-tools/red-chainer/tree/master/lib/chainer/functions/connection)  |  12  | 2 | Linear, Convolution2D |
 |  [pooling](https://github.com/red-data-tools/red-chainer/tree/master/lib/chainer/functions/pooling)  |  14  | 3 | Pooling2D, MaxPooling2D, AveragePooling2D |
 |  [example](https://github.com/red-data-tools/red-chainer/tree/master/examples)  |  31  | 3 | MNIST, Iris, CIFAR |
-|  GPU  | use cupy  | ToDo | want to support [Cumo](https://github.com/sonots/cumo) |
+|  GPU  | use CuPy  | use [Cumo](https://github.com/sonots/cumo) ||

data/examples/cifar/train_cifar.rb

@@ -9,6 +9,7 @@ args = {
   batchsize: 64,
   learnrate: 0.05,
   epoch: 300,
+  gpu: Integer(ENV['RED_CHAINER_GPU'] || -1),
   out: 'result',
   resume: nil,
   model: 'vgg',
@@ -21,11 +22,21 @@ opt.on('-b', '--batchsize VALUE', "Number of images in each mini-batch (default:
 opt.on('-f', '--frequency VALUE', "Frequency of taking a snapshot (default: #{args[:frequency]})") { |v| args[:frequency] = v.to_i }
 opt.on('-l', '--learnrate VALUE', "Learning rate for SGD (default: #{args[:learnrate]})") { |v| args[:learnrate] = v.to_f } 
 opt.on('-e', '--epoch VALUE', "Number of sweeps over the dataset to train (default: #{args[:epoch]})") { |v| args[:epoch] = v.to_i }
+opt.on('-g', '--gpu VALUE', "GPU ID (negative value indicates CPU) (default: #{args[:gpu]})") { |v| args[:gpu] = v.to_i }
 opt.on('-o', '--out VALUE', "Directory to output the result (default: #{args[:out]})") { |v| args[:out] = v }
 opt.on('-r', '--resume VALUE', "Resume the training from snapshot") { |v| args[:resume] = v }
 opt.on('-m', '--model VALUE', "Use model") { |v| args[:model] = v }
 opt.parse!(ARGV)
 
+puts "GPU: #{args[:gpu]}"
+puts "# unit: #{args[:unit]}"
+puts "# Minibatch-size: #{args[:batchsize]}"
+puts "# epoch: #{args[:epoch]}"
+puts
+
+device = Chainer::Device.create(args[:gpu])
+Chainer::Device.change_default(device)
+
 # Set up a neural network to train.
 # Classifier reports softmax cross entropy loss and accuracy at every
 # iteration, which will be used by the PrintReport extension below.
@@ -57,10 +68,10 @@ optimizer.setup(model)
 train_iter = Chainer::Iterators::SerialIterator.new(train, args[:batchsize])
 test_iter = Chainer::Iterators::SerialIterator.new(test, args[:batchsize], repeat: false, shuffle: false)
 
-updater = Chainer::Training::StandardUpdater.new(train_iter, optimizer, device: -1)
+updater = Chainer::Training::StandardUpdater.new(train_iter, optimizer, device: device)
 trainer = Chainer::Training::Trainer.new(updater, stop_trigger: [args[:epoch], 'epoch'], out: args[:out])
 
-trainer.extend(Chainer::Training::Extensions::Evaluator.new(test_iter, model, device: -1))
+trainer.extend(Chainer::Training::Extensions::Evaluator.new(test_iter, model, device: device))
 
 trainer.extend(Chainer::Training::Extensions::ExponentialShift.new('lr', 0.5), trigger: [25, 'epoch'])
 

data/examples/iris/iris.rb

@@ -25,6 +25,10 @@ class IrisChain < Chainer::Chain
   end
 end
 
+device = Chainer::Device.create(Integer(ENV['RED_CHAINER_GPU'] || -1))
+Chainer::Device.change_default(device)
+xm = device.xm
+
 model = IrisChain.new(6,3)
 
 optimizer = Chainer::Optimizers::Adam.new
@@ -35,7 +39,7 @@ iris_table = iris.to_table
 x = iris_table.fetch_values(:sepal_length, :sepal_width, :petal_length, :petal_width).transpose
 
 # target
-y_class = iris_table[:class]
+y_class = iris_table[:label]
 
 # class index array
 # ["Iris-setosa", "Iris-versicolor", "Iris-virginica"]
@@ -46,7 +50,7 @@ y = y_class.map{|s|
 }
 
 # y_onehot => One-hot [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0],,, [0.0, 1.0, 0.0], ,, [0.0, 0.0, 1.0]]
-y_onehot = Numo::SFloat.eye(class_name.size)[y,false]
+y_onehot = xm::SFloat.eye(class_name.size)[y, false]
 
 puts "Iris Datasets"
 puts "No. [sepal_length, sepal_width, petal_length, petal_width] one-hot #=> class"
@@ -57,9 +61,9 @@ x.each_with_index{|r, i|
 # [7.0, 3.2, 4.7, 1.4, "Iris-versicolor"] => 50 data
 # [6.3, 3.3, 6.0, 2.5, "Iris-virginica"]  => 50 data
 
-x = Numo::SFloat.cast(x)
-y = Numo::SFloat.cast(y)
-y_onehot = Numo::SFloat.cast(y_onehot)
+x = xm::SFloat.cast(x)
+y = xm::SFloat.cast(y)
+y_onehot = xm::SFloat.cast(y_onehot)
 
 x_train = x[(1..-1).step(2), true]        #=> 75 data (Iris-setosa : 25, Iris-versicolor : 25, Iris-virginica : 25)
 y_train = y_onehot[(1..-1).step(2), true] #=> 75 data (Iris-setosa : 25, Iris-versicolor : 25, Iris-virginica : 25)

data/examples/mnist/mnist.rb

@@ -27,6 +27,7 @@ args = {
   batchsize: 100,
   frequency: -1,
   epoch: 20,
+  gpu: Integer(ENV['RED_CHAINER_GPU'] || -1),
   resume: nil,
   unit: 1000,
   out: 'result'
@@ -35,25 +36,36 @@ args = {
 opt = OptionParser.new
 opt.on('-b', '--batchsize VALUE', "Number of images in each mini-batch (default: #{args[:batchsize]})") { |v| args[:batchsize] = v.to_i }
 opt.on('-e', '--epoch VALUE', "Number of sweeps over the dataset to train (default: #{args[:epoch]})") { |v| args[:epoch] = v.to_i }
+opt.on('-g', '--gpu VALUE', "GPU ID (negative value indicates CPU) (default: #{args[:gpu]})") { |v| args[:gpu] = v.to_i }
 opt.on('-f', '--frequency VALUE', "Frequency of taking a snapshot (default: #{args[:frequency]})") { |v| args[:frequency] = v.to_i }
 opt.on('-o', '--out VALUE', "Directory to output the result (default: #{args[:out]})") { |v| args[:out] = v }
 opt.on('-r', '--resume VALUE', "Resume the training from snapshot") { |v| args[:resume] = v }
 opt.on('-u', '--unit VALUE', "Number of units (default: #{args[:unit]})") { |v| args[:unit] = v.to_i }
 opt.parse!(ARGV)
 
-model = Chainer::Links::Model::Classifier.new(MLP.new(args[:unit], 10))
+puts "GPU: #{args[:gpu]}"
+puts "# unit: #{args[:unit]}"
+puts "# Minibatch-size: #{args[:batchsize]}"
+puts "# epoch: #{args[:epoch]}"
+puts
+
+device = Chainer::Device.create(args[:gpu])
+Chainer::Device.change_default(device)
+
+lossfun = -> (x, t) { Chainer::Functions::Loss::SoftmaxCrossEntropy.new(ignore_label: nil).(x, t) }
+model = Chainer::Links::Model::Classifier.new(MLP.new(args[:unit], 10), lossfun)
 
 optimizer = Chainer::Optimizers::Adam.new
 optimizer.setup(model)
-train, test = Chainer::Datasets::Mnist.get_mnist
+train, test = Chainer::Datasets::MNIST.get_mnist
 
 train_iter = Chainer::Iterators::SerialIterator.new(train, args[:batchsize])
 test_iter = Chainer::Iterators::SerialIterator.new(test, args[:batchsize], repeat: false, shuffle: false)
 
-updater = Chainer::Training::StandardUpdater.new(train_iter, optimizer, device: -1)
+updater = Chainer::Training::StandardUpdater.new(train_iter, optimizer, device: device)
 trainer = Chainer::Training::Trainer.new(updater, stop_trigger: [args[:epoch], 'epoch'], out: args[:out])
 
-trainer.extend(Chainer::Training::Extensions::Evaluator.new(test_iter, model, device: -1))
+trainer.extend(Chainer::Training::Extensions::Evaluator.new(test_iter, model, device: args[:gpu]))
 
 # Take a snapshot for each specified epoch
 frequency = args[:frequency] == -1 ? args[:epoch] : [1, args[:frequency]].max

data/lib/chainer.rb

@@ -3,8 +3,11 @@ require "weakref"
 require "chainer/version"
 
 require 'chainer/cuda'
+require 'chainer/backend'
 require 'chainer/configuration'
+require 'chainer/device'
 require 'chainer/function'
+require 'chainer/function_node'
 require 'chainer/optimizer'
 require 'chainer/gradient_method'
 require 'chainer/gradient_check'
@@ -15,6 +18,7 @@ require 'chainer/initializer'
 require 'chainer/initializers/init'
 require 'chainer/initializers/constant'
 require 'chainer/initializers/normal'
+require 'chainer/initializers/uniform'
 require 'chainer/iterators/serial_iterator'
 require 'chainer/link'
 require 'chainer/links/connection/convolution_2d'
@@ -30,15 +34,28 @@ require 'chainer/utils/variable'
 require 'chainer/utils/array'
 require 'chainer/functions/activation/leaky_relu'
 require 'chainer/functions/activation/relu'
+require 'chainer/functions/activation/relu_grad2'
 require 'chainer/functions/activation/sigmoid'
+require 'chainer/functions/activation/sigmoid_grad'
 require 'chainer/functions/activation/tanh'
 require 'chainer/functions/activation/log_softmax'
+require 'chainer/functions/array/broadcast_to'
+require 'chainer/functions/array/cast'
+require 'chainer/functions/array/reshape'
+require 'chainer/functions/array/rollaxis'
+require 'chainer/functions/array/select_item'
+require 'chainer/functions/array/squeeze'
+require 'chainer/functions/array/transpose'
 require 'chainer/functions/evaluation/accuracy'
 require 'chainer/functions/math/basic_math'
 require 'chainer/functions/math/identity'
+require 'chainer/functions/math/sum'
+require 'chainer/functions/math/exp'
 require 'chainer/functions/loss/mean_squared_error'
 require 'chainer/functions/loss/softmax_cross_entropy'
 require 'chainer/functions/connection/convolution_2d'
+require 'chainer/functions/connection/deconvolution_2d'
+require 'chainer/functions/connection/convolution_2d_grad_w'
 require 'chainer/functions/connection/linear'
 require 'chainer/functions/noise/dropout'
 require 'chainer/functions/normalization/batch_normalization'
@@ -61,7 +78,6 @@ require 'chainer/training/triggers/interval'
 require 'chainer/parameter'
 require 'chainer/optimizers/adam'
 require 'chainer/optimizers/momentum_sgd'
-require 'chainer/dataset/download'
 require 'chainer/datasets/mnist'
 require 'chainer/datasets/cifar'
 require 'chainer/datasets/tuple_dataset'

data/lib/chainer/backend.rb

@@ -0,0 +1,27 @@
+module Chainer
+  # Gets an appropriate one from +Numo::NArray+ or +Cumo::NArray+ from given arrays.
+  #
+  # @param [Array<Chainer::Variable> or Array<Numo::NArray> or Array<Cumo::NArray>] args Values to determine whether Numo or Cumo should be used.
+  # @return [Class] +Cumo::NArray+ or +Numo::NArray+ is returned based on the types of the arguments.
+  def get_array_module(*args)
+    arrays = args.map {|v| v.kind_of?(Chainer::Variable) ? v.data : v }
+    if CUDA.available?
+      return Cumo if arrays.any? {|a| a.kind_of?(Cumo::NArray) }
+    end
+    return Numo
+  end
+  module_function :get_array_module
+
+  # Returns true if the argument is either of +Numo::NArray+ or +Cumo::NArray+.
+  #
+  # @param [Object] obj
+  # @return [Boolean]
+  def array?(obj)
+    if CUDA.available?
+      return true if obj.kind_of?(Cumo::NArray)
+    end
+    return true if obj.kind_of?(Numo::NArray)
+    false
+  end
+  module_function :array?
+end

data/lib/chainer/cuda.rb

@@ -1,18 +1,40 @@
+begin
+  require 'cumo'
+  $chainer_cuda_available = true
+rescue LoadError => e
+  $chainer_cuda_available = false
+  # A trick to make Cumo::NArray always exists
+  module Cumo
+    class NArray; end
+    class NMath; end
+    class Bit; end
+  end
+end
+
 module Chainer
-  # Gets an appropriate one from +Numo::NArray+ or +Cumo::NArray+.
-  #
-  # This is almost equivalent to +Chainer::get_array_module+. The differences
-  # are that this function can be used even if CUDA is not available and that
-  # it will return their data arrays' array module for
-  # +Chainer::Variable+ arguments.
-  #
-  # @param [Array<Chainer::Variable> or Array<Numo::NArray> or Array<Cumo::NArray>] args Values to determine whether Numo or Cumo should be used.
-  # @return [Numo::NArray] +Cumo::NArray+ or +Numo::NArray+ is returned based on the types of
-  #   the arguments.
-  # @todo CUDA is not supported, yet.
-  #
-  def get_array_module(*args)
-    return Numo::NArray
+  module CUDA
+    # Returns whether CUDA is available.
+    #
+    # @param [Integer or nil] id If a non negative integer is given, check availability of GPU ID.
+    # @return [Boolean]
+    def available?(id = nil)
+      return false unless $chainer_cuda_available
+      if id
+        raise 'id must be non negative' if id < 0
+        @device_count ||= Cumo::CUDA::Runtime.cudaGetDeviceCount
+        return @device_count > id
+      end
+      true
+    end
+    module_function :available?
+
+    # Checks if CUDA is available.
+    #
+    # @param [Integer or nil] id If a non negative integer is given, check availability of GPU ID.
+    # @raise [RuntimeError] if not available
+    def check_available(id = nil)
+      raise 'CUDA is not available' unless available?(id)
+    end
+    module_function :check_available
   end
-  module_function :get_array_module
 end

data/lib/chainer/dataset/convert.rb

@@ -2,12 +2,13 @@ module Chainer
   module Dataset
     module Convert
       def self.to_device(device, x)
-        # TODO: support cuda
+        # TODO(sonots): Implement after Cumo supports transferring between devices
         x
       end
 
       def self.concat_examples(batch, device: nil, padding: nil)
         raise "batch is empty" if batch.size == 0
+        device = device ? Chainer::Device.create(device) : Chainer::Device.default # takes care of int and nil
         first_elem = batch[0]
 
         if first_elem.kind_of?(Array)
@@ -17,28 +18,29 @@ module Chainer
           end
 
           first_elem.size.times do |i|
-            x = concat_arrays(batch.map { |b| b[i] }, padding[i])
+            x = _concat_arrays(batch.map { |b| b[i] }, padding[i], device)
             result.push(to_device(device, x))
           end
 
           return result
         else
-          return to_device(device, concat_arrays(batch, padding))
+          return _concat_arrays(batch, padding, device)
         end
       end
 
-      def self.concat_arrays(arrays, padding)
-        unless arrays[0].kind_of?(Numo::NArray)
+      def self._concat_arrays(arrays, padding, device)
+        xm = device.xm
+        unless arrays[0].kind_of?(xm::NArray)
           # [1, 2, 3, 4] => Numo::Int32[1, 2, 3, 4]
-          arrays = Numo::NArray.cast(arrays)
+          arrays = xm::NArray.cast(arrays)
           if padding
-            return concat_arrays_with_padding(arrays, padding)
+            return _concat_arrays_with_padding(arrays, padding, device)
           end
           return arrays
         end
 
         if padding
-          return concat_arrays_with_padding(arrays, padding)
+          return _concat_arrays_with_padding(arrays, padding, device)
         end
 
         # [Numo::SFloat[1, 2], Numo::SFloat[3, 4]]
@@ -48,12 +50,14 @@ module Chainer
         a[0].concatenate(*a[1..-1])
       end
 
-      def self.concat_arrays_with_padding(arrays, padding)
-        if arrays[0].is_a? Numo::NArray
-          shape = Numo::Int32.cast(arrays[0].shape)
+      def self._concat_arrays_with_padding(arrays, padding, device)
+        xm = device.xm
+        if Chainer.array?(arrays[0]) and arrays[0].ndim > 0
+          xm = Chainer.get_array_module(arrays[0])
+          shape = xm::Int32.cast(arrays[0].shape)
           arrays[1..-1].each do |array|
-            if Numo::Bit.[](shape != array.shape).any?
-              shape = Numo::Int32.maximum(shape, array.shape)
+            if xm::Bit.[](shape != array.shape).any?
+              shape = xm::Int32.maximum(shape, array.shape)
             end
           end
         else # Integer
@@ -61,15 +65,15 @@ module Chainer
         end
 
         shape = shape.insert(0, arrays.size).to_a
-        if arrays[0].is_a? Numo::NArray
+        if Chainer.array?(arrays[0]) and arrays[0].ndim > 0
           result = arrays[0].class.new(shape).fill(padding)
         else # Integer
-          result = Numo::Int32.new(shape).fill(padding)
+          result = xm::Int32.new(shape).fill(padding)
         end
 
         arrays.size.times do |i|
           src = arrays[i]
-          if src.is_a? Numo::NArray
+          if Chainer.array?(src) and src.ndim > 0
             result[i, 0...src.shape[0], 0...src.shape[1]] = src
           else # Integer
             result[i] = src