red-chainer 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bd5f287aafbc100878391131a0a184c9c6497ddb26e0c5124010166aa455def
-  data.tar.gz: 6625f1d862ba17db5867b208494419f1e7e7bc1ed5b5276bec785151140a47bd
+  metadata.gz: 18e976d36f56e110baeae2d799471b4be2e4932778316ffcb3aafa51563bd3fd
+  data.tar.gz: f5429173d5b175738f4358774d9f058e31a86eec1418954cbad72d7875a2a7b8
 SHA512:
-  metadata.gz: 659986f00b88051471ca54a88eafb4a6f9ebbdf8f27a9f51c8ff32a27f584d2a78015d47baf20e74c6e9605c09bda0777b4780c4ef79313d194a362e0d3ff013
-  data.tar.gz: a468488ee913244bcdbc058fe27c93beec897bd4476f1eec50ae2bc3071124701aaf37b9f15cd07848bbb30372e4796c04b24ead672c28e5fcb0dbb1721b7bd6
+  metadata.gz: b1a617684703b92491e7876d919c2f6ef9c144039b9e12086d5b2ec7aed8644eca3ea8b2f4b32f2ef98fb6f31db4068b67467f95aa0a5868b3a903e073909b2e
+  data.tar.gz: '095870edbd1c68d35da023e9dd9a16096585a264f8e9cedf2c49dc465a62687a46634c58ee8a2d5fca4b2c41872f2f335455e076da66996a47f6c658ca6987e6'

data/examples/cifar/models/resnet18.rb

@@ -0,0 +1,90 @@
+module ResNet18
+  class Plain < Chainer::Chain
+    include Chainer::Functions::Activation
+    include Chainer::Initializers
+    include Chainer::Links::Connection
+    include Chainer::Links::Normalization
+
+    def initialize(ch, stride, use_conv: false)
+      super()
+
+      @use_conv = use_conv
+      w = HeNormal.new
+
+      init_scope do
+        @conv1 = Convolution2D.new(nil, ch, 3, stride: stride, pad: 1, nobias: true, initial_w: w)
+        @bn1 = BatchNormalization.new(ch)
+        @conv2 = Convolution2D.new(nil, ch, 3, stride: 1, pad: 1, nobias: true, initial_w: w)
+        @bn2 = BatchNormalization.new(ch)
+        if @use_conv
+          @conv3 = Convolution2D.new(nil, ch, 3, stride: stride, pad: 1, nobias: true, initial_w: w)
+          @bn3 = BatchNormalization.new(ch)
+        end
+      end
+    end
+
+    def call(x)
+      h = Relu.relu(@bn1.(@conv1.(x)))
+      h = @bn2.(@conv2.(h))
+      if @use_conv
+        h2 = @bn3.(@conv3.(x))
+        Relu.relu(h + h2)
+      else
+        Relu.relu(h + x)
+      end
+    end
+  end
+
+  class Block < Chainer::ChainList
+    def initialize(layer, ch, stride=2)
+      super()
+      add_link(Plain.new(ch, stride, use_conv: true))
+      (layer-1).times do
+        add_link(Plain.new(ch, 1))
+      end
+    end
+
+    def call(x)
+      @children.each do |f|
+        x = f.(x)
+      end
+      x
+    end
+  end
+
+  class Model < Chainer::Chain
+    include Chainer::Functions::Activation
+    include Chainer::Functions::Evaluation
+    include Chainer::Functions::Loss
+    include Chainer::Functions::Pooling
+    include Chainer::Initializers
+    include Chainer::Links::Connection
+    include Chainer::Links::Normalization
+
+    def initialize(n_classes: 10)
+      super()
+      initial_w = HeNormal.new
+
+      init_scope do
+        @conv = Convolution2D.new(3, 64, 7, stride: 2, pad: 3, initial_w: initial_w)
+        @bn = BatchNormalization.new(64)
+
+        @res2 = Block.new(2, 64, 1)
+        @res3 = Block.new(2, 128)
+        @res4 = Block.new(2, 256)
+        @res5 = Block.new(2, 512)
+        @fc = Linear.new(nil, out_size: n_classes)
+      end
+    end
+
+    def call(x)
+      h = Relu.relu(@bn.(@conv.(x)))
+      h = @res2.(h)
+      h = @res3.(h)
+      h = @res4.(h)
+      h = @res5.(h)
+      h = AveragePooling2D.average_pooling_2d(h, h.shape[2..-1])
+      @fc.(h)
+    end
+  end
+end

data/examples/cifar/models/vgg.rb

@@ -15,7 +15,7 @@ class Block < Chainer::Chain
 end
 
 class VGG < Chainer::Chain
-  def initialize(class_labels: 10)
+  def initialize(n_classes: 10)
     super()
     init_scope do
       @block1_1 = Block.new(64, 3)
@@ -33,7 +33,7 @@ class VGG < Chainer::Chain
       @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)
+      @fc2 = Chainer::Links::Connection::Linear.new(nil, out_size: n_classes, nobias: true)
     end
   end
 

data/examples/cifar/train_cifar.rb

@@ -1,5 +1,6 @@
 require 'chainer'
 require __dir__ + '/models/vgg'
+require __dir__ + '/models/resnet18'
 require 'optparse'
 
 args = {
@@ -9,7 +10,8 @@ args = {
   learnrate: 0.05,
   epoch: 300,
   out: 'result',
-  resume: nil
+  resume: nil,
+  model: 'vgg',
 }
 
 
@@ -21,6 +23,7 @@ opt.on('-l', '--learnrate VALUE', "Learning rate for SGD (default: #{args[:learn
 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.on('-m', '--model VALUE', "Use model") { |v| args[:model] = v }
 opt.parse!(ARGV)
 
 # Set up a neural network to train.
@@ -38,9 +41,15 @@ else
     raise 'Invalid dataset choice.'
 end
 
-puts "setup..."
+if args[:model] == 'vgg'
+  puts 'Using VGG model'
+  model_class = VGG
+elsif args[:model] == 'resnet18'
+  puts 'Using ResNet-18 model'
+  model_class = ResNet18::Model
+end
 
-model = Chainer::Links::Model::Classifier.new(VGG.new(class_labels: class_labels))
+model = Chainer::Links::Model::Classifier.new(model_class.new(n_classes: class_labels))
 
 optimizer = Chainer::Optimizers::MomentumSGD.new(lr: args[:learnrate])
 optimizer.setup(model)
@@ -58,7 +67,7 @@ trainer.extend(Chainer::Training::Extensions::ExponentialShift.new('lr', 0.5), t
 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::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)
 

data/lib/chainer.rb

@@ -43,6 +43,7 @@ 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/average_pooling_2d'
 require 'chainer/functions/pooling/max_pooling_2d'
 require 'chainer/testing/array'
 require 'chainer/training/extension'

data/lib/chainer/datasets/cifar.rb

@@ -40,7 +40,7 @@ module Chainer
         else
           raise 'invalid ndim for CIFAR dataset'
         end
-        images = images.cast_to(Numo::DFloat)
+        images = images.cast_to(Numo::SFloat)
         images *= scale / 255.0
 
         if withlabel

data/lib/chainer/datasets/tuple_dataset.rb

@@ -21,7 +21,7 @@ module Chainer
         end
         if index.kind_of?(Enumerable)
           length = batches[0].shape[0]
-          length.times.map {|i| batches.map { |m| m[i] } }
+          length.times.map {|i| batches.map { |m| m.ndim > 1 ? m[i, false] : m[i] } }
         else
           batches
         end

data/lib/chainer/functions/pooling/average_pooling_2d.rb

@@ -0,0 +1,45 @@
+module Chainer
+  module Functions
+    module Pooling
+      class AveragePooling2D < Pooling2D
+        # Spatial average pooling function.
+        #
+        # This function acts similarly to :class:`Convolution2D`,
+        # but it computes the average of input spatial patch for each channel
+        # without any parameter instead of computing the inner products.
+        # @param [Chainer::Variable] x Input variable.
+        # @param [integer] ksize Size of pooling window. `ksize=k` and `ksize=[k, k]` are equivalent.
+        # @param [integer] stride Stride of pooling applications. `stride=s` and `stride=[s, s]` are equivalent.
+        #                  If `nil` is specified, then it uses same stride as the pooling window size.
+        # @param [integer] pad Spatial padding width for the input array. `pad=p` and `pad=[p, p]` are equivalent.
+        # @return [Chainer::Variable] Output variable
+        def self.average_pooling_2d(x, ksize, stride: nil, pad: 0)
+          self.new(ksize, stride: stride, pad: pad, cover_all: false).(x)
+        end
+
+        # Average pooling over a set of 2d planes.
+        def forward_cpu(x)
+          retain_inputs([])
+          @in_shape = x[0].shape
+          @in_dtype = x[0].class
+
+          col = Chainer::Utils::Conv.im2col_cpu(x[0], @kh, @kw, @sy, @sx, @ph, @pw)
+          y = col.mean(axis: [2, 3])
+
+          [y]
+        end
+
+        def backward_cpu(x, gy)
+          h, w  = @in_shape[2..-1]
+          shape = gy[0].shape
+          shape.insert(2, 1, 1)
+          gcol = gy[0].reshape(*shape).tile(1, 1, @kh, @kw, 1, 1)
+
+          gx = Chainer::Utils::Conv.col2im_cpu(gcol, @sy, @sx, @ph, @pw, h, w)
+          gx /= @kh * @kw
+          [gx]
+        end
+      end
+    end
+  end
+end

data/lib/chainer/initializers/init.rb

@@ -13,8 +13,8 @@ module Chainer
       return HeNormal.new(scale: 1 / Numo::NMath.sqrt(2)) if initializer.nil?
       return Constant.new(initializer) if initializer.kind_of?(Numeric)
       return Constant.new(initializer) if initializer.kind_of?(Numo::NArray)
-      
-      unless initializer.method_defined?(:call)
+
+      unless initializer.respond_to?(:call)
         raise TypeError, "invalid type of initializer: #{initializer.class}"
       end
 

data/lib/chainer/link.rb

@@ -1,5 +1,7 @@
 module Chainer
   class Link
+    attr_accessor :name
+
     def initialize
       @params = []
       @persistent = []
@@ -17,22 +19,28 @@ module Chainer
 
       begin
         yield
-        set_attr
+        self.instance_variables.each do |name|
+          set_attr(name, self.instance_variable_get(name))
+        end
       ensure
         @within_init_scope = old_flag
       end
     end
 
-    def set_attr
-      self.instance_variables.each do |name|
-        value = self.instance_variable_get(name)
-        if value.instance_of?(Chainer::Parameter)
-          @params << name
-          @persistent.delete(name)
-        end
+    def set_attr(name, value)
+      if within_init_scope && value.kind_of?(Chainer::Parameter)
+        value.name = name
+        @params << name
+        @persistent.delete(name)
       end
     end
 
+    def del_attr(name)
+      @params.delete(name)
+      @persistent.delete(name)
+      self.remove_instance_variable(name)
+    end
+
     def cleargrads
       params do |param|
         param.cleargrad
@@ -99,16 +107,22 @@ module Chainer
       @children = []
     end
 
-    def set_attr
-      self.instance_variables.each do |name|
-        value = self.instance_variable_get(name)
-        if value.kind_of?(Chainer::Link)
-          @children << name
+    def set_attr(name, value)
+      if within_init_scope && value.kind_of?(Chainer::Link)
+        if self.respond_to?(name)
+          raise TypeError, "cannot register a new link #{name}: attribute exists"
         end
+        value.name = name
+        @children << name
       end
       super
     end
 
+    def del_attr(name)
+      @children.delete(name)
+      super
+    end
+
     def params(include_uninit: true)
       super(include_uninit: include_uninit) do |param|
         yield param
@@ -155,4 +169,118 @@ module Chainer
       end
     end
   end
+
+
+  # Composable link with list-like interface.
+  #
+  # This is another example of compositional link. Unlike :class:`Chainer::Chain`,
+  # this class can be used like a list of child links.
+  # Each child link is indexed by a non-negative integer,
+  # and it maintains the current number of registered child links.
+  # The :meth:`add_link` method inserts a new link at the end of the list.
+  # It is useful to write a chain with arbitrary number of child links,
+  # e.g. an arbitrarily deep multi-layer perceptron.
+  class ChainList < Link
+    attr_reader :children
+
+    def initialize(*links)
+      super()
+      @children = []
+
+      links.each do |link|
+        add_link(link)
+      end
+    end
+
+    def set_attr(name, value)
+      if within_init_scope && value.kind_of?(Chainer::Link)
+        raise TypeError, 'cannot register a new link within a "with chainlist.init_scope:" block.'
+      end
+      super
+    end
+
+    def [](index)
+      @children[index]
+    end
+
+    def each(&block)
+      @children.each(&block)
+    end
+
+    def size
+      @children.size
+    end
+
+    def <<(link)
+      add_link(link)
+    end
+
+    def add_link(link)
+      link.name = @children.size.to_s
+      @children << link
+    end
+
+    def params(include_uninit: true)
+      super(include_uninit: include_uninit) do |param|
+        yield param
+      end
+
+      @children.each do |link|
+        link.params(include_uninit: include_uninit) do |param|
+          yield param
+        end
+      end
+    end
+
+    def namedparams(include_uninit: true)
+      super(include_uninit: include_uninit) do |ret|
+        yield ret
+      end
+      @children.each_with_index do |link, idx|
+        prefix = "/#{idx}"
+        link.namedparams(include_uninit: include_uninit) do |path, param|
+          yield [prefix + path, param]
+        end
+      end
+    end
+
+    def links(skipself: false)
+      unless skipself
+        yield self
+      end
+
+      @children.each do |child|
+        child.links do |link|
+          yield link
+        end
+      end
+    end
+
+    def namedlinks(skipself: false)
+      unless skipself
+        yield '/', self
+      end
+
+      @children.each_with_index do |child, idx|
+        prefix = "/#{idx}"
+        yield prefix, child
+        child.namedlinks(skipself: true) do |path, link|
+          yield [prefix + path, link]
+        end
+      end
+    end
+
+    def children
+      @children.each do |child|
+        yield child
+      end
+    end
+
+    def serialize(serializer)
+      super
+      @children.each_with_index do |child, idx|
+        child.serialize(serializer[idx.to_s])
+      end
+    end
+  end
 end

data/lib/chainer/links/normalization/batch_normalization.rb

@@ -23,7 +23,7 @@ module Chainer
         # @param [Numo::NArray.dtype] dtype Type to use in computing.
         # @param [boolean] use_gamma If `true`, use scaling parameter. Otherwise, use unit(1) which makes no effect.
         # @param [boolean] use_beta If `true`, use shifting parameter. Otherwise, use unit(0) which makes no effect.
-        def initialize(size, decay: 0.9, eps: 2e-5, dtype: Numo::DFloat, use_gamma: true, use_beta: true, initial_gamma: nil, initial_beta: nil)
+        def initialize(size, decay: 0.9, eps: 2e-5, dtype: Numo::SFloat, use_gamma: true, use_beta: true, initial_gamma: nil, initial_beta: nil)
           super()
           @avg_mean = dtype.zeros(size)
           register_persistent('avg_mean')

data/lib/chainer/version.rb

@@ -1,4 +1,4 @@
 module Chainer
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-chainer
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Yusaku Hatanaka
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-19 00:00:00.000000000 Z
+date: 2018-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -96,6 +96,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/cifar/models/resnet18.rb
 - examples/cifar/models/vgg.rb
 - examples/cifar/train_cifar.rb
 - examples/iris.rb
@@ -124,6 +125,7 @@ files:
 - lib/chainer/functions/math/identity.rb
 - lib/chainer/functions/noise/dropout.rb
 - lib/chainer/functions/normalization/batch_normalization.rb
+- lib/chainer/functions/pooling/average_pooling_2d.rb
 - lib/chainer/functions/pooling/max_pooling_2d.rb
 - lib/chainer/functions/pooling/pooling_2d.rb
 - lib/chainer/gradient_check.rb