red-chainer 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fae8ab4c6d546356b7171ba9823e1537f02ad5e08358d97b29d907e67e11b20
-  data.tar.gz: 87b807d2cdf48b060100ade6c0f294e249db8f8a6a131754c4a108758867a1e5
+  metadata.gz: 4bd5f287aafbc100878391131a0a184c9c6497ddb26e0c5124010166aa455def
+  data.tar.gz: 6625f1d862ba17db5867b208494419f1e7e7bc1ed5b5276bec785151140a47bd
 SHA512:
-  metadata.gz: b533669c998ef246222a001658193e489c5500a4d9276c53e43c332543342bb258c2a8cf8958b47cd5201c52c8f6c3d1378af33c20c0f3644d0d155addeafc04
-  data.tar.gz: 16c2e65110c8a83e42d85e482a35209463c36766d2eb6d6eb76045f44d55472f5f6c94b8050221f2273f5e8d2ba644648fb3c10b2a0b9cf4d03b86495470d7a0
+  metadata.gz: 659986f00b88051471ca54a88eafb4a6f9ebbdf8f27a9f51c8ff32a27f584d2a78015d47baf20e74c6e9605c09bda0777b4780c4ef79313d194a362e0d3ff013
+  data.tar.gz: a468488ee913244bcdbc058fe27c93beec897bd4476f1eec50ae2bc3071124701aaf37b9f15cd07848bbb30372e4796c04b24ead672c28e5fcb0dbb1721b7bd6

data/README.md

@@ -2,7 +2,7 @@
 
 ## Name
 
-Red Cahiner
+Red Chainer
 
 ## Description
 Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/chainer`. To experiment with that code, run `bin/console` for an interactive prompt.
@@ -39,4 +39,4 @@ $ ruby examples/mnist.rb
 
 ## License
 
-The MIT license. See [LICENSE.txt](./LICENSE.txt) for details.
+The MIT license. See [LICENSE.txt](./LICENSE.txt) for details.

data/examples/cifar/models/vgg.rb

@@ -0,0 +1,84 @@
+class Block < Chainer::Chain
+  def initialize(out_channels, ksize, pad: 1)
+    super()
+    init_scope do
+      @conv = Chainer::Links::Connection::Convolution2D.new(nil, out_channels, ksize, pad: pad, nobias: true)
+      @bn = Chainer::Links::Normalization::BatchNormalization.new(out_channels)
+    end
+  end
+
+  def call(x)
+    h = @conv.(x)
+    h = @bn.(h)
+    Chainer::Functions::Activation::Relu.relu(h)
+  end
+end
+
+class VGG < Chainer::Chain
+  def initialize(class_labels: 10)
+    super()
+    init_scope do
+      @block1_1 = Block.new(64, 3)
+      @block1_2 = Block.new(64, 3)
+      @block2_1 = Block.new(128, 3)
+      @block2_2 = Block.new(128, 3)
+      @block3_1 = Block.new(256, 3)
+      @block3_2 = Block.new(256, 3)
+      @block3_3 = Block.new(256, 3)
+      @block4_1 = Block.new(512, 3)
+      @block4_2 = Block.new(512, 3)
+      @block4_3 = Block.new(512, 3)
+      @block5_1 = Block.new(512, 3)
+      @block5_2 = Block.new(512, 3)
+      @block5_3 = Block.new(512, 3)
+      @fc1 = Chainer::Links::Connection::Linear.new(nil, out_size: 512, nobias: true)
+      @bn_fc1 = Chainer::Links::Normalization::BatchNormalization.new(512)
+      @fc2 = Chainer::Links::Connection::Linear.new(nil, out_size: class_labels, nobias: true)
+    end
+  end
+
+  def call(x)
+    # 64 channel blocks:
+    h = @block1_1.(x)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.3)
+    h = @block1_2.(h)
+    h = Chainer::Functions::Pooling::MaxPooling2D.max_pooling_2d(h, 2, stride: 2)
+
+    # 128 channel blocks:
+    h = @block2_1.(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.4)
+    h = @block2_2.(h)
+    h = Chainer::Functions::Pooling::MaxPooling2D.max_pooling_2d(h, 2, stride:2)
+
+    # 256 channel blocks:
+    h = @block3_1.(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.4)
+    h = @block3_2.(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.4)
+    h = @block3_3.(h)
+    h = Chainer::Functions::Pooling::MaxPooling2D.max_pooling_2d(h, 2, stride: 2)
+
+    # 512 channel blocks:
+    h = @block4_1.(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.4)
+    h = @block4_2.(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.4)
+    h = @block4_3.(h)
+    h = Chainer::Functions::Pooling::MaxPooling2D.max_pooling_2d(h, 2, stride: 2)
+
+    # 512 channel blocks:
+    h = @block5_1.(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.4)
+    h = @block5_2.(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.4)
+    h = @block5_3.(h)
+    h = Chainer::Functions::Pooling::MaxPooling2D.max_pooling_2d(h, 2, stride: 2)
+
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.5)
+    h = @fc1.(h)
+    h = @bn_fc1.(h)
+    h = Chainer::Functions::Activation::Relu.relu(h)
+    h = Chainer::Functions::Noise::Dropout.dropout(h, ratio: 0.5)
+    @fc2.(h)
+  end
+end

data/examples/cifar/train_cifar.rb

@@ -0,0 +1,70 @@
+require 'chainer'
+require __dir__ + '/models/vgg'
+require 'optparse'
+
+args = {
+  dataset: 'cifar10',
+  frequency: -1,
+  batchsize: 64,
+  learnrate: 0.05,
+  epoch: 300,
+  out: 'result',
+  resume: nil
+}
+
+
+opt = OptionParser.new
+opt.on('-d', '--dataset VALUE', "The dataset to use: cifar10 or cifar100 (default: #{args[:dataset]})") { |v| args[:dataset] = v }
+opt.on('-b', '--batchsize VALUE', "Number of images in each mini-batch (default: #{args[:batchsize]})") { |v| args[:batchsize] = v.to_i }
+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('-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.parse!(ARGV)
+
+# 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.
+if args[:dataset] == 'cifar10'
+    puts 'Using CIFAR10 dataset.'
+    class_labels = 10
+    train, test = Chainer::Datasets::CIFAR.get_cifar10
+elsif args[:dataset] == 'cifar100'
+    puts 'Using CIFAR100 dataset.'
+    class_labels = 100
+    train, test = Chainer::Datasets::CIFAR.get_cifar100
+else
+    raise 'Invalid dataset choice.'
+end
+
+puts "setup..."
+
+model = Chainer::Links::Model::Classifier.new(VGG.new(class_labels: class_labels))
+
+optimizer = Chainer::Optimizers::MomentumSGD.new(lr: args[:learnrate])
+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)
+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::ExponentialShift.new('lr', 0.5), trigger: [25, 'epoch'])
+
+frequency = args[:frequency] == -1 ? args[:epoch] : [1, args[:frequency]].max
+trainer.extend(Chainer::Training::Extensions::Snapshot.new, trigger: [frequency, 'epoch'])
+
+trainer.extend(Chainer::Training::Extensions::LogReport.new)    
+trainer.extend(Chainer::Training::Extensions::PrintReport.new(['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
+trainer.extend(Chainer::Training::Extensions::ProgressBar.new)
+
+if args[:resume]
+  Chainer::Serializers::MarshalDeserializer.load_file(args[:resume], trainer)
+end
+
+trainer.run
+

data/examples/iris.rb

@@ -0,0 +1,103 @@
+require 'numo/narray'
+require 'chainer'
+require "datasets"
+
+class IrisChain < Chainer::Chain
+  L = Chainer::Links::Connection::Linear
+  F = Chainer::Functions
+
+  def initialize(n_units, n_out)
+    super()
+    init_scope do
+      @l1 = L.new(nil, out_size: n_units)
+      @l2 = L.new(nil, out_size: n_out)
+    end
+  end
+
+  def call(x, y)
+    return F::Loss::MeanSquaredError.mean_squared_error(fwd(x), y)
+  end
+
+  def fwd(x)
+    h1 = F::Activation::Sigmoid.sigmoid(@l1.(x))
+    h2 = @l2.(h1)
+    return h2
+  end
+end
+
+model = IrisChain.new(6,3)
+
+optimizer = Chainer::Optimizers::Adam.new
+optimizer.setup(model)
+
+iris = Datasets::Iris.new
+x = iris.each.map {|r| r.each.to_a[0..3]}
+
+# target
+y_class = iris.each.map {|r| r.class}
+
+# class index array
+# ["Iris-setosa", "Iris-versicolor", "Iris-virginica"]
+class_name = y_class.uniq
+# y => [0, 0, 0, 0, ,,, 1, 1, ,,, ,2, 2]
+y = y_class.map{|s|
+  class_name.index(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 = y_class.map{|s|
+  i = class_name.index(s)
+  a = Array.new(class_name.size, 0.0)
+  a[i] = 1.0
+  a
+}
+
+puts "Iris Datasets"
+puts "No. [sepal_length, sepal_width, petal_length, petal_width] one-hot #=> class"
+x.each_with_index{|r, i|
+  puts "#{'%3d' % i} : [#{r.join(', ')}] #{y_onehot[i]} #=> #{y_class[i]}(#{y[i]})"
+}
+# [5.1, 3.5, 1.4, 0.2, "Iris-setosa"]     => 50 data
+# [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_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)
+x_test = x[(0..-1).step(2), true]         #=> 75 data (Iris-setosa : 25, Iris-versicolor : 25, Iris-virginica : 25)
+y_test = y[(0..-1).step(2)]               #=> 75 data (Iris-setosa : 25, Iris-versicolor : 25, Iris-virginica : 25)
+
+# Train
+10000.times{|i|
+  x = Chainer::Variable.new(x_train)
+  y = Chainer::Variable.new(y_train)
+  model.cleargrads()
+  loss = model.(x, y)
+  loss.backward()
+  optimizer.update()
+}
+
+# Test
+xt = Chainer::Variable.new(x_test)
+yt = model.fwd(xt)
+n_row, n_col = yt.data.shape
+
+puts "Result : Correct Answer : Answer <= One-Hot"
+ok = 0
+n_row.times{|i|
+  ans = yt.data[i, true].max_index()
+  if ans == y_test[i]
+    ok += 1
+    printf("OK")
+  else
+    printf("--")
+  end
+  printf(" : #{y_test[i].to_i} :")
+
+  puts " #{ans.to_i} <= #{yt.data[i, 0..-1].to_a}"
+}
+puts "Row: #{n_row}, Column: #{n_col}"
+puts "Accuracy rate : #{ok}/#{n_row} = #{ok.to_f / n_row}"

data/lib/chainer.rb

@@ -2,10 +2,12 @@ require "weakref"
 
 require "chainer/version"
 
+require 'chainer/cuda'
 require 'chainer/configuration'
 require 'chainer/function'
 require 'chainer/optimizer'
 require 'chainer/gradient_method'
+require 'chainer/gradient_check'
 require 'chainer/hyperparameter'
 require 'chainer/dataset/iterator'
 require 'chainer/dataset/convert'
@@ -15,11 +17,15 @@ require 'chainer/initializers/constant'
 require 'chainer/initializers/normal'
 require 'chainer/iterators/serial_iterator'
 require 'chainer/link'
+require 'chainer/links/connection/convolution_2d'
 require 'chainer/links/connection/linear'
+require 'chainer/links/normalization/batch_normalization'
 require 'chainer/links/model/classifier'
 require 'chainer/variable'
 require 'chainer/variable_node'
+require 'chainer/utils/conv'
 require 'chainer/utils/initializer'
+require 'chainer/utils/math'
 require 'chainer/utils/variable'
 require 'chainer/utils/array'
 require 'chainer/functions/activation/leaky_relu'
@@ -29,10 +35,19 @@ require 'chainer/functions/activation/tanh'
 require 'chainer/functions/activation/log_softmax'
 require 'chainer/functions/evaluation/accuracy'
 require 'chainer/functions/math/basic_math'
+require 'chainer/functions/math/identity'
+require 'chainer/functions/loss/mean_squared_error'
 require 'chainer/functions/loss/softmax_cross_entropy'
+require 'chainer/functions/connection/convolution_2d'
 require 'chainer/functions/connection/linear'
+require 'chainer/functions/noise/dropout'
+require 'chainer/functions/normalization/batch_normalization'
+require 'chainer/functions/pooling/pooling_2d'
+require 'chainer/functions/pooling/max_pooling_2d'
+require 'chainer/testing/array'
 require 'chainer/training/extension'
 require 'chainer/training/extensions/evaluator'
+require 'chainer/training/extensions/exponential_shift'
 require 'chainer/training/extensions/log_report'
 require 'chainer/training/extensions/print_report'
 require 'chainer/training/extensions/progress_bar'
@@ -44,8 +59,10 @@ require 'chainer/training/standard_updater'
 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'
 require 'chainer/reporter'
 require 'chainer/serializer'

data/lib/chainer/configuration.rb

@@ -1,9 +1,10 @@
 module Chainer
   class Configuration
-    attr_accessor :enable_backprop
+    attr_accessor :enable_backprop, :train
 
     def initialize
       @enable_backprop = true
+      @train = true
     end
   end
 end

data/lib/chainer/cuda.rb

@@ -0,0 +1,18 @@
+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
+  end
+  module_function :get_array_module
+end

data/lib/chainer/dataset/convert.rb

@@ -29,30 +29,51 @@ module Chainer
 
       def self.concat_arrays(arrays, padding)
         unless arrays[0].kind_of?(Numo::NArray)
+          # [1, 2, 3, 4] => Numo::Int32[1, 2, 3, 4]
           arrays = Numo::NArray.cast(arrays)
+          if padding
+            return concat_arrays_with_padding(arrays, padding)
+          end
+          return arrays
         end
 
         if padding
           return concat_arrays_with_padding(arrays, padding)
         end
 
-        Numo::NArray.[](*arrays.to_a.map { |arr| arr.kind_of?(Numeric) ? arr : Numo::NArray.[](*arr) })
+        # [Numo::SFloat[1, 2], Numo::SFloat[3, 4]]
+        #  => Numo::SFloat#shape=[2,2]
+        # [[1, 2], [3, 4]]
+        a = arrays.map{|arr| arr[:-, false]}
+        a[0].concatenate(*a[1..-1])
       end
 
       def self.concat_arrays_with_padding(arrays, padding)
-        shape = Numo::Int32.[](arrays[0].shape)
-        arrays[1...arrays.len].each do |array|
-          if Numo::Bit.[](shape != array.shape).any?
-            # TODO: numpy maximum
+        if arrays[0].is_a? Numo::NArray
+          shape = Numo::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)
+            end
           end
+        else # Integer
+          shape = []
+        end
+
+        shape = shape.insert(0, arrays.size).to_a
+        if arrays[0].is_a? Numo::NArray
+          result = arrays[0].class.new(shape).fill(padding)
+        else # Integer
+          result = Numo::Int32.new(shape).fill(padding)
         end
 
-        shape = [shape.insert(0, arrays.size)]
-        result = arrays[0].dtype.[](*shape).full(padding)
         arrays.size.times do |i|
           src = arrays[i]
-          slices = src.shape.map { |s| [s] }
-          result[[i] + slices] = src
+          if src.is_a? Numo::NArray
+            result[i, 0...src.shape[0], 0...src.shape[1]] = src
+          else # Integer
+            result[i] = src
+          end
         end
 
         result

data/lib/chainer/datasets/cifar.rb

@@ -0,0 +1,56 @@
+require 'datasets'
+
+module Chainer
+  module Datasets
+    module CIFAR
+      def self.get_cifar10(with_label: true, ndim: 3, scale: 1.0)
+        get_cifar(10, with_label, ndim, scale)
+      end
+
+      def self.get_cifar100(with_label: true, ndim: 3, scale: 1.0)
+        get_cifar(100, with_label, ndim, scale)
+      end
+
+      def self.get_cifar(n_classes, with_label, ndim, scale)
+        train_data = []
+        train_labels = []
+        ::Datasets::CIFAR.new(n_classes: n_classes, type: :train).each do |record|
+          train_data << record.pixels
+          train_labels << (n_classes == 10 ? record.label : record.fine_label)
+        end
+
+        test_data = []
+        test_labels = []
+        ::Datasets::CIFAR.new(n_classes: n_classes, type: :test).each do |record|
+          test_data << record.pixels
+          test_labels << (n_classes == 10 ? record.label : record.fine_label)
+        end
+
+        [
+          preprocess_cifar(Numo::UInt8[*train_data], Numo::UInt8[*train_labels], with_label, ndim, scale),
+          preprocess_cifar(Numo::UInt8[*test_data], Numo::UInt8[*test_labels], with_label, ndim, scale)
+        ]
+      end
+
+      def self.preprocess_cifar(images, labels, withlabel, ndim, scale)
+        if ndim == 1
+          images = images.reshape(images.shape[0], 3072)
+        elsif ndim == 3
+          images = images.reshape(images.shape[0], 3, 32, 32)
+        else
+          raise 'invalid ndim for CIFAR dataset'
+        end
+        images = images.cast_to(Numo::DFloat)
+        images *= scale / 255.0
+
+        if withlabel
+          labels = labels.cast_to(Numo::Int32)
+          TupleDataset.new(images, labels)
+        else
+          images
+        end
+      end
+    end
+  end
+end
+