red-chainer 0.1.0

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

@@ -0,0 +1,72 @@
+require 'tempfile'
+require 'json'
+
+module Chainer
+  module Training
+    module Extensions
+      class LogReport < Extension
+        attr_reader :log
+
+        def initialize(keys: nil, trigger: [1, 'epoch'], postprocess: nil, log_name: 'log')
+          @keys = keys
+          @trigger = Chainer::Training::Util.get_trigger(trigger)
+          @postprocess = postprocess
+          @log_name = log_name
+          @log = []
+
+          init_summary
+        end
+
+        def call(trainer)
+          observation = trainer.observation
+
+          if @keys.nil?
+            @summary.add(observation)
+          else
+            symbolized_observation = Hash[observation.map{|(k,v)| [k.to_sym,v]}]
+            filterd_keys = @keys.select {|k| observation.keys.include?(k.to_sym) }
+            @summary.add(filterd_keys.each_with_object({}) {|k, hash| hash[k.to_s] = observation[k.to_sym] })            
+          end
+
+          # if trigger is true, output the result
+          return unless @trigger.(trainer)
+
+          stats = @summary.compute_mean
+          stats_cpu = {}
+          stats.each do |name, value|
+            stats_cpu[name] = value.to_f  # copy to CPU
+          end
+
+          updater = trainer.updater
+          stats_cpu['epoch'] = updater.epoch
+          stats_cpu['iteration'] = updater.iteration
+          stats_cpu['elapsed_time'] = trainer.elapsed_time
+        
+          @postprocess.(stats_cpu) unless @postprocess.nil?
+          
+          @log << stats_cpu
+
+          unless @log_name.nil?
+            # example: sprintf("%{a}, %{b}", {a: "1", b: "2"})
+            # => "1, 2"
+            log_name = sprintf(@log_name, stats_cpu)
+            temp_file = Tempfile.create(basename: log_name, tmpdir: trainer.out)
+
+            JSON.dump(@log, temp_file)
+
+            new_path = File.join(trainer.out, log_name)
+            FileUtils.mv(temp_file.path, new_path)
+          end
+
+          init_summary
+        end
+
+        private
+
+        def init_summary
+          @summary = DictSummary.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Chainer
+  module Training
+    module Extensions
+      class PrintReport < Extension
+        def initialize(entries, log_report: 'Chainer::Training::Extensions::LogReport', out: STDOUT)
+          @entries = entries
+          @log_report = log_report
+          @out = out
+
+          @log_len = 0 # number of observations already printed
+
+          # format information
+          entry_widths = entries.map { |s| [10, s.size].max }
+
+          templates = []
+          header = []
+          entries.zip(entry_widths).each do |entry, w|
+            header << sprintf("%-#{w}s", entry)
+            templates << [entry, "%-#{w}g  ", ' ' * (w + 2)]
+          end
+          @header = header.join('  ') + "\n"
+          @templates = templates
+        end
+
+        def call(trainer)
+          if @header
+            @out.write(@header)
+            @header = nil
+          end
+         
+          if @log_report.is_a?(String)
+            log_report = trainer.get_extension(@log_report)
+          elsif @log_report.is_a?(LogReport)
+            log_report.(trainer)
+          else
+            raise TypeError, "log report has a wrong type #{log_report.class}"
+          end
+
+          log = log_report.log
+          while log.size > @log_len
+            @out.write("\033[J")
+            print(log[@log_len])
+            @log_len += 1
+          end
+        end
+
+        private
+
+        def print(observation)
+          @templates.each do |entry, template, empty|
+            if observation.keys.include?(entry)
+              @out.write(sprintf(template, observation[entry]))
+            else
+              @out.write(empty)
+            end
+          end
+          @out.write("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'erb'
+
+module Chainer
+  module Training
+    module Extensions
+      class ProgressBar < Extension
+        def initialize(training_length: nil, update_interval: 100,  bar_length: 50, out: STDOUT)
+          @training_length = training_length
+          @status_template = nil
+          @update_interval = update_interval
+          @bar_length = bar_length
+          @out = out
+          @out.sync = true
+          @recent_timing = []
+        end
+
+        def call(trainer) 
+          if @training_length.nil?
+            t = trainer.stop_trigger
+            raise TypeError, "cannot retrieve the training length #{t.class}" unless t.is_a?(Chainer::Training::Triggers::IntervalTrigger)
+            @training_length = [t.period, t.unit]
+          end
+
+          if @status_template.nil?
+            @status_template = ERB.new("<%= sprintf('%10d', self.iteration) %> iter, <%= self.epoch %> epoch / #{@training_length[0]} #{@training_length[1]}s\n")
+          end
+
+          length, unit = @training_length
+          iteration = trainer.updater.iteration
+          
+          # print the progress bar according to interval
+          return unless iteration % @update_interval == 0
+
+          epoch = trainer.updater.epoch_detail
+          now = Time.now.to_f
+
+          @recent_timing << [iteration, epoch, now]
+          @out.write("\033[J")
+
+          if unit == 'iteration'
+            rate = iteration.to_f / length
+          else
+            rate = epoch.to_f / length
+          end
+
+          marks = '#' * (rate * @bar_length).to_i
+          @out.write(sprintf("     total [%s%s] %6.2f%\n", marks, '.' * (@bar_length - marks.size), rate * 100))
+
+          epoch_rate = epoch - epoch.to_i
+          marks = '#' * (epoch_rate * @bar_length).to_i
+          @out.write(sprintf("this epoch [%s%s] %6.2f%\n", marks, '.' * (@bar_length - marks.size), epoch_rate * 100))
+
+          status = @status_template.result(trainer.updater.bind)
+          @out.write(status)
+
+          old_t, old_e, old_sec = @recent_timing[0]
+          span = now - old_sec
+
+          if span.zero?
+            speed_t = Float::INFINITY
+            speed_e = Float::INFINITY
+          else
+            speed_t = (iteration - old_t) / span
+            speed_e = (epoch - old_e) / span
+          end
+
+          if unit == 'iteration'
+            estimated_time = (length - iteration) / speed_t
+          else
+            estimated_time = (length - epoch) / speed_e
+          end
+          
+          @out.write(sprintf("%10.5g iters/sec. Estimated time to finish: %s.\n", speed_t, (Time.parse("1991/01/01") + (estimated_time)).strftime("%H:%m:%S")))
+
+          # move the cursor to the head of the progress bar
+          @out.write("\033[4A") # TODO: Support Windows
+          @out.flush
+
+          @recent_timing.delete_at(0) if @recent_timing.size > 100
+        end
+
+        def finalize
+          @out.write("\033[J") # TODO: Support Windows
+          @out.flush
+        end
+      end
+    end
+  end
+end

data/lib/chainer/training/standard_updater.rb

@@ -0,0 +1,63 @@
+module Chainer
+  module Training
+    class StandardUpdater < Updater
+      attr_accessor :iteration
+
+      def initialize(iterator, optimizer, converter: nil, device: nil, loss_func: nil)
+        if iterator.kind_of?(Dataset::Iterator)
+          iterator = { main: iterator }
+        end
+        @iterators = iterator
+
+        unless optimizer.kind_of?(Hash)
+          optimizer = { main: optimizer }
+        end
+        @optimizers = optimizer
+
+        @converter = converter || Dataset::Convert.method(:concat_examples)
+        @loss_func = loss_func
+        @device = device
+        @iteration = 0
+      end
+
+      def get_all_optimizers
+        @optimizers.to_h
+      end
+
+      def update
+        update_core
+        @iteration += 1
+      end
+
+      def epoch
+        @iterators[:main].epoch
+      end
+
+      def epoch_detail
+        @iterators[:main].epoch_detail
+      end
+
+      def update_core
+        batch = @iterators[:main].next
+        in_arrays = @converter.call(batch, device: @device)
+
+        optimizer = @optimizers[:main]
+        loss_func = @loss_func || optimizer.target
+
+        if in_arrays.kind_of?(Array)
+          optimizer.update(loss_func, *in_arrays)
+        elsif in_arrays.kind_of?(Hash)
+          optimizer.update(loss_func, **in_arrays)
+        else
+          optimizer.update(loss_func, in_arrays)
+        end
+      end
+
+      def finalize
+        @iterators.each do |(_, iterator)|
+          iterator.finalize
+        end
+      end
+    end
+  end
+end

data/lib/chainer/training/trainer.rb

@@ -0,0 +1,136 @@
+module Chainer
+  module Training
+    class ExtensionEntry
+      attr_accessor :extension, :trigger, :invoke_before_training, :priority
+
+      def initialize(extension, priority, trigger, invoke_before_training)
+        @extension = extension
+        @trigger = trigger
+        @invoke_before_training = invoke_before_training
+        @priority = priority
+      end
+    end
+
+    class Trainer
+      attr_accessor :updater, :stop_trigger, :observation, :out
+
+      def initialize(updater, stop_trigger: nil, out: 'result')
+        @updater = updater
+        @stop_trigger = Chainer::Training::Util.get_trigger(stop_trigger)
+        @observation = {}
+        @out = out
+
+        reporter = Reporter.new
+        updater.get_all_optimizers().each do |(name, optimizer)|
+          reporter.add_observer(name, optimizer.target)
+          optimizer.target.namedlinks(skipself: true) do |suffix, observer|
+            observer_name = name.to_s + suffix
+            reporter.add_observer(observer_name, observer)
+          end
+        end
+        @reporter = reporter
+
+        @done = false
+        @extensions = {}
+
+        @start_at = nil
+        @snapshot_elapsed_time = 0.0
+        @final_elapsed_time = nil
+
+        updater.connect_trainer(self)
+      end
+
+      def elapsed_time
+        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
+      end
+
+      def extend(extension, name: nil, trigger: nil, priority: nil, invoke_before_training: nil)
+        if name.nil?
+          name = if extension.name
+                   extension.name
+                 elsif extension.default_name
+                   extension.default_name
+                 else
+                   raise ArgumentError 'name is not given for the extension'
+                 end
+        end
+
+        raise 'the name "training" is prohibited as an extension name' if name == 'training'
+
+        if trigger.nil?
+          trigger = extension.methods.include?(:trigger) ? extension.trigger : [1, 'iteration']
+        end
+        trigger = Chainer::Training::Util.get_trigger(trigger)
+
+        if priority.nil?
+          priority = extension.methods.include?(:priority) ? extension.priority : Extension::PRIORITY_READER
+        end
+
+        if invoke_before_training.nil?
+          invoke_before_training = extension.methods.include?(:invoke_before_training) ? extension.invoke_before_training : false
+        end
+
+        modified_name = name
+        ordinal = 0
+
+        @extensions.each do |modified_name|
+          ordinal += 1
+          modified_name = "#{name}_#{ordinal}"
+        end
+
+        extension.name = modified_name
+        @extensions[modified_name] = ExtensionEntry.new(extension, priority, trigger, invoke_before_training)
+      end
+
+      def get_extension(name)
+        if @extensions.keys.include?(name)
+          @extensions[name].extension
+        else
+          raise "extension #{name} not found"
+        end
+      end
+
+      def run
+        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] }
+
+        @start_at = Time.now.to_f
+
+        extensions.each do |(_, entry)|
+          initializer = entry.extension.methods.include?(:init) ? entry.extension.method(:init) : nil
+          initializer.call(self) if initializer
+        end
+
+        update = @updater.method(:update)
+        reporter = @reporter
+        stop_trigger = @stop_trigger
+
+        begin
+          until stop_trigger.(self) do
+            @observation = {}
+            reporter.scope(@observation) do
+              update.call
+              extensions.each do |(_, entry)|
+                entry.extension.(self) if entry.trigger.(self)
+              end
+            end
+          end
+        ensure
+          extensions.each do |(_, entry)|
+            finalize = entry.extension.methods.include?(:finalize) ? entry.extension.method(:finalize) : nil
+            finalize.() if finalize
+          end
+          @updater.finalize()
+        end
+
+        @final_elapsed_time = @elapsed_time
+        @done = true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Chainer
+  module Training
+    module Triggers
+      class IntervalTrigger
+        attr_reader :period, :unit, :count
+
+        def initialize(period, unit)
+          @period = period
+          @unit = unit
+          @count = 0
+        end
+
+        def call(trainer)
+          updater = trainer.updater
+          if @unit == 'epoch'
+            prev = @count
+            @count = updater.epoch_detail.div(@period)
+            prev != @count
+          else
+            iteration = updater.iteration
+            iteration > 0 && iteration % @period == 0
+          end
+        end
+      end
+    end
+  end
+end