red-chainer 0.1.0

data/lib/chainer/training/updater.rb

@@ -0,0 +1,33 @@
+module Chainer
+  module Training
+    class Updater
+      def connect_trainer(trainer)
+      end
+
+      def finalize
+      end
+
+      def get_optimizer(name)
+        raise NotImplementedError
+      end
+
+      def get_all_optimizers
+        raise NotImplementedError
+      end
+
+      def update
+        raise NotImplementedError
+      end
+
+      def serialize(serializer)
+        raise NotImplementedError
+      end
+
+      # this method uses in ERB
+      # example: ERB.new("<%= self %>").result(updater.bind)
+      def bind
+        binding
+      end
+    end
+  end
+end

data/lib/chainer/training/util.rb

@@ -0,0 +1,13 @@
+module Chainer
+  module Training
+    module Util
+      def self.get_trigger(trigger)
+        if trigger.nil?
+          false
+        else
+          Triggers::IntervalTrigger.new(*trigger)
+        end
+      end
+    end
+  end
+end

data/lib/chainer/utils/array.rb

@@ -0,0 +1,10 @@
+module Chainer
+  module Utils
+    module Array
+      def self.force_array(x, dtype=nil)
+        # TODO: conversion by dtype
+        Numo::NArray.[](*x)
+      end
+    end
+  end
+end

data/lib/chainer/utils/initializer.rb

@@ -0,0 +1,14 @@
+module Chainer
+  module Utils
+    module Initializer
+      def self.get_fans(shape)
+        raise 'shape must be of length >= 2: shape={}' if shape.size < 2
+        slice_arr = shape.slice(2, shape.size)
+        receptive_field_size = slice_arr.empty? ? 1 : Numo::Int32[slice_arr].prod
+        fan_in = shape[1] * receptive_field_size
+        fan_out = shape[0] * receptive_field_size
+        [fan_in, fan_out]
+      end
+    end
+  end
+end

data/lib/chainer/utils/variable.rb

@@ -0,0 +1,20 @@
+module Chainer
+  module Utils
+    module Variable
+      def self.check_grad_type(func, x, gx)
+        if x.data.nil? || gx.nil?
+          return
+        end
+
+        unless gx.instance_of?(x.data.class)
+          raise TypeError, "Type of data and grad mismatch\n#{x.class} != #{gx.class}"
+        end
+
+        unless gx.shape == x.data.shape
+          raise TypeError, "Shape of data and grad mismatch\n#{x.class} != #{gx.class}"
+        end
+      end
+    end
+  end
+end
+

data/lib/chainer/variable.rb

@@ -0,0 +1,204 @@
+module Chainer
+  class Variable
+    attr_accessor :data, :grad, :requires_grad, :node
+
+    def initialize(data=nil, name: nil, grad: nil, requires_grad: true)
+      unless data.nil? || data.is_a?(Numo::NArray)
+        raise TypeError, "Numo::NArray are expected."
+      end
+
+      @data = [data]
+      @grad = grad
+      @requires_grad = requires_grad
+      @node = VariableNode.new(variable: self, name: name, grad: grad)
+    end
+
+    def data
+      return @data[0]
+    end
+
+    def data=(d)
+      @data[0] = d
+      @node.set_data_type(d)
+    end
+
+    def name
+      return @node.name
+    end
+
+    def name=(n)
+      @node.name = n
+    end
+
+    def label
+      @node.label
+    end
+
+    def creator
+      @node.creator
+    end
+
+    def creator=(func)
+      @node.creator = func
+    end
+
+    def grad
+      @node.grad
+    end
+
+    def grad=(g)
+      @node.set_grad_with_check(g, nil, self)
+    end
+
+    def shape
+      self.data.shape
+    end
+
+    def ndim
+      self.data.ndim
+    end
+
+    def size
+      self.data.size
+    end
+
+    def dtype
+      self.data.class
+    end
+
+    def rank
+      @node.rank
+    end
+
+    def cleargrad
+      @node.grad = nil
+    end
+
+    def backward(retain_grad: false)
+      return if self.creator.nil?
+
+      if self.data.size == 1 && self.grad.nil?
+        self.grad = self.data.new_ones
+      end
+
+      funcs = [self.creator]
+
+      while func = funcs.pop
+        outputs = func.outputs.map(&:__getobj__)
+        in_data = func.inputs.map(&:data)
+        out_grad = outputs.map { |y| y.nil? ? nil : y.grad }
+
+        func.output_data = outputs.map { |y| y.nil? ? nil : y.data }
+        gxs = func.backward(in_data, out_grad)
+
+        raise unless gxs.size == in_data.size
+
+        unless func.retain_after_backward
+          func.output_data = nil
+        end
+
+        unless retain_grad
+          outputs.each do |y|
+            unless y.nil? || y == @node
+              y.grad = nil
+            end
+          end
+        end
+
+        seen_vars = []
+        need_copy = []
+
+        func.inputs.zip(gxs).each do |x, gx|
+          next if gx.nil?
+          next unless x.requires_grad
+
+          Utils::Variable.check_grad_type(func, x, gx)
+
+          id_x = x.object_id
+          if x.creator.nil? # leaf
+            if x.grad.nil?
+              x.grad = gx
+              need_copy << id_x
+            else
+              if need_copy.include?(id_x)
+                x.grad = Utils::Array.force_array(x.grad + gx)
+                need_copy.delete(id_x)
+              else
+                x.grad += gx
+              end
+            end
+          else # not leaf
+            funcs << x.creator
+            if seen_vars.include?(id_x)
+              if need_copy.include?(id_x)
+                x.grad = Utils::Array.force_array(gx + x.grad)
+                need_copy.delete(id_x)
+              else
+                x.grad += gx
+              end
+            else
+              x.grad = gx
+              seen_vars << id_x
+              need_copy << id_x
+            end
+          end
+        end
+      end 
+    end
+
+    def -@
+      Functions::Math::Neg.new.(self) 
+    end
+
+    def +(other)
+      if other.instance_of?(Chainer::Variable)
+        Functions::Math::Add.new.(*[self, other])
+      else
+        Functions::Math::AddConstant.new(other).(self)
+      end
+    end
+
+    def -(other) 
+      if other.instance_of?(Chainer::Variable)
+        Functions::Math::Sub.new.(*[self, other])
+      else
+        Functions::Math::AddConstant.new(-other).(self)
+      end
+    end
+
+    def *(other)
+      if other.instance_of?(Chainer::Variable)
+        Functions::Math::Mul.new.(*[self, other])
+      else
+        Functions::Math::MulConstant.new(other).(self)
+      end
+    end
+
+    def /(other)
+      if other.instance_of?(Chainer::Variable)
+        Functions::Math::Div.new.(*[self, other])
+      else
+        Functions::Math::MulConstant.new(1 / other).(self)
+      end
+    end
+
+    def **(other) 
+      if other.instance_of?(Chainer::Variable)
+        Functions::Math::PowVarVar.new.(*[self, other])
+      else
+        Functions::Math::PowVarConst.new(other).(self)
+      end
+    end
+
+    def retain_data
+      @node.data = @data[0]
+    end
+
+    # when left side is Numeric value and right side is Chainer::Value, call this method.
+    def coerce(other)
+      other = self.data.class[*other] if other.kind_of?(Numeric)
+      [Chainer::Variable.new(other, requires_grad: false), self]
+    end
+  end
+end
+

data/lib/chainer/variable_node.rb

@@ -0,0 +1,71 @@
+module Chainer
+  class VariableNode
+    attr_reader :dtype, :shape
+    attr_accessor :data, :name, :grad, :rank, :creator, :requires_grad, :variable
+
+    def initialize(variable: , name:, grad: nil)
+      @variable = WeakRef.new(variable)
+      @creator = nil
+      @data = nil
+      @rank = 0
+      @name = name
+      @requires_grad = variable.requires_grad
+
+      set_data_type(variable.data)
+
+      @grad = grad
+    end
+
+    def creator=(func)
+      @creator = func
+      unless func.nil?
+        @rank = func.rank + 1
+      end
+    end
+
+    def data=(data)
+      @data = data
+      set_data_type(data)
+    end
+
+    def grad=(g)
+      Utils::Variable.check_grad_type(nil, self, g)
+      @grad = g
+    end
+
+    def label
+      if @shape.nil? || @shape.empty?
+        @dtype.to_s
+      else
+        "(#{@shape.join(', ')}), #{@dtype.to_s}"
+      end
+    end
+
+    def unchain
+      @creator = nil
+    end
+
+    def retain_data
+      if @variable.nil?
+        raise "cannot retain variable data: the variable has been already released"
+      else
+        @variable.data
+      end
+    end
+
+    def set_data_type(data)
+      if data.nil?
+        @dtype = nil
+        @shape = nil
+      else
+        @dtype = data.class
+        @shape = data.shape
+      end
+    end
+
+    def set_grad_with_check(g, func, var)
+      Utils::Variable.check_grad_type(func, var, g)
+      @grad = g
+    end
+  end
+end

data/lib/chainer/version.rb

@@ -0,0 +1,4 @@
+module Chainer
+  VERSION = "0.1.0"
+end
+

data/red-chainer.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "chainer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "red-chainer"
+  spec.version       = Chainer::VERSION
+  spec.authors       = ["Yusaku Hatanaka"]
+  spec.email         = ["hatappi@hatappi.me"]
+
+  spec.summary, spec.description = "A flexible framework for neural network for Ruby"
+  spec.homepage      = "https://github.com/red-data-tools/red-chainer"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "numo-narray", ">= 0.9.0.8"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "test-unit"
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: red-chainer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yusaku Hatanaka
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0.8
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- hatappi@hatappi.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/mnist.rb
+- lib/chainer.rb
+- lib/chainer/configuration.rb
+- lib/chainer/dataset/convert.rb
+- lib/chainer/dataset/download.rb
+- lib/chainer/dataset/iterator.rb
+- lib/chainer/datasets/mnist.rb
+- lib/chainer/datasets/tuple_dataset.rb
+- lib/chainer/function.rb
+- lib/chainer/functions/activation/log_softmax.rb
+- lib/chainer/functions/activation/relu.rb
+- lib/chainer/functions/connection/linear.rb
+- lib/chainer/functions/evaluation/accuracy.rb
+- lib/chainer/functions/loss/softmax_cross_entropy.rb
+- lib/chainer/functions/math/basic_math.rb
+- lib/chainer/gradient_method.rb
+- lib/chainer/hyperparameter.rb
+- lib/chainer/initializer.rb
+- lib/chainer/initializers/constant.rb
+- lib/chainer/initializers/init.rb
+- lib/chainer/initializers/normal.rb
+- lib/chainer/iterators/serial_iterator.rb
+- lib/chainer/link.rb
+- lib/chainer/links/connection/linear.rb
+- lib/chainer/links/model/classifier.rb
+- lib/chainer/optimizer.rb
+- lib/chainer/optimizers/adam.rb
+- lib/chainer/parameter.rb
+- lib/chainer/reporter.rb
+- lib/chainer/training/extension.rb
+- lib/chainer/training/extensions/evaluator.rb
+- lib/chainer/training/extensions/log_report.rb
+- lib/chainer/training/extensions/print_report.rb
+- lib/chainer/training/extensions/progress_bar.rb
+- lib/chainer/training/standard_updater.rb
+- lib/chainer/training/trainer.rb
+- lib/chainer/training/triggers/interval.rb
+- lib/chainer/training/updater.rb
+- lib/chainer/training/util.rb
+- lib/chainer/utils/array.rb
+- lib/chainer/utils/initializer.rb
+- lib/chainer/utils/variable.rb
+- lib/chainer/variable.rb
+- lib/chainer/variable_node.rb
+- lib/chainer/version.rb
+- red-chainer.gemspec
+homepage: https://github.com/red-data-tools/red-chainer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: A flexible framework for neural network for Ruby
+test_files: []