red-chainer 0.1.0

data/lib/chainer/functions/math/basic_math.rb

@@ -0,0 +1,119 @@
+module Chainer
+  module Functions
+    module Math
+ 
+      class Neg < ::Chainer::Function
+        def forward(x)
+          retain_inputs([])
+          [Utils::Array.force_array(-x[0])]
+        end
+
+        def backward(x, gy)
+          [Utils::Array.force_array(-gy[0])]
+        end
+      end
+
+      class Add < ::Chainer::Function
+        def forward(x)
+          retain_inputs([])
+          [Utils::Array.force_array(x[0] + x[1])]
+        end
+
+        def backward(x, gy)
+          [gy[0], gy[0]]
+        end
+      end
+
+      class AddConstant < ::Chainer::Function
+        def initialize(value)
+          @value = value
+        end
+
+        def forward(x)
+          retain_inputs([])
+          [Utils::Array.force_array(x[0] + @value)]
+        end
+
+        def backward(x, gy)
+          [gy[0]]
+        end
+      end
+ 
+      class Sub < ::Chainer::Function
+        def forward(x)
+          retain_inputs([])
+          [Utils::Array.force_array(x[0] - x[1])]
+        end
+
+        def backward(x, gy)
+          [gy[0], Utils::Array.force_array(-gy[0])]
+        end
+      end
+
+      class Mul < ::Chainer::Function
+        def forward(x)
+          [Utils::Array.force_array(x[0] * x[1])]
+        end
+
+        def backward(x, gy)
+          [Utils::Array.force_array(gy[0] * x[1]), Utils::Array.force_array(gy[0] * x[0])]
+        end
+      end
+
+      class MulConstant < ::Chainer::Function
+        def initialize(value)
+          @value = value
+        end
+
+        def forward(x)
+          [Utils::Array.force_array(@value * x[0])]
+        end
+
+        def backward(x, gy)
+          [Utils::Array.force_array(@value * gy[0])]
+        end
+      end
+      
+      class Div < ::Chainer::Function
+        def forward(x)
+          [Utils::Array.force_array(x[0] / x[1])]
+        end
+
+        def backward(x, gy)
+          gx0 = Utils::Array.force_array(gy[0] / x[1])
+          [gx0, Utils::Array.force_array(-1 * gx0 * x[0] / x[1])]
+        end
+      end
+      
+      class PowVarVar < ::Chainer::Function
+        def forward(x)
+          @y = Utils::Array.force_array(x[0] ** x[1])
+          [@y]
+        end
+
+        def backward(x, gy)
+          one = x[1].class.ones[0]
+          gx0 = Utils::Array.force_array(x[1] * (x[0] ** (x[1] - one)) * gy[0])
+          gx1 = Utils::Array.force_array(Numo::NMath.log(x[0]) * @y * gy[0])
+          [gx0, gx1]
+        end
+      end
+
+      class PowVarConst < ::Chainer::Function
+        def initialize(value)
+          @value = value
+        end
+
+        def forward(x)
+          [Utils::Array.force_array(x[0] ** @value)]
+        end
+
+        def backward(x, gy)
+          val_1 = @value - 1
+          gx = @value * (x[0] ** val_1) * gy[0]
+          [Utils::Array.force_array(gx)]
+        end
+      end 
+    end
+  end
+end

data/lib/chainer/gradient_method.rb

@@ -0,0 +1,63 @@
+module Chainer
+  class GradientMethod < Chainer::Optimizer
+    def initialize
+      super()
+      @hyperparam = Hyperparameter.new
+    end
+    
+    def setup(link)
+      super(link)
+      link.params do |param|
+        param.update_rule = create_update_rule
+      end
+    end
+
+    def reallocate_cleared_grads
+      @target.namedparams(include_uninit: false) do |(name, param)|
+        if param.grad.nil?
+          param.grad = Numo::NArray.[](*param.data).new_zeros
+        end
+      end
+    end
+
+    def call_hooks
+      @hooks.each do |hook|
+        _call_hook(hook)
+        reallocate_cleared_grads
+      end
+    end
+
+    def update(lossfun=nil, *args, **kwds)
+      if lossfun
+        use_cleargrads = self.methods.include?(:use_cleargrads) ? self.use_cleargrads : true
+        if args.size > 0 && kwds.keys.size > 0
+          loss = lossfun.(*args, **kwds)
+        elsif args.size > 0
+          loss = lossfun.(*args)
+        elsif kwds.keys.size > 0
+          loss = lossfun.(**kwds)
+        end
+
+        if use_cleargrads
+          @target.cleargrads()
+        else
+          @target.zerograds()
+        end
+        loss.backward()
+      end
+
+      reallocate_cleared_grads
+
+      call_hooks
+
+      @t += 1
+      @target.params do |param|
+        param.update
+      end
+    end
+
+    def create_update_rule
+      raise NotImplementedError
+    end
+  end
+end

data/lib/chainer/hyperparameter.rb

@@ -0,0 +1,23 @@
+module Chainer
+  class Hyperparameter
+    attr_reader :parent
+
+    def initialize(parent: nil)
+      @parent = parent
+    end
+
+    def method_missing(name)
+      @parent.instance_variable_get("@#{name}")
+    end
+
+    def get_dict
+      d = @parent.nil? ? {} : @parent.get_dict
+      self.instance_variables.each do |m|
+        unless m == :@parent
+          d[m.to_s.delete('@')] = self.instance_variable_get(m)
+        end
+      end
+      d
+    end
+  end
+end

data/lib/chainer/initializer.rb

@@ -0,0 +1,12 @@
+module Chainer
+  class Initializer
+    def initialize(dtype: nil)
+      @dtype = dtype
+    end
+
+    def call(array)
+      raise NotImplementedError
+    end
+  end
+end
+

data/lib/chainer/initializers/constant.rb

@@ -0,0 +1,18 @@
+module Chainer
+  module Initializers
+    class Constant < ::Chainer::Initializer
+      def initialize(fill_value, dtype: nil)
+        @fill_value = fill_value
+        super(dtype: dtype)
+      end
+
+      def call(array)
+        if @dtype
+          raise ArgumentError unless array.dtype == @dtype
+        end
+        array.store(@fill_value)
+        array
+      end
+    end
+  end
+end

data/lib/chainer/initializers/init.rb

@@ -0,0 +1,24 @@
+module Chainer
+  module Initializers
+    def self.generate_array(initializer, shape)
+      array = Numo::DFloat.new(shape).rand
+      initializer.(array)
+    end
+
+    def self.get_initializer(initializer)
+      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)
+        raise TypeError, "invalid type of initializer: #{initializer.class}"
+      end
+
+      return initializer
+    end
+
+    def self.nan(dtype: nil)
+      Constant.new(Float::NAN, dtype: dtype)
+    end
+  end
+end

data/lib/chainer/initializers/normal.rb

@@ -0,0 +1,28 @@
+module Chainer
+  module Initializers
+    class Normal < ::Chainer::Initializer
+      def initialize(scale: 0.05, dtype: nil)
+        @scale = scale
+        super(dtype: dtype)
+      end
+
+      def call(array)
+        args = { loc: 0.0, scale: @scale, size: array.shape}
+        Numo::DFloat.new(array.shape).rand_norm(0.0, @scale)
+      end
+    end
+
+    class HeNormal < ::Chainer::Initializer
+      def initialize(scale: 1.0, dtype: nil)
+        @scale = scale
+        super(dtype: dtype)
+      end
+
+      def call(array)
+        fan_in, fan_out = Chainer::Utils::Initializer.get_fans(array.shape)
+        s = @scale * Numo::NMath.sqrt(2.0 / fan_in)
+        Normal.new(scale: s).(array)
+      end
+    end
+  end
+end

data/lib/chainer/iterators/serial_iterator.rb

@@ -0,0 +1,74 @@
+module Chainer
+  module Iterators
+    class SerialIterator < Chainer::Dataset::Iterator 
+      attr_reader :epoch
+
+      def initialize(dataset, batch_size, repeat: true, shuffle: true)
+        @dataset = dataset
+        @batch_size = batch_size
+        @repeat = repeat
+        @shuffle = shuffle
+
+        reset
+      end
+
+      def next
+        raise StopIteration if !@repeat && @epoch > 0
+
+        @previous_epoch_detail = @epoch_detail
+
+        i = @current_position
+        i_end = i + @batch_size
+        n = @dataset.size
+
+        batch = @order[i...i_end].to_a.map { |index| @dataset[index] }
+
+        if i_end >= n
+          if @repeat
+            rest = i_end - n
+            unless @order.nil?
+              @order = @order.class[*@order.to_a.shuffle]
+            end
+            if rest > 0
+              if @order.nil?
+                batch = batch.append(@dataset[0...rest])
+              else
+                batch = @dataset[0...rest].map { |index| @dataset[index] }
+              end
+            end
+            @current_position = rest
+          else
+            @current_position = 0
+          end
+
+          @epoch += 1
+          @is_new_epoch = true
+        else
+          @is_new_epoch = false
+          @current_position = i_end
+        end
+
+        batch
+      end
+
+      def epoch_detail
+        @epoch + @current_position.to_f / @dataset.size
+      end
+
+      def reset
+        if @shuffle
+          order = @dataset.size.times.map(&:to_i).shuffle
+          @order = Numo::Int64[*order]
+        else
+          order = @dataset.size.times.map(&:to_i)
+          @order = Numo::Int64[*order]
+        end
+
+        @current_position = 0
+        @epoch = 0
+        @is_new_epoch = false
+        @previous_epoch_detail = -1.0
+      end
+    end
+  end
+end

data/lib/chainer/link.rb

@@ -0,0 +1,118 @@
+module Chainer
+  class Link
+    def initialize
+      @params = []
+      @persistent = []
+      @within_init_scope = false
+      @name = nil
+    end
+
+    def within_init_scope
+      @within_init_scope || false
+    end
+
+    def init_scope
+      old_flag = self.within_init_scope
+      @within_init_scope = true
+
+      begin
+        yield
+        set_attr
+      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
+      end
+    end
+
+    def cleargrads
+      params do |param|
+        param.cleargrad
+      end
+    end
+
+    def params(include_uninit: true)
+      @params.map do |name|
+        data = self.instance_variable_get(name).data
+        if include_uninit || data
+          yield self.instance_variable_get(name)
+        end
+      end
+    end
+
+    def namedparams(include_uninit: true)
+      @params.each do |name|
+        if include_uninit || self.instance_variable_get(name).data
+          yield ['/' + name.to_s, self.instance_variable_get(name)]
+        end
+      end
+    end
+
+    def namedlinks(skipself: false)
+      yield('/', self) unless skipself
+    end
+  end
+
+  class Chain < Link
+    def initialize
+      super
+      @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
+        end
+      end
+      super
+    end
+
+    def params(include_uninit: true)
+      super(include_uninit: include_uninit) do |param|
+        yield param
+      end
+
+      @children.each do |name|
+        self.instance_variable_get(name).params(include_uninit: include_uninit) do |param|
+          yield param
+        end
+      end
+    end
+
+    def namedparams(include_uninit: true)
+      super(include_uninit: include_uninit) do |param|
+        yield param
+      end
+
+      @children.each do |name|
+        prefix = "/#{name}"
+        self.instance_variable_get(name).namedparams(include_uninit: include_uninit) do |(path, param)|
+          yield [prefix + path, param]
+        end
+      end
+    end
+
+    def namedlinks(skipself: false)
+      yield('/' , self) unless skipself
+      d = self.instance_variables.each_with_object({}) { |sym, h| h[sym] = self.instance_variable_get(sym) }
+      @children.each do |name|
+        child = d[name.to_sym]
+        prefix = '/' + name.to_s
+        yield(prefix, child)
+        d[name].namedlinks(skipself: true) do |path, link|
+          yield(prefix + path, link)
+        end
+      end
+    end
+  end
+end