onnx-red-chainer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8aa77d35c9473d25f6528d912569b9c87edd9f011ff84e5542590dff65ca4a6
+  data.tar.gz: ea3066bfb22cb81e82983347419143290347efdc79ebe2cce2d869ad90387de9
+SHA512:
+  metadata.gz: 285dd52ec849dbe6be77653556748e55256e2c1d19fe93c474b782ea54b20154dbc4e23cfa881de69a49522d7fcf12766ea6193a06effe10091c18a4f625c2de
+  data.tar.gz: 51afc59d523458206594b2f60ee6750ab2212ae106bf28ff8eee3c5e2a35ef7b03c09d1acbb23ab153830d5e2fbdde3bc610675061917a8f8fbadceef3f1e524

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in onnx-red-chainer.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    onnx-red-chainer (0.1.0)
+      google-protobuf
+      numo-narray
+      red-chainer
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    csv (3.0.8)
+    google-protobuf (3.7.1)
+    minitest (5.11.3)
+    numo-narray (0.9.1.4)
+    rake (10.5.0)
+    red-chainer (0.4.1)
+      numo-narray (>= 0.9.1.1)
+      red-datasets (>= 0.0.6)
+    red-datasets (0.0.8)
+      csv (>= 3.0.5)
+      rubyzip
+    rubyzip (1.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  minitest (~> 5.0)
+  onnx-red-chainer!
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 hatappi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Onnx RedChainer
+
+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/onnx/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 'onnx-red-chainer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install onnx-red-chainer
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/onnx-red-chainer.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "onnx/chainer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/onnx-red-chainer

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'onnx-chainer/cli'
+
+OnnxChainer::CLI.start(ARGV)

data/lib/onnx-chainer.rb

@@ -0,0 +1,16 @@
+require 'chainer'
+require "onnx-chainer/version"
+require "onnx-chainer/graph"
+require "onnx-chainer/proto/onnx_pb"
+
+module OnnxChainer
+  class Error < StandardError; end
+
+  def self.parse_file(onnx_path)
+    raise "File not found. #{onnx_path}" if onnx_path.nil? || !File.exists?(onnx_path)
+
+    m = Onnx::ModelProto.decode(File.read(onnx_path))
+
+    OnnxChainer::Graph.parse(m.graph)
+  end
+end

data/lib/onnx-chainer/cli.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'onnx-chainer'
+require 'json'
+require 'optparse'
+require 'pathname'
+
+module OnnxChainer
+  class CLI
+    def self.start(argv)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @parser = OptionParser.new do |opts|
+        opts.banner = 'onnx-red-chainer [OPTIONS] FILE'
+        opts.version = VERSION
+        opts.on('-o', '--output_dir=OUTPUT_DIR', 'output path') { |v| @output = v }
+        opts.on('-m', '--model_name=MODEL_NAME', 'Model name') { |v| @model_name = v }
+        opts.on('-h', '--help', 'show help') { @help = true }
+      end
+      @onnx_path = argv.pop
+      @parser.parse!(argv)
+    end
+
+    def run
+      if @help || @argv.empty?
+        puts @parser.help
+      else
+        graph = OnnxChainer.parse_file(@onnx_path)
+        graph.export(output_dir: @output, model_name: @model_name)
+      end
+    end
+  end
+end

data/lib/onnx-chainer/graph.rb

@@ -0,0 +1,125 @@
+require 'onnx-chainer/operators/gemm'
+require 'onnx-chainer/operators/relu'
+require 'numo/narray'
+
+module OnnxChainer
+  class Graph
+    attr_reader :nodes, :input_names, :output_names
+
+    class << self
+      def parse(onnx_graph)
+        nodes = onnx_graph.node
+        initializers = onnx_graph.initializer
+        outputs = onnx_graph.output
+
+        # take out input
+        initializer_names = onnx_graph.initializer.map(&:name)
+        call_inputs = onnx_graph.input.reject { |i| initializer_names.include?(i.name) }
+        name = 'x'
+        input_names = call_inputs.each_with_object({}) do |i, hash|
+          hash[i.name] = name
+          name = name.succ
+        end
+
+        # parse each node
+        output_name_index = {}
+        nodes = nodes.map do |n|
+          output_name_index[n.op_type] ||= 1
+          klass = operator_klass(n.op_type)
+          i_names = n.input.reject { |i| initializers.map(&:name).include?(i) }
+
+          node = klass.parse(n, i_names, onnx_graph.input, output_name_index[n.op_type])
+
+          output_name_index[n.op_type] += 1
+          node
+        end
+
+        # take out output
+        output_names = {}
+        nodes.each { |n| output_names.merge!(n.output_names) }
+
+        # parameter
+        target = {}
+        onnx_graph.initializer.each do |initializer|
+          name = initializer.name
+          dtype = dtype(initializer.data_type)
+
+          arr = dtype.from_binary(initializer.raw_data).reshape(*initializer.dims)
+
+          n = name.split('_')
+          target["/@#{n[1].downcase}/@#{n[2].downcase}"] =  dtype.from_binary(initializer.raw_data).reshape(*initializer.dims)
+        end
+
+        self.new(onnx_graph.name, nodes, input_names, output_names, target)
+      end
+
+      private
+
+      def operator_klass(op_type)
+        case op_type
+        when 'Gemm' then
+          return OnnxChainer::Operators::Gemm
+        when 'Relu' then
+          return OnnxChainer::Operators::Relu
+        end
+      end
+
+      def dtype(data_type)
+        if data_type == Onnx::TensorProto::DataType::FLOAT
+          Numo::SFloat
+        elsif data_type == Onnx::TensorProto::DataType::INT8
+          Numo::Int8
+        else
+          raise TypeError, 'unexpected value ' + data_type
+        end
+      end
+    end
+
+    def initialize(model_name, nodes, input_names, output_names, target)
+      @model_name = model_name
+      @nodes = nodes
+      @input_names = input_names
+      @output_names = output_names
+      @target = target
+    end
+
+    # export file
+    def export(output_dir: nil, model_name: nil)
+      model_name = model_name || @model_name
+      model_name = model_name.capitalize.gsub(/(?:^|_)(.)/){$1.upcase}
+
+      output_dir ||= '.'
+      FileUtils.mkdir(output_dir) unless Dir.exist?(output_dir)
+
+s = <<EOS
+require 'chainer'
+
+class #{model_name} < Chainer::Chain
+  def initialize()
+    super()
+    init_scope do
+      #{@nodes.select(&:need_initialized).map(&:to_initialize_string).join("\n      ")}
+    end
+  end
+
+  def call(#{@input_names.values.join(', ')})
+    #{
+      @nodes.map do |n|
+        args = n.input_names.map { |name| @input_names[name] || @output_names[name] }
+        n.to_call_string(args)
+      end.join("\n    ")
+    }
+  end
+end
+EOS
+
+      File.open("#{output_dir}/model.rb", 'w') do |f|
+        f.puts(s)
+      end
+
+      File.open("#{output_dir}/resume", 'wb+') do |f|
+        Marshal.dump(@target, f)
+      end
+    end
+  end
+end

data/lib/onnx-chainer/operator.rb

@@ -0,0 +1,24 @@
+module OnnxChainer
+  class Operator
+    attr_reader :need_initialized,
+                :output_names,
+                :input_names
+
+    class << self
+      def parse(node)
+      end
+    end
+
+    def chainer_class
+      raise NotImplementedError
+    end
+
+    def to_initialize_string
+      raise NotImplementedError
+    end
+
+    def to_call_string
+      raise NotImplementedError
+    end
+  end
+end

data/lib/onnx-chainer/operators/gemm.rb

@@ -0,0 +1,44 @@
+require 'onnx-chainer/operator'
+
+module OnnxChainer
+  module Operators
+    class Gemm < Operator
+      class << self
+        def parse(node, input_names, inputs, output_name_index)
+          bias_name = node.input.find { |i| i.match(/_b$/) }
+          input = inputs.find { |i| i.name == bias_name }
+          output_shape = input.type.tensor_type.shape.dim.map(&:dim_value)
+
+          need_initialized = node.input.any? { |i| inputs.map(&:name).include?(i) }
+
+          output_names = {
+            node.output.first => "l#{output_name_index}"
+          }
+          instance_variable_name = "@l#{output_name_index}"
+
+          self.new(input_names: input_names, output_shape: output_shape, output_names: output_names, instance_variable_name: instance_variable_name, need_initialized: need_initialized)
+        end
+      end
+
+      def initialize(input_names:, output_shape:, output_names:, instance_variable_name:, need_initialized:)
+        @input_names = input_names
+        @output_shape = output_shape
+        @output_names = output_names
+        @instance_variable_name = instance_variable_name
+        @need_initialized = need_initialized
+      end
+
+      def chainer_class
+        ::Chainer::Links::Connection::Linear
+      end
+
+      def to_initialize_string
+        "#{@instance_variable_name} = #{chainer_class}.new(nil, out_size: #{@output_shape})"
+      end
+
+      def to_call_string(args)
+        "#{@output_names.values.first} = #{@instance_variable_name}.(#{args.join(', ')})"
+      end
+    end
+  end
+end

data/lib/onnx-chainer/operators/relu.rb

@@ -0,0 +1,35 @@
+require 'onnx-chainer/operator'
+
+module OnnxChainer
+  module Operators
+    class Relu < Operator
+      class << self
+        def parse(node, input_names, inputs, output_name_index)
+          need_initialized = node.input.any? { |i| inputs.map(&:name).include?(i) }
+
+          output_names = {
+            node.output.first => "r#{output_name_index}"
+          }
+          instance_variable_name = "@r#{output_name_index}"
+
+          self.new(input_names: input_names, output_names: output_names, instance_variable_name: instance_variable_name, need_initialized: need_initialized)
+        end
+      end
+
+      def initialize(input_names:, output_names:, instance_variable_name:, need_initialized:)
+        @input_names = input_names
+        @output_names = output_names
+        @instance_variable_name = instance_variable_name
+        @need_initialized = need_initialized
+      end
+
+      def chainer_class
+        ::Chainer::Functions::Activation::Relu
+      end
+
+      def to_call_string(args)
+        "#{@output_names.values.first} = #{chainer_class}.relu(#{args.join(', ')})"
+      end
+    end
+  end
+end

data/lib/onnx-chainer/proto/onnx.proto

@@ -0,0 +1,483 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// Copyright (c) ONNX Project Contributors.
+// Licensed under the MIT license.
+
+syntax = "proto2";
+
+package onnx;
+
+// Overview
+//
+// ONNX is an open specification that is comprised of the following components:
+//
+// 1)  A definition of an extensible computation graph model.
+// 2)  Definitions of standard data types.
+// 3)  Definitions of built-in operators.
+//
+// This document describes the syntax of models and their computation graphs,
+// as well as the standard data types. Together, they are referred to as the ONNX
+// Intermediate Representation, or 'IR' for short. 
+//
+// The normative semantic specification of the ONNX IR is found in docs/IR.md.
+// Definitions of the built-in neural network operators may be found in docs/Operators.md.
+
+// Notes
+//
+// Release
+//
+// We are still in the very early stage of defining ONNX. The current
+// version of ONNX is a starting point. While we are actively working
+// towards a complete spec, we would like to get the community involved
+// by sharing our working version of ONNX.
+//
+// Protobuf compatibility
+// 
+// To simplify framework compatibility, ONNX is defined using the subset of protobuf 
+// that is compatible with both protobuf v2 and v3. This means that we do not use any
+// protobuf features that are only available in one of the two versions.
+//
+// Here are the most notable contortions we have to carry out to work around
+// these limitations:
+//
+//   - No 'map' (added protobuf 3.0). We instead represent mappings as lists
+//     of key-value pairs, where order does not matter and duplicates
+//     are not allowed.
+
+
+// Versioning
+//
+// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
+//
+// To be compatible with both proto2 and proto3, we will use a version number
+// that is not defined by the default value but an explicit enum number.
+enum Version {
+  // proto3 requires the first enum value to be zero.
+  // We add this just to appease the compiler.
+  _START_VERSION = 0;
+  // The version field is always serialized and we will use it to store the
+  // version that the  graph is generated from. This helps us set up version
+  // control. 
+  // For the IR, we are using simple numbers starting with with 0x00000001, 
+  // which was the version we published on Oct 10, 2017.
+  IR_VERSION_2017_10_10 = 0x0000000000000001;
+
+  // IR_VERSION 2 published on Oct 30, 2017
+  // - Added type discriminator to AttributeProto to support proto3 users
+  IR_VERSION_2017_10_30 = 0x0000000000000002;
+
+  // IR VERSION 3 published on Nov 3, 2017
+  // - For operator versioning:
+  //    - Added new message OperatorSetIdProto
+  //    - Added opset_import in ModelProto
+  // - For vendor extensions, added domain in NodeProto
+  IR_VERSION_2017_11_3 = 0x0000000000000003;
+
+  // IR VERSION 4 published on Jan 22, 2019
+  // - Relax constraint that initializers should be a subset of graph inputs
+  // - Add type BFLOAT16
+  IR_VERSION = 0x0000000000000004;
+}
+
+// Attributes
+//
+// A named attribute containing either singular float, integer, string, graph,
+// and tensor values, or repeated float, integer, string, graph, and tensor values.
+// An AttributeProto MUST contain the name field, and *only one* of the
+// following content fields, effectively enforcing a C/C++ union equivalent.
+message AttributeProto {
+
+  // Note: this enum is structurally identical to the OpSchema::AttrType
+  // enum defined in schema.h.  If you rev one, you likely need to rev the other.
+  enum AttributeType {
+    UNDEFINED = 0;
+    FLOAT = 1;
+    INT = 2;
+    STRING = 3;
+    TENSOR = 4;
+    GRAPH = 5;
+
+    FLOATS = 6;
+    INTS = 7;
+    STRINGS = 8;
+    TENSORS = 9;
+    GRAPHS = 10;
+  }
+
+  // The name field MUST be present for this version of the IR.
+  optional string name = 1;           // namespace Attribute
+ 
+  // if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function.
+  // In this case, this AttributeProto does not contain data, and it's a reference of attribute
+  // in parent scope.
+  // NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph.
+  optional string ref_attr_name = 21;
+
+  // A human-readable documentation for this attribute. Markdown is allowed.
+  optional string doc_string = 13;
+
+  // The type field MUST be present for this version of the IR.
+  // For 0.0.1 versions of the IR, this field was not defined, and
+  // implementations needed to use has_field hueristics to determine
+  // which value field was in use.  For IR_VERSION 0.0.2 or later, this
+  // field MUST be set and match the f|i|s|t|... field in use.  This
+  // change was made to accomodate proto3 implementations.
+  optional AttributeType type = 20;   // discriminator that indicates which field below is in use
+
+  // Exactly ONE of the following fields must be present for this version of the IR
+  optional float f = 2;               // float
+  optional int64 i = 3;               // int
+  optional bytes s = 4;               // UTF-8 string
+  optional TensorProto t = 5;         // tensor value
+  optional GraphProto g = 6;          // graph
+  // Do not use field below, it's deprecated.
+  // optional ValueProto v = 12;         // value - subsumes everything but graph
+
+  repeated float floats = 7;          // list of floats
+  repeated int64 ints = 8;            // list of ints
+  repeated bytes strings = 9;         // list of UTF-8 strings
+  repeated TensorProto tensors = 10;  // list of tensors
+  repeated GraphProto graphs = 11;    // list of graph
+}
+
+// Defines information on value, including the name, the type, and
+// the shape of the value.
+message ValueInfoProto {
+  // This field MUST be present in this version of the IR.
+  optional string name = 1;     // namespace Value
+  // This field MUST be present in this version of the IR.
+  optional TypeProto type = 2;
+  // A human-readable documentation for this value. Markdown is allowed.
+  optional string doc_string = 3;
+}
+
+// Nodes
+//
+// Computation graphs are made up of a DAG of nodes, which represent what is
+// commonly called a "layer" or "pipeline stage" in machine learning frameworks.
+//
+// For example, it can be a node of type "Conv" that takes in an image, a filter 
+// tensor and a bias tensor, and produces the convolved output.
+message NodeProto {
+  repeated string input = 1;    // namespace Value
+  repeated string output = 2;   // namespace Value
+
+  // An optional identifier for this node in a graph.
+  // This field MAY be absent in ths version of the IR.
+  optional string name = 3;     // namespace Node
+
+  // The symbolic identifier of the Operator to execute.
+  optional string op_type = 4;  // namespace Operator
+  // The domain of the OperatorSet that specifies the operator named by op_type.
+  optional string domain = 7;   // namespace Domain
+
+  // Additional named attributes.
+  repeated AttributeProto attribute = 5;
+
+  // A human-readable documentation for this node. Markdown is allowed.
+  optional string doc_string = 6;
+}
+
+// Models
+//
+// ModelProto is a top-level file/container format for bundling a ML model and
+// associating its computation graph with metadata.
+//
+// The semantics of the model are described by the associated GraphProto.
+message ModelProto {
+  // The version of the IR this model targets. See Version enum above.
+  // This field MUST be present.
+  optional int64 ir_version = 1;
+
+  // The OperatorSets this model relies on.
+  // All ModelProtos MUST have at least one entry that
+  // specifies which version of the ONNX OperatorSet is
+  // being imported.
+  //
+  // All nodes in the ModelProto's graph will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets.
+  repeated OperatorSetIdProto opset_import = 8;
+
+  // The name of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_name = 2;
+
+  // The version of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_version = 3;
+
+  // Domain name of the model.
+  // We use reverse domain names as name space indicators. For example:
+  // `com.facebook.fair` or `com.microsoft.cognitiveservices`
+  //
+  // Together with `model_version` and GraphProto.name, this forms the unique identity of
+  // the graph.
+  optional string domain = 4;
+
+  // The version of the graph encoded. See Version enum below.
+  optional int64 model_version = 5;
+
+  // A human-readable documentation for this model. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // The parameterized graph that is evaluated to execute the model.
+  optional GraphProto graph = 7;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+};
+
+// StringStringEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message StringStringEntryProto {
+  optional string key = 1;
+  optional string value= 2;
+};
+
+// Graphs
+//
+// A graph defines the computational logic of a model and is comprised of a parameterized 
+// list of nodes that form a directed acyclic graph based on their inputs and outputs.
+// This is the equivalent of the "network" or "graph" in many deep learning
+// frameworks.
+message GraphProto {
+  // The nodes in the graph, sorted topologically.
+  repeated NodeProto node = 1;
+
+  // The name of the graph.
+  optional string name = 2;   // namespace Graph
+
+  // A list of named tensor values, used to specify constant inputs of the graph.
+  // Each TensorProto entry must have a distinct name (within the list) that
+  // MAY also appear in the input list.
+  repeated TensorProto initializer = 5;
+
+  // A human-readable documentation for this graph. Markdown is allowed.
+  optional string doc_string = 10;
+
+  // The inputs and outputs of the graph.
+  repeated ValueInfoProto input = 11;
+  repeated ValueInfoProto output = 12;
+
+  // Information for the values in the graph. The ValueInfoProto.name's
+  // must be distinct. It is optional for a value to appear in value_info list.
+  repeated ValueInfoProto value_info = 13;
+
+  // DO NOT USE the following fields, they were deprecated from earlier versions.
+  // repeated string input = 3;
+  // repeated string output = 4;
+  // optional int64 ir_version = 6;
+  // optional int64 producer_version = 7;
+  // optional string producer_tag = 8;
+  // optional string domain = 9;
+}
+
+// Tensors
+//
+// A serialized tensor value.
+message TensorProto {
+  enum DataType {
+    UNDEFINED = 0;
+    // Basic types.
+    FLOAT = 1;   // float
+    UINT8 = 2;   // uint8_t
+    INT8 = 3;    // int8_t
+    UINT16 = 4;  // uint16_t
+    INT16 = 5;   // int16_t
+    INT32 = 6;   // int32_t
+    INT64 = 7;   // int64_t
+    STRING = 8;  // string
+    BOOL = 9;    // bool
+
+    // IEEE754 half-precision floating-point format (16 bits wide).
+    // This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+    FLOAT16 = 10;
+
+    DOUBLE = 11;
+    UINT32 = 12;
+    UINT64 = 13;
+    COMPLEX64 = 14;     // complex with float32 real and imaginary components
+    COMPLEX128 = 15;    // complex with float64 real and imaginary components
+
+    // Non-IEEE floating-point format based on IEEE754 single-precision
+    // floating-point number truncated to 16 bits.
+    // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
+    BFLOAT16 = 16;
+
+    // Future extensions go here.
+  }
+
+  // The shape of the tensor.
+  repeated int64 dims = 1;
+
+  // The data type of the tensor.
+  // This field MUST have a valid TensorProto.DataType value
+  optional int32 data_type = 2;
+
+  // For very large tensors, we may want to store them in chunks, in which
+  // case the following fields will specify the segment that is stored in
+  // the current TensorProto.
+  message Segment {
+    optional int64 begin = 1;
+    optional int64 end = 2;
+  }
+  optional Segment segment = 3;
+
+  // Tensor content must be organized in row-major order.
+  //
+  // Depending on the data_type field, exactly one of the fields below with
+  // name ending in _data is used to store the elements of the tensor.
+
+  // For float and complex64 values
+  // Complex64 tensors are encoded as a single array of floats,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component apparing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
+  repeated float float_data = 4 [packed = true];
+
+  // For int32, uint8, int8, uint16, int16, bool, and float16 values
+  // float16 values must be bit-wise converted to an uint16_t prior
+  // to writing to the buffer.
+  // When this field is present, the data_type field MUST be
+  // INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16
+  repeated int32 int32_data = 5 [packed = true];
+
+  // For strings.
+  // Each element of string_data is a UTF-8 encoded Unicode
+  // string. No trailing null, no leading BOM. The protobuf "string"
+  // scalar type is not used to match ML community conventions.
+  // When this field is present, the data_type field MUST be STRING
+  repeated bytes string_data = 6;
+
+  // For int64.
+  // When this field is present, the data_type field MUST be INT64
+  repeated int64 int64_data = 7 [packed = true];
+
+  // Optionally, a name for the tensor.
+  optional string name = 8; // namespace Value
+
+  // A human-readable documentation for this tensor. Markdown is allowed.
+  optional string doc_string = 12;
+
+  // Serializations can either use one of the fields above, or use this
+  // raw bytes field. The only exception is the string case, where one is
+  // required to store the content in the repeated bytes string_data field.
+  //
+  // When this raw_data field is used to store tensor value, elements MUST
+  // be stored in as fixed-width, little-endian order.
+  // Floating-point data types MUST be stored in IEEE 754 format.
+  // Complex64 elements must be written as two consecutive FLOAT values, real component first.
+  // Complex128 elements must be written as two consecutive DOUBLE values, real component first.
+  // Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
+  //
+  // Note: the advantage of specific field rather than the raw_data field is
+  // that in some cases (e.g. int data), protobuf does a better packing via
+  // variable length storage, and may lead to smaller binary footprint.
+  // When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
+  optional bytes raw_data = 9;
+
+  // Data can be stored inside the protobuf file using type-specific fields or raw_data.
+  // Alternatively, raw bytes data can be stored in an external file, using the external_data field.
+  // external_data stores key-value pairs describing data location. Recognized keys are:
+  // - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
+  //                           protobuf model was stored
+  // - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
+  //                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
+  // - "length" (optional) - number of bytes containing data. Integer stored as string.
+  // - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
+  repeated StringStringEntryProto external_data = 13;
+
+  // Location of the data for this tensor. MUST be one of:
+  // - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field.
+  // - EXTERNAL - data stored in an external location as described by external_data field.
+  enum DataLocation {
+    DEFAULT = 0;
+    EXTERNAL = 1;
+  }
+
+  // If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
+  optional DataLocation data_location = 14;
+
+  // For double
+  // Complex128 tensors are encoded as a single array of doubles,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component apparing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
+  repeated double double_data = 10 [packed = true];
+
+  // For uint64 and uint32 values
+  // When this field is present, the data_type field MUST be
+  // UINT32 or UINT64
+  repeated uint64 uint64_data = 11 [packed = true];
+}
+
+// Defines a tensor shape. A dimension can be either an integer value
+// or a symbolic variable. A symbolic variable represents an unknown
+// dimension.
+message TensorShapeProto {
+  message Dimension {
+    oneof value {
+      int64 dim_value = 1;
+      string dim_param = 2;   // namespace Shape
+    };
+    // Standard denotation can optionally be used to denote tensor
+    // dimensions with standard semantic descriptions to ensure
+    // that operations are applied to the correct axis of a tensor.
+    // Refer to https://github.com/onnx/onnx/blob/master/docs/DimensionDenotation.md#denotation-definition
+    // for pre-defined dimension denotations.
+    optional string denotation = 3;
+  };
+  repeated Dimension dim = 1;
+}
+
+// Types
+//
+// The standard ONNX data types.
+message TypeProto {
+
+  message Tensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    optional int32 elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+
+
+  oneof value {
+    // The type of a tensor.
+    Tensor tensor_type = 1;
+
+  }
+
+  // An optional denotation can be used to denote the whole 
+  // type with a standard semantic description as to what is 
+  // stored inside. Refer to https://github.com/onnx/onnx/blob/master/docs/TypeDenotation.md#type-denotation-definition
+  // for pre-defined type denotations.
+  optional string denotation = 6;
+}
+
+// Operator Sets
+//
+// OperatorSets are uniquely identified by a (domain, opset_version) pair.
+message OperatorSetIdProto {
+  // The domain of the operator set being identified.
+  // The empty string ("") or absence of this field implies the operator
+  // set that is defined as part of the ONNX specification.
+  // This field MUST be present in this version of the IR when referring to any other operator set.
+  optional string domain = 1;
+
+  // The version of the operator set being identified.
+  // This field MUST be present in this version of the IR.
+  optional int64 version = 2;
+}

data/lib/onnx-chainer/proto/onnx_pb.rb

@@ -0,0 +1,170 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lib/onnx.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("lib/onnx.proto", :syntax => :proto2) do
+    add_message "onnx.AttributeProto" do
+      optional :name, :string, 1
+      optional :ref_attr_name, :string, 21
+      optional :doc_string, :string, 13
+      optional :type, :enum, 20, "onnx.AttributeProto.AttributeType"
+      optional :f, :float, 2
+      optional :i, :int64, 3
+      optional :s, :bytes, 4
+      optional :t, :message, 5, "onnx.TensorProto"
+      optional :g, :message, 6, "onnx.GraphProto"
+      repeated :floats, :float, 7
+      repeated :ints, :int64, 8
+      repeated :strings, :bytes, 9
+      repeated :tensors, :message, 10, "onnx.TensorProto"
+      repeated :graphs, :message, 11, "onnx.GraphProto"
+    end
+    add_enum "onnx.AttributeProto.AttributeType" do
+      value :UNDEFINED, 0
+      value :FLOAT, 1
+      value :INT, 2
+      value :STRING, 3
+      value :TENSOR, 4
+      value :GRAPH, 5
+      value :FLOATS, 6
+      value :INTS, 7
+      value :STRINGS, 8
+      value :TENSORS, 9
+      value :GRAPHS, 10
+    end
+    add_message "onnx.ValueInfoProto" do
+      optional :name, :string, 1
+      optional :type, :message, 2, "onnx.TypeProto"
+      optional :doc_string, :string, 3
+    end
+    add_message "onnx.NodeProto" do
+      repeated :input, :string, 1
+      repeated :output, :string, 2
+      optional :name, :string, 3
+      optional :op_type, :string, 4
+      optional :domain, :string, 7
+      repeated :attribute, :message, 5, "onnx.AttributeProto"
+      optional :doc_string, :string, 6
+    end
+    add_message "onnx.ModelProto" do
+      optional :ir_version, :int64, 1
+      repeated :opset_import, :message, 8, "onnx.OperatorSetIdProto"
+      optional :producer_name, :string, 2
+      optional :producer_version, :string, 3
+      optional :domain, :string, 4
+      optional :model_version, :int64, 5
+      optional :doc_string, :string, 6
+      optional :graph, :message, 7, "onnx.GraphProto"
+      repeated :metadata_props, :message, 14, "onnx.StringStringEntryProto"
+    end
+    add_message "onnx.StringStringEntryProto" do
+      optional :key, :string, 1
+      optional :value, :string, 2
+    end
+    add_message "onnx.GraphProto" do
+      repeated :node, :message, 1, "onnx.NodeProto"
+      optional :name, :string, 2
+      repeated :initializer, :message, 5, "onnx.TensorProto"
+      optional :doc_string, :string, 10
+      repeated :input, :message, 11, "onnx.ValueInfoProto"
+      repeated :output, :message, 12, "onnx.ValueInfoProto"
+      repeated :value_info, :message, 13, "onnx.ValueInfoProto"
+    end
+    add_message "onnx.TensorProto" do
+      repeated :dims, :int64, 1
+      optional :data_type, :int32, 2
+      optional :segment, :message, 3, "onnx.TensorProto.Segment"
+      repeated :float_data, :float, 4
+      repeated :int32_data, :int32, 5
+      repeated :string_data, :bytes, 6
+      repeated :int64_data, :int64, 7
+      optional :name, :string, 8
+      optional :doc_string, :string, 12
+      optional :raw_data, :bytes, 9
+      repeated :external_data, :message, 13, "onnx.StringStringEntryProto"
+      optional :data_location, :enum, 14, "onnx.TensorProto.DataLocation"
+      repeated :double_data, :double, 10
+      repeated :uint64_data, :uint64, 11
+    end
+    add_message "onnx.TensorProto.Segment" do
+      optional :begin, :int64, 1
+      optional :end, :int64, 2
+    end
+    add_enum "onnx.TensorProto.DataType" do
+      value :UNDEFINED, 0
+      value :FLOAT, 1
+      value :UINT8, 2
+      value :INT8, 3
+      value :UINT16, 4
+      value :INT16, 5
+      value :INT32, 6
+      value :INT64, 7
+      value :STRING, 8
+      value :BOOL, 9
+      value :FLOAT16, 10
+      value :DOUBLE, 11
+      value :UINT32, 12
+      value :UINT64, 13
+      value :COMPLEX64, 14
+      value :COMPLEX128, 15
+      value :BFLOAT16, 16
+    end
+    add_enum "onnx.TensorProto.DataLocation" do
+      value :DEFAULT, 0
+      value :EXTERNAL, 1
+    end
+    add_message "onnx.TensorShapeProto" do
+      repeated :dim, :message, 1, "onnx.TensorShapeProto.Dimension"
+    end
+    add_message "onnx.TensorShapeProto.Dimension" do
+      optional :denotation, :string, 3
+      oneof :value do
+        optional :dim_value, :int64, 1
+        optional :dim_param, :string, 2
+      end
+    end
+    add_message "onnx.TypeProto" do
+      optional :denotation, :string, 6
+      oneof :value do
+        optional :tensor_type, :message, 1, "onnx.TypeProto.Tensor"
+      end
+    end
+    add_message "onnx.TypeProto.Tensor" do
+      optional :elem_type, :int32, 1
+      optional :shape, :message, 2, "onnx.TensorShapeProto"
+    end
+    add_message "onnx.OperatorSetIdProto" do
+      optional :domain, :string, 1
+      optional :version, :int64, 2
+    end
+    add_enum "onnx.Version" do
+      value :_START_VERSION, 0
+      value :IR_VERSION_2017_10_10, 1
+      value :IR_VERSION_2017_10_30, 2
+      value :IR_VERSION_2017_11_3, 3
+      value :IR_VERSION, 4
+    end
+  end
+end
+
+module Onnx
+  AttributeProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.AttributeProto").msgclass
+  AttributeProto::AttributeType = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.AttributeProto.AttributeType").enummodule
+  ValueInfoProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.ValueInfoProto").msgclass
+  NodeProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.NodeProto").msgclass
+  ModelProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.ModelProto").msgclass
+  StringStringEntryProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.StringStringEntryProto").msgclass
+  GraphProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.GraphProto").msgclass
+  TensorProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TensorProto").msgclass
+  TensorProto::Segment = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TensorProto.Segment").msgclass
+  TensorProto::DataType = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TensorProto.DataType").enummodule
+  TensorProto::DataLocation = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TensorProto.DataLocation").enummodule
+  TensorShapeProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TensorShapeProto").msgclass
+  TensorShapeProto::Dimension = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TensorShapeProto.Dimension").msgclass
+  TypeProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TypeProto").msgclass
+  TypeProto::Tensor = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.TypeProto.Tensor").msgclass
+  OperatorSetIdProto = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.OperatorSetIdProto").msgclass
+  Version = Google::Protobuf::DescriptorPool.generated_pool.lookup("onnx.Version").enummodule
+end

data/lib/onnx-chainer/version.rb

@@ -0,0 +1,3 @@
+module OnnxChainer
+  VERSION = "0.1.0"
+end

data/onnx-red-chainer.gemspec

@@ -0,0 +1,31 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "onnx-chainer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "onnx-red-chainer"
+  spec.version       = OnnxChainer::VERSION
+  spec.authors       = ["hatappi"]
+  spec.email         = ["hatappi@hatappi.me"]
+
+  spec.summary       = "Automatically generate Ruby code from ONNX"
+  spec.description   = "Automatically generate Ruby code from ONNX"
+  spec.homepage      = "https://github.com/hatappi/onnx-red-chainer"
+  spec.license       = "MIT"
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |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_dependency 'google-protobuf'
+  spec.add_dependency 'red-chainer'
+  spec.add_dependency "numo-narray"
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end
+

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: onnx-red-chainer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- hatappi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: red-chainer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Automatically generate Ruby code from ONNX
+email:
+- hatappi@hatappi.me
+executables:
+- onnx-red-chainer
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/onnx-red-chainer
+- lib/onnx-chainer.rb
+- lib/onnx-chainer/cli.rb
+- lib/onnx-chainer/graph.rb
+- lib/onnx-chainer/operator.rb
+- lib/onnx-chainer/operators/gemm.rb
+- lib/onnx-chainer/operators/relu.rb
+- lib/onnx-chainer/proto/onnx.proto
+- lib/onnx-chainer/proto/onnx_pb.rb
+- lib/onnx-chainer/version.rb
+- onnx-red-chainer.gemspec
+homepage: https://github.com/hatappi/onnx-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.7.6
+signing_key: 
+specification_version: 4
+summary: Automatically generate Ruby code from ONNX
+test_files: []