red-chainer 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f236d4d7bf68a410d804ef19c6dc10173eb167d4
-  data.tar.gz: 71f41bc080aa3a1f11018a0c15c6ee3c27e02f05
+SHA256:
+  metadata.gz: 01f7ae8c937f4fb6384d9d6a0bf975d236da004d9165a734f9f5ab78c48d1197
+  data.tar.gz: 218ae1d0ebe3f90db0861d98d88a0be2a52e160f8001952d223df64ee8d22838
 SHA512:
-  metadata.gz: ed00166f602c037f22215a88e58ac4eaf40b155f0463b5c72737a343468b5246530e962f73d34ec85563196ed275077fffd3acc37da3e6afbd25e56007331199
-  data.tar.gz: 1567a64df5951c04e0140082afa3530417424f468fa983ae07bf83c7beac9fdc13a6332b23fb6633c37d2d487d7aa6fe15a3a5647ed652b79cedea51fc89a782
+  metadata.gz: aba81905dd93397b368b64fdd517b3b99487cc47dfb2ca7477cadf5e8357038be3f920f950a4968394040bd34e04e6537f24965a52e93f7d4855f174ff305d60
+  data.tar.gz: 96752ee9d7b151eb63e36ddda56d82910a6eee07109376de47cd977a77d1bb2bf0ecf78353835a049b795b35441197ede4cfb1dbff78ad4bd4a220da1c6f5009

data/.gitignore

@@ -7,6 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+result
 
 # rspec failure tracking
 .rspec_status

data/.travis.yml

@@ -1,5 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4.1
+  - 2.3.5
+  - 2.4.2
 before_install: gem install bundler -v 1.15.1
+script: ruby test/run_test.rb

data/README.md

@@ -5,39 +5,35 @@
 Red Cahiner
 
 ## 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.
 
-TODO: Delete this and the text above, and describe your gem
-
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```ruby
-gem 'red-chainer', github: 'red-data-tools/red-chainer' 
+```bash
+gem 'red-chainer'
 ```
 
 And then execute:
 
-```ruby
+```bash
 $ bundle
 ```
 
 Or install it yourself as:
 
-```ruby
-gem install specific_install
-gem specific_install -l 'https://github.com/red-data-tools/red-chainer'
+```bash
+$ gem install red-chainer
 ```
 
 ## Usage
 mnist sample program is [here](./examples/mnist.rb)
 
-```ruby
-# install Gemfile
+```bash
+# when install Gemfile
 $ bundle exec ruby examples/mnist.rb
-# install yourself
+# when install yourself
 $ ruby examples/mnist.rb
 ```
 

data/examples/mnist.rb

@@ -1,5 +1,6 @@
 require 'chainer'
 require 'fileutils'
+require 'optparse'
 require 'tmpdir'
 
 class MLP < Chainer::Chain
@@ -22,21 +23,48 @@ class MLP < Chainer::Chain
   end
 end
 
-model = Chainer::Links::Model::Classifier.new(MLP.new(1000, 10))
+args = {
+  batchsize: 100,
+  frequency: -1,
+  epoch: 20,
+  resume: nil,
+  unit: 1000,
+  out: 'result'
+}
+
+opt = OptionParser.new
+opt.on('-b', '--batchsize VALUE', "Number of images in each mini-batch (default: #{args[:batchsize]})") { |v| args[:batchsize] = v.to_i }
+opt.on('-e', '--epoch VALUE', "Number of sweeps over the dataset to train (default: #{args[:epoch]})") { |v| args[:epoch] = v.to_i }
+opt.on('-f', '--frequency VALUE', "Frequency of taking a snapshot (default: #{args[:frequency]})") { |v| args[:frequency] = 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('-u', '--unit VALUE', "Number of units (default: #{args[:unit]})") { |v| args[:unit] = v.to_i }
+opt.parse!(ARGV)
+
+model = Chainer::Links::Model::Classifier.new(MLP.new(args[:unit], 10))
 
 optimizer = Chainer::Optimizers::Adam.new
 optimizer.setup(model)
 train, test = Chainer::Datasets::Mnist.get_mnist
 
-train_iter = Chainer::Iterators::SerialIterator.new(train, 100)
-test_iter = Chainer::Iterators::SerialIterator.new(test, 100, repeat: false, shuffle: false)
+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: [20, 'epoch'], out: 'result')
+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))
+
+# Take a snapshot for each specified epoch
+frequency = args[:frequency] == -1 ? args[:epoch] : [1, args[:frequency]].max
+trainer.extend(Chainer::Training::Extensions::Snapshot.new, trigger: [frequency, 'epoch'], priority: -100)
+
 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/lib/chainer/functions/activation/leaky_relu.rb

@@ -0,0 +1,64 @@
+module Chainer
+  module Functions
+    module Activation
+      # Leaky rectifier unit.
+      class LeakyReLU < Function
+        # Leaky Rectified Linear Unit function.
+        #
+        # This function is expressed as
+        #
+        # $$
+        # f(x)=\\max(x, ax),
+        # $$
+        # 
+        # where $a$ is a configurable slope value.
+        # 
+        # @param [Chainer::Variable or Numo::DFloat] x Input variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @param [float] slope Slope value $a$.
+        # @return [Chainer::Variable] Output variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @example
+        #   > x = Numo::DFloat[[-1, 0], [2, -3], [-2, 1]]
+        #   > x
+        #   => Numo::DFloat#shape=[3,2]
+        #   [[-1, 0], 
+        #    [2, -3], 
+        #    [-2, 1]]
+        #   > F = Chainer::Functions::Activation::LeakyReLU
+        #   > F.leaky_relu(x, slope:0.2).data
+        #   => Numo::DFloat#shape=[3,2]
+        #   [[-0.2, 0], 
+        #    [2, -0.6], 
+        #    [-0.4, 1]]
+        #
+        def self.leaky_relu(x, slope: 0.2)
+          self.new(slope: slope).(x)
+        end
+
+        def initialize(slope:0.2)
+          @slope = slope
+        end
+
+        def forward_cpu(x)
+          y = x[0].dup()
+          y[x[0] < 0] *= @slope
+          if @slope >= 0
+            retain_inputs([])
+            retain_outputs([0])
+          end
+          [y]
+        end
+
+        def backward_cpu(x, gy)
+          gx = gy[0].dup()
+          if @slope >= 0
+            y = @output_data
+            gx[y[0] < 0] *= @slope
+          else
+            gx[x[0] < 0] *= @slope
+          end
+          [gx]
+        end
+      end
+    end
+  end
+end

data/lib/chainer/functions/activation/log_softmax.rb

@@ -10,26 +10,68 @@ module Chainer
         m + s
       end
 
-      def self.log_softmax(x)
+      def self._log_softmax(x)
         log_z = logsumexp(x)
         x - log_z
       end
 
+      # Log-softmax activation function.
       class LogSoftmax < Function
-        def self.relu(x)
+        # Channel-wise log-softmax function.
+        #
+        # This function computes its logarithm of softmax along the second axis.
+        # Let $c = (c_1, c_2, \\dots, c_D)$ be the slice of +x+ along with
+        # the second axis. For each slice $c$, it computes the logarithm of
+        # the function $f(\c)$ defined as
+        #
+        # $$
+        # f(\c) = { \\exp(\c) \\over \\sum_{ d } \\exp(c_d) }.
+        # $$
+        #
+        # This method is theoretically equivalent to +log(softmax(x))+ but is more
+        # stable.
+        #
+        # @note
+        #   +log(softmax(x))+ may cause underflow when +x+ is too small,
+        #   because +softmax(x)+ may returns +0+.
+        #   +log_softmax+ method is more stable.
+        #
+        # @param [Chainer::Variable or Numo::DFloat] x Input variable. A $n$-dimensional ($n \\geq 2$) float array.
+        # @return [Chainer::Variable] Output variable. A $n$-dimensional ($n \\geq 2$) float array, which is the same shape with x.
+        #
+        # @see Chainer::Functions::Softmax
+        #
+        # @example
+        #   > x = Numo::DFloat[[0, 1, 2], [0, 2, 4]]
+        #   => Numo::DFloat#shape=[2,3]
+        #   [[0, 1, 2],
+        #    [0, 2, 4]]
+        #   > F = Chainer::Functions::Activation::LogSoftmax
+        #   > F.log_softmax(x).data
+        #   => Numo::DFloat#shape=[2,3]
+        #   [[-2.40761, -1.40761, -0.407606],
+        #    [-4.14293, -2.14293, -0.142932]]
+        # @example (T.B.I : F.log, F.softmax)
+        #   > F.log_softmax(x).data.nearly_eq(F.log(F.softmax(x)).data).all?)
+        #   => true
+        #
+        def self.log_softmax(x)
           self.new.(x)
         end
 
-        def forward_cpu(x)
+        def forward(xs)
+          y = Chainer::Functions::Activation._log_softmax(xs[0])
+          @x_shape = xs[0].shape
+          @x_dtype = xs[0].class
           retain_inputs([])
           retain_outputs([0])
-          x[0][x[0]<=0] = 0
-          [Utils::Array.force_array(x[0])] 
+          [y]
         end
 
-        def backward_cpu(x, gy)
-          y = output_data[0]
-          [Utils::Array.force_array(gy[0] * (y > 0))]
+        def backward(x, gy)
+          y = @output_data[0]
+          gx = gy[0] - Numo::NMath.exp(y) * gy[0].sum(axis: 1, keepdims: true)
+          [gx]
         end
       end
     end

data/lib/chainer/functions/activation/relu.rb

@@ -1,7 +1,27 @@
 module Chainer
   module Functions
     module Activation
+      # Rectified Linear Unit.
       class Relu < Function
+        # Rectified Linear Unit function.
+        #
+        # $$
+        # f(x)=\\max(0, x).
+        # $$
+        #
+        # @param [Chainer::Variable or Numo::DFloat] x Input variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @return [Chainer::Variable] Output variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @example
+        #   > x = Numo::DFloat[[-1, 0], [2, -3], [-2, 1]]
+        #   > (x < 0).any?
+        #   => true
+        #   > F = Chainer::Functions::Activation::Relu
+        #   > y = F.relu(x)
+        #   > (y.data < 0).any?
+        #   => false
+        #   > y.shape
+        #   => [3, 2]
+        #
         def self.relu(x)
           self.new.(x)
         end
@@ -14,7 +34,7 @@ module Chainer
         end
 
         def backward_cpu(x, gy)
-          y = output_data[0]
+          y = @output_data[0]
           [Utils::Array.force_array(gy[0] * (y > 0))]
         end
       end

data/lib/chainer/functions/activation/sigmoid.rb

@@ -0,0 +1,43 @@
+module Chainer
+  module Functions
+    module Activation
+      # Logistic sigmoid function.
+      class Sigmoid < Function
+        # Element-wise sigmoid logistic function.
+        #
+        # $$
+        # f(x)=(1 + \\exp(-x))^ { -1 }.
+        # $$
+        #
+        # @param [Chainer::Variable or Numo::DFloat] x Input variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @return [Chainer::Variable] Output variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @example  It maps the input values into the range of $`[0, 1]`$.
+        #   > x = Numo::DFloat.new(3).seq(-2, 2)
+        #   => Numo::DFloat#shape=[3]
+        #   [-2, 0, 2]
+        #   > F = Chainer::Functions::Activation::Sigmoid
+        #   > F.sigmoid(x).data
+        #   => Numo::DFloat#shape=[3]
+        #   [0.119203, 0.5, 0.880797]
+        #
+        def self.sigmoid(x)
+          self.new.(x)
+        end
+
+        def forward_cpu(x)
+          half = 0.5
+          y = Utils::Array.force_array((Numo::NMath.tanh(x[0] * half) * half)+ half)
+          retain_inputs([])
+          retain_outputs([0])
+          return [y]
+        end
+
+        def backward_cpu(x, gy)
+          one = 1
+          y = @output_data[0]
+          [Utils::Array.force_array((gy[0] * y) * (one - y))]
+        end
+      end
+    end
+  end
+end

data/lib/chainer/functions/activation/tanh.rb

@@ -0,0 +1,42 @@
+module Chainer
+  module Functions
+    module Activation
+      # Hyperbolic tangent function.
+      class Tanh < Function
+        # Elementwise hyperbolic tangent function.
+        #
+        # $$
+        # f(x)=\\tanh(x).
+        # $$
+        #
+        # @param [Chainer::Variable or Numo::DFloat] x Input variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @return [Chainer::Variable] Output variable. A $(s_1, s_2, ..., s_N)$-shaped float array.
+        # @example
+        #   > x = Numo::DFloat.new(3).seq(-1, 2)
+        #   => Numo::DFloat#shape=[3]
+        #   [-1, 1, 3]
+        #   > F = Chainer::Functions::Activation::Tanh
+        #   > F.tanh(x).data
+        #   => Numo::DFloat#shape=[3]
+        #   [-0.761594, 0.761594, 0.995055]
+        #
+        def self.tanh(x)
+          self.new.(x)
+        end
+
+        def forward_cpu(x)
+          y = Utils::Array.force_array(Numo::NMath.tanh(x[0]))
+          retain_inputs([])
+          retain_outputs([0])
+          return [y]
+        end
+
+        def backward_cpu(x, gy)
+          y = @output_data[0]
+          one = y.dtype.type(1)
+          [Utils::Array.force_array(gy[0] * (one - y * y))]
+        end
+      end
+    end
+  end
+end

data/lib/chainer/functions/loss/softmax_cross_entropy.rb

@@ -31,7 +31,7 @@ module Chainer
 
         def forward_cpu(inputs)
           x, t = inputs
-          log_y = Activation.log_softmax(x)
+          log_y = Activation._log_softmax(x)
 
           if @cache_score
             @y = Numo::NMath.exp(log_y)
@@ -81,7 +81,7 @@ module Chainer
           if self.instance_variable_defined?(:'@y')
             y = @y.dup
           else
-            y = Activation.log_softmax(x)
+            y = Activation._log_softmax(x)
             y = Numo::NMath.exp(y)
           end
 

data/lib/chainer/iterators/serial_iterator.rb

@@ -15,7 +15,7 @@ module Chainer
       def next
         raise StopIteration if !@repeat && @epoch > 0
 
-        @previous_epoch_detail = @epoch_detail
+        @previous_epoch_detail = epoch_detail
 
         i = @current_position
         i_end = i + @batch_size
@@ -55,6 +55,31 @@ module Chainer
         @epoch + @current_position.to_f / @dataset.size
       end
 
+      def serialize(serializer)
+        @current_position = serializer.('current_position', @current_position)
+        @epoch = serializer.('epoch', @epoch)
+        @is_new_epoch = serializer.('is_new_epoch', @is_new_epoch)
+        unless @order.nil?
+          begin
+            serializer.('order', @order)
+          rescue KeyError
+            serializer('_order', @order)
+          end
+        end
+
+        begin
+          @previous_epoch_detail = serializer.( 'previous_epoch_detail', @previous_epoch_detail)
+        rescue KeyError
+          # guess previous_epoch_detail for older version
+          @previous_epoch_detail = @epoch + (@current_position - @batch_size) / @dataset.size
+          if epoch_detail > 0
+            @previous_epoch_detail = [@previous_epoch_detail, 0.0].max
+          else
+            @previous_epoch_detail = -1.0
+          end
+        end
+      end
+
       def reset
         if @shuffle
           order = @dataset.size.times.map(&:to_i).shuffle

data/lib/chainer/link.rb

@@ -59,6 +59,27 @@ module Chainer
     def namedlinks(skipself: false)
       yield('/', self) unless skipself
     end
+
+    def serialize(serializer)
+      d = self.instance_variables.each_with_object({}) { |sym, h| h[sym] = self.instance_variable_get(sym) }
+      @params.each do |name|
+        param = d[name]
+        data = serializer.(name.to_s, param.data)
+        if param.data.nil? && !data.nil?
+          # Initialize the parameter here
+          param.init(data.shape)
+          if param.data.is_a?(Numo::NArray)
+            param.data.store(data)
+          else
+            param.data.set(Numo::NArray.cast(data))
+          end
+        end
+      end
+
+      @persistent.each do |name|
+        d[name] = serializer.(name.to_s, d[name])
+      end
+    end
   end
 
   class Chain < Link
@@ -114,5 +135,13 @@ module Chainer
         end
       end
     end
+
+    def serialize(serializer)
+      super(serializer)
+      d = self.instance_variables.each_with_object({}) { |sym, h| h[sym] = self.instance_variable_get(sym) }
+      @children.each do |name|
+        d[name].serialize(serializer[name.to_s])
+      end
+    end
   end
 end

data/lib/chainer/optimizer.rb

@@ -19,6 +19,17 @@ module Chainer
         hook(self)
       end
     end
+
+    def serialize(serializer)
+      @t = serializer.('t', @t)
+      @epoch = serializer.('epoch', @epoch)
+      
+      @target.namedparams() do |(name, param)|
+        if param.respond_to?(:update_rule)
+          param.update_rule.serialize(serializer[name.to_s])
+        end
+      end
+    end
   end
 
   class UpdateRule
@@ -56,6 +67,33 @@ module Chainer
       raise NotImplementedError
     end
 
+
+    # Serializes the update rule state.
+    # Be careful that this method only saves/loads the state of the update rule.
+    # The parameters of the target link is not saved/loaded by this
+    # 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.
+    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::DFloat.new(1)
+          self_copy.init_state(Chainer::Variable.new(arr, grad: arr))
+          @state.keys.each do |key|
+            @state[key] = serializer.(key.to_s, nil)
+          end
+        end
+      else
+        @state.each do |key, val|
+          @state[key] = serializer.(key.to_s, val)
+        end
+      end                                                                                 
+    end
+
     private
 
     def prepare(param)

data/lib/chainer/serializer.rb

@@ -0,0 +1,50 @@
+module Chainer
+  # Abstract base class of all serializers and deserializers.
+  class AbstractSerializer
+    # Gets a child serializer.
+    # This operator creates a child serializer represented by the given key.
+    # 
+    # @param [string] key: Name of the child serializer.
+    def [](key)
+      raise NotImplementedError
+    end
+
+    # Serializes or deserializes a value by given name.
+    # This operator saves or loads a value by given name.
+    # If this is a serializer, then the value is simply saved at the key.
+    # Note that some type information might be missed depending on the
+    # implementation (and the target file format).
+    # If this is a deserializer, then the value is loaded by the key.
+    # The deserialization differently works on scalars and arrays.
+    # For scalars, the ``value`` argument is used just for determining the type of
+    # restored value to be converted, and the converted value is returned.
+    # 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.
+    #                     ``None`` is only supported by deserializers.
+    # @return Serialized or deserialized value.  
+    def call(key, value)
+      raise NotImplementedError  
+    end
+  end
+
+  # Base class of all serializers.
+  class Serializer < AbstractSerializer
+    # Saves an object by this serializer.
+    # This is equivalent to ``obj.serialize(self)``.
+    #
+    # @param [any] obj: Target object to be serialized.  
+    def save(obj)
+      obj.serialize(self)
+    end
+  end
+
+  # Base class of all deserializers.
+  class Deserializer < AbstractSerializer
+    def load(obj)
+      obj.serialize(self)
+    end
+  end
+end

data/lib/chainer/serializers/marshal.rb

@@ -0,0 +1,83 @@
+module Chainer
+  module Serializers
+    class MarshalSerializer < Chainer::Serializer      
+      attr_accessor :target, :path
+
+      def self.save_file(filename, obj)
+        s = self.new
+        s.save(obj)
+        Marshal.dump(s.target, filename)
+      end
+
+      def initialize(target: nil, path: "")
+        @target = target.nil? ? {} : target
+        @path = path
+      end
+
+      def [](key)
+        self.class.new(target: @target, path: File.join(@path, key, '/'))
+      end
+
+      def call(key, value)
+        ret = value
+        if value.is_a?(TrueClass)
+          arr = Numo::Bit[1]
+        elsif value.is_a?(FalseClass)
+          arr = Numo::Bit[0]
+        elsif value.instance_of?(String)
+          arr = value
+        else
+          arr = Numo::NArray.cast(value)
+        end
+        @target[File.join(@path, key)] = arr
+        ret
+      end
+    end
+
+    class MarshalDeserializer < Chainer::Deserializer
+      # 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.
+      def self.load_file(filename, obj)
+        File.open(filename) do |f|
+          d = self.new(Marshal.load(f))
+          d.load(obj)
+        end
+      end
+
+      def initialize(marshalData, path: '', strict: true)
+        @marshal_data = marshalData
+        @path = path
+        @strict = strict
+      end
+
+      def [](key)
+        self.class.new(@marshal_data, path: File.join(@path, key, '/'), strict: @strict)
+      end
+
+      def call(key, value)
+        key = File.join(@path, key)
+        if !@strict && !@marshal_data.keys.include?(key)
+          return value
+        end
+
+        dataset = @marshal_data[key]
+        if value.nil?
+          return dataset
+        elsif value.instance_of?(String)
+          return dataset
+        elsif value.is_a?(Numo::NArray)
+          value.store(dataset)
+          return value
+        elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          return dataset[0] == 1
+        else
+          return dataset[0]
+        end
+      end
+    end
+  end
+end
+

data/lib/chainer/training/extensions/log_report.rb

@@ -61,6 +61,21 @@ module Chainer
           init_summary
         end
 
+        def serialize(serializer)
+          if @trigger.respond_to?(:serialize)
+            @trigger.serialize(serializer['_trigger'])
+          end
+          # Note that this serialization may lose some information of small
+          # numerical differences.
+          if serializer.is_a?(Chainer::Serializer)
+            log = JSON.generate(@log)
+            serializer.('_log', log)
+          else
+            log = serializer.('_log', '')
+            @log = JSON.parse(log)
+          end
+        end
+
         private
 
         def init_summary

data/lib/chainer/training/extensions/print_report.rb

@@ -44,6 +44,12 @@ module Chainer
           end
         end
 
+        def serialize(serializer)
+          if @log_report.is_a?(Chainer::Training::Extensions::LogReport)
+            @log_report.serialize(serializer['_log_report'])
+          end
+        end
+
         private
 
         def print(observation)

data/lib/chainer/training/extensions/snapshot.rb

@@ -0,0 +1,33 @@
+module Chainer
+  module Training
+    module Extensions
+      class Snapshot < Extension
+        attr_accessor :save_class, :filename_proc, :target
+
+        def self.snapshot_object(target:, save_class:, &block)
+          self.new(save_class: save_class, filename_proc: block, target: target)
+        end
+
+        def self.snapshot(save_class: nil, &block)
+          self.new(save_class: save_class, filename_proc: block)
+        end
+
+        def initialize(save_class: nil, filename_proc: nil, target: nil)
+          @save_class = save_class || Chainer::Serializers::MarshalSerializer
+          @filename_proc = filename_proc || Proc.new { |trainer| "snapshot_iter_#{trainer.updater.iteration}" }
+          @target = target
+        end
+
+        def call(trainer)
+          target = @target || trainer
+          filename = filename_proc.call(trainer)
+          prefix = "tmp#{filename}"
+          temp_file = Tempfile.create(basename: prefix, tmpdir: trainer.out)
+          save_class.save_file(temp_file, trainer)
+          FileUtils.move(temp_file.path, File.join(trainer.out, filename))
+        end
+      end
+    end
+  end
+end
+

data/lib/chainer/training/standard_updater.rb

@@ -58,6 +58,18 @@ module Chainer
           iterator.finalize
         end
       end
+
+      def serialize(serializer)
+        @iterators.each do |name, iterator|
+          iterator.serialize(serializer["iterator:#{name}"])
+        end
+        @optimizers.each do |name, optimizer|
+          optimizer.serialize(serializer["optimizer:#{name}"])
+          optimizer.target.serialize(serializer["model:#{name}"])
+        end
+
+        @iteration = serializer.('iteration', @iteration)
+      end
     end
   end
 end

data/lib/chainer/training/trainer.rb

@@ -44,7 +44,7 @@ module Chainer
         return @final_elapsed_time if @done
         raise "training has not been started yet" if @start_at.nil?
 
-        Time.now.to_f - @start_at - @snapshot_elapsed_time.to_f
+        Time.now.to_f - @start_at + @snapshot_elapsed_time.to_f
       end
 
       def extend(extension, name: nil, trigger: nil, priority: nil, invoke_before_training: nil)
@@ -97,7 +97,7 @@ module Chainer
         raise 'cannot run training loop multiple times' if @done
         FileUtils.mkdir_p(@out)
 
-        extensions = @extensions.sort_by { |(_, e)| e.priority }.map { |(name, extension)| [name, extension] }
+        extensions = @extensions.sort_by { |(_, e)| -e.priority }.map { |(name, extension)| [name, extension] }
 
         @start_at = Time.now.to_f
 
@@ -115,7 +115,7 @@ module Chainer
             @observation = {}
             reporter.scope(@observation) do
               update.call
-              extensions.each do |(_, entry)|
+              extensions.each do |(name, entry)|
                 entry.extension.(self) if entry.trigger.(self)
               end
             end
@@ -131,6 +131,29 @@ module Chainer
         @final_elapsed_time = @elapsed_time
         @done = true
       end
+
+      def serialize(serializer)
+        updater.serialize(serializer['updater'])
+        if @stop_trigger.respond_to?(:serialize)
+          @stop_trigger.serialize(serializer['stop_trigger'])
+        end
+
+        s = serializer['extensions']
+        t = serializer['extension_triggers']
+        @extensions.each do |name, entry|
+          if entry.extension.respond_to?(:serialize)
+            entry.extension.serialize(s[name])
+          end
+          if entry.trigger.respond_to?(:serialize)
+            entry.trigger.serialize(t[name])
+          end
+        end
+        if serializer.is_a?(Chainer::Serializer)
+          serializer.('_snapshot_elapsed_time', elapsed_time)
+        else
+          @snapshot_elapsed_time = serializer.('_snapshot_elapsed_time', 0.0)
+        end
+      end
     end
   end
 end

data/lib/chainer/training/triggers/interval.rb

@@ -8,18 +8,43 @@ module Chainer
           @period = period
           @unit = unit
           @count = 0
+
+          @previous_iteration = 0
+          @previous_epoch_detail = 0.0
         end
 
         def call(trainer)
           updater = trainer.updater
           if @unit == 'epoch'
-            prev = @count
-            @count = updater.epoch_detail.div(@period)
-            prev != @count
+            epoch_detail = updater.epoch_detail
+            previous_epoch_detail = @previous_epoch_detail
+
+            if previous_epoch_detail < 0
+              previous_epoch_detail = updater.previous_epoch_detail
+            end
+
+            @count = epoch_detail.div(@period).floor
+
+            fire = previous_epoch_detail.div(@period).floor != epoch_detail.div(@period).floor
           else
             iteration = updater.iteration
-            iteration > 0 && iteration % @period == 0
+            previous_iteration = @previous_iteration
+            if previous_iteration < 0
+                previous_iteration = iteration - 1
+            end
+            fire = previous_iteration.div(@period).floor != iteration.div(@period).floor
           end
+
+          # save current values
+          @previous_iteration = updater.iteration
+          @previous_epoch_detail = updater.epoch_detail
+        
+          fire
+        end
+
+        def serialize(serializer)
+          @previous_iteration = serializer.('previous_iteration', @previous_iteration)
+          @previous_epoch_detail = serializer.('previous_epoch_detail', @previous_epoch_detail)
         end
       end
     end

data/lib/chainer/version.rb

@@ -1,4 +1,4 @@
 module Chainer
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end
 

data/lib/chainer.rb

@@ -22,7 +22,10 @@ require 'chainer/variable_node'
 require 'chainer/utils/initializer'
 require 'chainer/utils/variable'
 require 'chainer/utils/array'
+require 'chainer/functions/activation/leaky_relu'
 require 'chainer/functions/activation/relu'
+require 'chainer/functions/activation/sigmoid'
+require 'chainer/functions/activation/tanh'
 require 'chainer/functions/activation/log_softmax'
 require 'chainer/functions/evaluation/accuracy'
 require 'chainer/functions/math/basic_math'
@@ -33,6 +36,7 @@ require 'chainer/training/extensions/evaluator'
 require 'chainer/training/extensions/log_report'
 require 'chainer/training/extensions/print_report'
 require 'chainer/training/extensions/progress_bar'
+require 'chainer/training/extensions/snapshot'
 require 'chainer/training/trainer'
 require 'chainer/training/updater'
 require 'chainer/training/util'
@@ -44,6 +48,8 @@ require 'chainer/dataset/download'
 require 'chainer/datasets/mnist'
 require 'chainer/datasets/tuple_dataset'
 require 'chainer/reporter'
+require 'chainer/serializer'
+require 'chainer/serializers/marshal'
 
 require 'numo/narray'
 

data/red-chainer.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   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_runtime_dependency "numo-narray", ">= 0.9.1.1"
 
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-chainer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Yusaku Hatanaka
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-18 00:00:00.000000000 Z
+date: 2018-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0.8
+        version: 0.9.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0.8
+        version: 0.9.1.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -92,8 +92,11 @@ files:
 - lib/chainer/datasets/mnist.rb
 - lib/chainer/datasets/tuple_dataset.rb
 - lib/chainer/function.rb
+- lib/chainer/functions/activation/leaky_relu.rb
 - lib/chainer/functions/activation/log_softmax.rb
 - lib/chainer/functions/activation/relu.rb
+- lib/chainer/functions/activation/sigmoid.rb
+- lib/chainer/functions/activation/tanh.rb
 - lib/chainer/functions/connection/linear.rb
 - lib/chainer/functions/evaluation/accuracy.rb
 - lib/chainer/functions/loss/softmax_cross_entropy.rb
@@ -112,11 +115,14 @@ files:
 - lib/chainer/optimizers/adam.rb
 - lib/chainer/parameter.rb
 - lib/chainer/reporter.rb
+- lib/chainer/serializer.rb
+- lib/chainer/serializers/marshal.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/extensions/snapshot.rb
 - lib/chainer/training/standard_updater.rb
 - lib/chainer/training/trainer.rb
 - lib/chainer/training/triggers/interval.rb
@@ -149,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: A flexible framework for neural network for Ruby