red-chainer 0.3.2 → 0.4.0

data/lib/chainer/gradient_method.rb

@@ -15,13 +15,14 @@ module Chainer
     def reallocate_cleared_grads
       @target.namedparams(include_uninit: false) do |(name, param)|
         if param.grad.nil?
-          param.grad = Numo::NArray.[](*param.data).new_zeros
+          xm = Chainer.get_array_module(param.data)
+          param.grad = xm::NArray.[](*param.data).new_zeros
         end
       end
     end
 
     def call_hooks
-      @hooks.each do |hook|
+      @hooks.values.each do |hook|
         _call_hook(hook)
         reallocate_cleared_grads
       end

data/lib/chainer/initializers/init.rb

@@ -1,7 +1,7 @@
 module Chainer
   module Initializers
-    def self.generate_array(initializer, shape)
-      klass = Numo::SFloat
+    def self.generate_array(initializer, shape, device: Chainer::Device.default)
+      klass = device.xm::SFloat
       if initializer.respond_to?(:dtype) && initializer.dtype
         klass = initializer.dtype
       end
@@ -9,10 +9,10 @@ module Chainer
       initializer.(array)
     end
 
-    def self.get_initializer(initializer)
-      return HeNormal.new(scale: 1 / Numo::NMath.sqrt(2)) if initializer.nil?
+    def self.get_initializer(initializer, device: Chainer::Device.default)
+      return HeNormal.new(scale: 1 / device.xm::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)
+      return Constant.new(initializer) if Chainer.array?(initializer)
 
       unless initializer.respond_to?(:call)
         raise TypeError, "invalid type of initializer: #{initializer.class}"

data/lib/chainer/initializers/normal.rb

@@ -19,8 +19,10 @@ module Chainer
       end
 
       def call(array)
-        fan_in, fan_out = Chainer::Utils::Initializer.get_fans(array.shape)
-        s = @scale * Numo::NMath.sqrt(2.0 / fan_in)
+        # TODO(sonots): pass device from outside
+        device = Chainer::Device.default
+        fan_in, fan_out = Chainer::Utils::Initializer.get_fans(array.shape, device: device)
+        s = @scale * device.xm::NMath.sqrt(2.0 / fan_in)
         Normal.new(scale: s).(array)
       end
     end

data/lib/chainer/initializers/uniform.rb

@@ -0,0 +1,15 @@
+module Chainer
+  module Initializers
+    class Uniform < ::Chainer::Initializer
+      def initialize(scale: 0.05, dtype: nil)
+        @scale = scale
+        super(dtype: dtype)
+      end
+
+      def call(array)
+        raise ArgumentError.new("dtypes are missmatched. #{dtype} != #{array.class}") if dtype && dtype != array.class
+        array.class.new(array.shape).rand(-@scale, @scale)
+      end
+    end
+  end
+end

data/lib/chainer/iterators/serial_iterator.rb

@@ -3,11 +3,13 @@ module Chainer
     class SerialIterator < Chainer::Dataset::Iterator 
       attr_reader :epoch, :is_new_epoch
 
-      def initialize(dataset, batch_size, repeat: true, shuffle: true)
+      def initialize(dataset, batch_size, repeat: true, shuffle: true, device: Chainer::Device.default)
         @dataset = dataset
         @batch_size = batch_size
         @repeat = repeat
         @shuffle = shuffle
+        @device = device
+        @xm = device.xm
 
         reset
       end
@@ -83,10 +85,10 @@ module Chainer
       def reset
         if @shuffle
           order = @dataset.size.times.map(&:to_i).shuffle
-          @order = Numo::Int64[*order]
+          @order = @xm::Int64[*order]
         else
           order = @dataset.size.times.map(&:to_i)
-          @order = Numo::Int64[*order]
+          @order = @xm::Int64[*order]
         end
 
         @current_position = 0

data/lib/chainer/link.rb

@@ -80,6 +80,8 @@ module Chainer
     end
 
     def serialize(serializer)
+      # TODO(sonots): pass device from outside
+      xm = Chainer::Device.default.xm
       d = self.instance_variables.each_with_object({}) { |sym, h| h[sym] = self.instance_variable_get(sym) }
       @params.each do |name|
         param = d[name]
@@ -87,10 +89,10 @@ module Chainer
         if param.data.nil? && !data.nil?
           # Initialize the parameter here
           param.init(data.shape)
-          if param.data.is_a?(Numo::NArray)
+          if Chainer.array?(param.data)
             param.data.store(data)
           else
-            param.data.set(Numo::NArray.cast(data))
+            param.data.set(xm::NArray.cast(data))
           end
         end
       end

data/lib/chainer/links/connection/convolution_2d.rb

@@ -14,8 +14,8 @@ module Chainer
         # @param [integer or 2-d int array] stride Stride of filter applications.
         # @param [integer or 2-d int array] pad Spatial padding width for input arrays.
         # @param [boolean] nobias If `true`, then this link does not use the bias term.
-        # @param [Numo::NArray] initialW Initial weight value. If `nil`, the default initializer is used.
-        # @param [Numo::NArray] initial_bias Initial bias value. If `nil`, the bias is set to 0.
+        # @param [Numo::NArray or Cumo::NArray] initial_w Initial weight value. If `nil`, the default initializer is used.
+        # @param [Numo::NArray or Cumo::NArray] initial_bias Initial bias value. If `nil`, the bias is set to 0.
         #
         # Example
         # There are several ways to make a Convolution2D link.

data/lib/chainer/links/model/classifier.rb

@@ -4,26 +4,45 @@ module Chainer
       class Classifier < Chain
         attr_accessor :compute_accuracy
 
-        def initialize(predictor, lossfun=Functions::Loss::SoftmaxCrossEntropy.method(:softmax_cross_entropy), accfun=Functions::Evaluation::Accuracy.method(:accuracy))
+        # @param [Chainer::Link] predictor Predictor network.
+        # @param [Function] lossfun Loss function.
+        # @param [Function] accfun Function that computes accuracy.
+        # @param [Integer, String] label_key Key to specify label variable from arguments.
+        #   When it is Integer, a variable in positional arguments is used.
+        #   And when it is String, a variable in keyword arguments is used.
+        def initialize(predictor, lossfun=Functions::Loss::SoftmaxCrossEntropy.method(:softmax_cross_entropy), accfun=Functions::Evaluation::Accuracy.method(:accuracy), label_key=-1)
           super()
+
+          unless label_key.is_a?(Integer) || label_key.is_a?(String)
+            raise TypeError, "label_key must be Integer or String, but is #{label_key.class}"
+          end
+
           @lossfun = lossfun
           @accfun = accfun
           @y = nil
           @loss = nil
           @accuracy = nil
           @compute_accuracy = true
+          @label_key = label_key
 
           init_scope do
             @predictor = predictor
           end
         end
 
-        def call(*args)
-          t = args.pop
-          x = args
+        def call(*args, **kwargs)
+          if @label_key.is_a?(Integer)
+            raise IndexError, "label_key #{@label_key} is out of bounds" if @label_key < -args.size || @label_key >= args.size
+            t = args.slice!(@label_key)
+          elsif @label_key.is_a?(String)
+            raise KeyError, "label_key #{@label_key} is not found" unless kwargs.has_key?(@label_key)
+            t = kwargs[@label_key]
+            kwargs.delete(@label_key)
+          end
+
           @y = nil
           @accuracy = nil
-          @y = @predictor.(*x)
+          @y = @predictor.(*args, **kwargs)
 
           @loss = @lossfun.call(@y, t)
           Chainer::Reporter.save_report({loss: @loss}, self)

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

@@ -20,11 +20,12 @@ module Chainer
         # @param [integer or int array] size Size (or shape) of channel dimensions.
         # @param [float] decay Decay rate of moving average. It is used on training.
         # @param [float] eps Epsilon value for numerical stability.
-        # @param [Numo::NArray.dtype] dtype Type to use in computing.
+        # @param [Numo::NArray.dtype or Cumo::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::SFloat, use_gamma: true, use_beta: true, initial_gamma: nil, initial_beta: nil)
+        def initialize(size, decay: 0.9, eps: 2e-5, dtype: nil, use_gamma: true, use_beta: true, initial_gamma: nil, initial_beta: nil)
           super()
+          dtype ||= Chainer::Device.default.xm::SFloat
           @avg_mean = dtype.zeros(size)
           register_persistent('avg_mean')
           @avg_var = dtype.zeros(size)
@@ -79,15 +80,11 @@ module Chainer
               decay = @decay
             end
 
-            func = Chainer::Functions::Normalization::BatchNormalizationFunction.new(eps: @eps, mean: @avg_mean, var: @avg_var, decay: decay)
-            ret = func.(x, gamma, beta)
-
-            @avg_mean[false] = func.running_mean
-            @avg_var[false] = func.running_var
+            ret = Chainer::Functions::Normalization::BatchNormalization.batch_normalization(x, gamma, beta, eps: @eps, running_mean: @avg_mean, running_var: @avg_var, decay: decay)
           else
-            mean = Chainer::Variable(@avg_mean)
-            var = Chainer::Variable(@avg_var)
-            ret = Chainer::Functions::Normalization::BatchNormalizationFunction.fixed_batch_normalization(x, gamma, beta, mean, var, eps: @eps)
+            mean = Chainer::Variable.new(@avg_mean)
+            var = Chainer::Variable.new(@avg_var)
+            ret = Chainer::Functions::Normalization::FixedBatchNormalization.fixed_batch_normalization(x, gamma, beta, mean, var, eps: @eps)
           end
 
           ret

data/lib/chainer/optimizer.rb

@@ -10,13 +10,32 @@ module Chainer
       @hooks = {}
     end
 
+    def add_hook(hook, name: nil)
+      if !hook.class.method_defined?(:call)
+        raise TypeError, 'hook function is not callable'
+      end
+
+      name = hook.name if name.nil?
+      if @hooks[name]
+        raise TypeError, "hook #{name} already exists"
+      end
+      @hooks[name] = hook
+    end
+
+    def call_hooks
+      @hooks.values.each do |hook|
+        _call_hook(hook)
+        reallocate_cleared_grads
+      end
+    end
+
     def _call_hook(hook)
       if hook.methods.include?(:call_for_each_param)
-        @target.params.each do |param|
+        @target.params do |param|
           hook.(param.update_rule, param)
         end
       else
-        hook(self)
+        hook.(self)
       end
     end
 
@@ -47,7 +66,9 @@ module Chainer
       return unless @enabled
 
       @t += 1
-      prepare(param)
+      unless param.data.nil?
+        prepare(param)
+      end
       @hooks.values.each do |hook|
         hook.call(param)
       end
@@ -55,14 +76,22 @@ module Chainer
     end
 
     def update_core(param)
-      # TODO: support GPU
-      update_core_cpu(param)
+      xm = Chainer.get_array_module(param)
+      if xm == Cumo
+        update_core_gpu(param)
+      else
+        update_core_cpu(param)
+      end
     end
 
     def update_core_cpu
       raise NotImplementedError
     end
 
+    def update_core_gpu
+      raise NotImplementedError
+    end
+
     def init_state(param)
       raise NotImplementedError
     end
@@ -74,14 +103,16 @@ module Chainer
     # method, and so you need to serialize the target link separately if you
     # want to fully recover the training state including parameters.
     #
-    # @param [Chainer::AbstractSerializer] serializer: Serializer object.
+    # @param [Chainer::AbstractSerializer] serializer Serializer object.
     def serialize(serializer)
       if @state.nil?
         if serializer.is_a?(Chainer::Deserializer)
           # try to initialize the state to retrieve state entries
           @state = {}
           self_copy = self.dup
-          arr = Numo::SFloat.new(1)
+          # TODO(sonots): pass device from outside
+          xm = Chainer::Device.default.xm
+          arr = xm::SFloat.new(1)
           self_copy.init_state(Chainer::Variable.new(arr, grad: arr))
           @state.keys.each do |key|
             @state[key] = serializer.(key.to_s, nil)
@@ -101,7 +132,7 @@ module Chainer
         @state = {}
         init_state(param)
       end
-      @state.select! { |_, v| v.kind_of?(Numo::NArray) }
+      @state.select! { |_, v| Chainer.array?(v) }
     end
   end
 
@@ -126,11 +157,11 @@ module Chainer
   #
   # @param [Float] rate Coefficient for the weight decay
   class WeightDecay
-    def self.name
+    def name
       "WeightDecay"
     end
 
-    def self.call_for_each_param
+    def call_for_each_param
       true
     end
 
@@ -140,7 +171,7 @@ module Chainer
 
     def call(rule, param)
       return if param.data.nil? || param.grad.nil?
-      param.grad += @rate * param.data
+      param.grad += (@rate * param.data)
     end
   end
 end

data/lib/chainer/optimizers/adam.rb

@@ -21,7 +21,7 @@ module Chainer
         @state[:v] = param.data.new_zeros
       end
 
-      def update_core_cpu(param)
+      def update_core(param)
         grad = param.grad
         return if grad.nil?
 
@@ -29,7 +29,8 @@ module Chainer
 
         @state[:m] += (1 - hp.beta1) * (grad - @state[:m])
         @state[:v] += (1 - hp.beta2) * (grad * grad - @state[:v])
-        param.data -= lr * @state[:m] / (Numo::NMath.sqrt(@state[:v]) + hp.eps)
+        xm = Chainer.get_array_module(grad)
+        param.data -= lr * @state[:m] / (xm::NMath.sqrt(@state[:v]) + hp.eps)
       end
 
       def lr

data/lib/chainer/optimizers/momentum_sgd.rb

@@ -17,7 +17,7 @@ module Chainer
         @state[:v] = param.data.new_zeros
       end
 
-      def update_core_cpu(param)
+      def update_core(param)
         grad = param.grad
         return if grad.nil?
           

data/lib/chainer/parameter.rb

@@ -10,20 +10,21 @@ module Chainer
       end
 
       if shape.nil?
-        if @initializer.kind_of?(Numo::NArray)
+        if Chainer.array?(initializer)
           super(initializer, name: name)
         else
           super(name: name)
           @initializer = initializer
           dtype = initializer.respond_to?(:dtype) ? initializer.dtype : 'SFloat'
-          @grad_initializer = Chainer::Initializers.nan()
+          @grad_initializer = Chainer::Initializers.nan(dtype: dtype)
         end
       else
-        if initializer.kind_of?(Numo::NArray)
+        if Chainer.array?(initializer)
           initializer = Initializers::Constant.new(initializer)
         end
         data = Chainer::Initializers.generate_array(initializer, shape)
-        grad = Numo::NArray[*[1, 2]].new_fill(-922337203)
+        xm = Chainer.get_array_module(data)
+        grad = xm::NArray[*[1, 2]].new_fill(-922337203)
         super(data, name: name, grad: grad)
       end
 
@@ -40,8 +41,8 @@ module Chainer
       ginit = @grad_initializer
       grad = ginit.nil? ? nil : Chainer::Initializers.generate_array(ginit, shape)
 
-      @data[0] = data
-      @node.grad = grad
+      self.data = data
+      self.grad = grad
     end
 
     def update

data/lib/chainer/serializer.rb

@@ -4,7 +4,7 @@ module Chainer
     # Gets a child serializer.
     # This operator creates a child serializer represented by the given key.
     # 
-    # @param [string] key: Name of the child serializer.
+    # @param [string] key Name of the child serializer.
     def [](key)
       raise NotImplementedError
     end
@@ -21,8 +21,8 @@ module Chainer
     # For arrays, the restored elements are directly copied into the
     # ``value`` argument. String values are treated like scalars.
     #
-    # @param [string] key: Name of the serialization entry.   
-    # @param [any] value: Object to be (de)serialized.
+    # @param [string] key Name of the serialization entry.
+    # @param [any] value Object to be (de)serialized.
     #                     ``None`` is only supported by deserializers.
     # @return Serialized or deserialized value.  
     def call(key, value)
@@ -35,7 +35,7 @@ module Chainer
     # Saves an object by this serializer.
     # This is equivalent to ``obj.serialize(self)``.
     #
-    # @param [any] obj: Target object to be serialized.  
+    # @param [any] obj Target object to be serialized.
     def save(obj)
       obj.serialize(self)
     end

data/lib/chainer/serializers/marshal.rb

@@ -1,6 +1,6 @@
 module Chainer
   module Serializers
-    class MarshalSerializer < Chainer::Serializer      
+    class MarshalSerializer < Chainer::Serializer
       attr_accessor :target, :path
 
       # @param [string] file_path Target file path
@@ -13,9 +13,11 @@ module Chainer
         end
       end
 
-      def initialize(target: nil, path: "")
+      def initialize(target: nil, path: "", device: Chainer::Device.default)
         @target = target.nil? ? {} : target
         @path = path
+        @device = device
+        @xm = device.xm
       end
 
       def [](key)
@@ -25,13 +27,13 @@ module Chainer
       def call(key, value)
         ret = value
         if value.is_a?(TrueClass)
-          arr = Numo::Bit[1]
+          arr = @xm::Bit[1]
         elsif value.is_a?(FalseClass)
-          arr = Numo::Bit[0]
+          arr = @xm::Bit[0]
         elsif value.instance_of?(String) || value.nil?
           arr = value
         else
-          arr = Numo::NArray.cast(value)
+          arr = @xm::NArray.cast(value)
         end
         @target[File.join(@path, key)] = arr
         ret
@@ -42,8 +44,8 @@ module Chainer
       # Loads an object from the file in Marshal format.
       # This is a short-cut function to load from an Marshal file that contains only one object.
       #
-      # @param [string ]filename: Name of the file to be loaded.
-      # @param [object] obj: Object to be deserialized. It must support serialization protocol.
+      # @param [string] filename Name of the file to be loaded.
+      # @param [object] obj Object to be deserialized. It must support serialization protocol.
       def self.load_file(filename, obj)
         File.open(filename) do |f|
           d = self.new(Marshal.load(f))
@@ -72,7 +74,7 @@ module Chainer
           return dataset
         elsif value.instance_of?(String)
           return dataset
-        elsif value.is_a?(Numo::NArray)
+        elsif Chainer.array?(value)
           value.store(dataset)
           return value
         elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)